str2list:
 Todo Clases Archivos Funciones 'defines'
Clases | 'defines' | Funciones
Referencia del Archivo str2list.h

Funciones para crear listas y matrices a partir de hileras. Más...

#include <list>
#include <string>
#include <cstdlib>
#include <cstring>

Ir al código fuente de este archivo.

Clases

struct  str2list_int_wrap
 Empaque ATON() alrededor de la función atoi(). Más...
 
struct  str2list_long_wrap
 Empaque ATON() alrededor de la función atol(). Más...
 
struct  str2list_double_wrap
 Empaque ATON() alrededor de la función atof(). Más...
 

'defines'

#define str2list_h
 Evita la inclusión múltiple.
 

Funciones

template<class CHAR >
bool iswhitespace_str2list (CHAR ch)
 Retorna true para todos los caracters considerados como espacios en blanco por str2list().
 
template<class STRING >
const char * str2list (std::list< STRING > &L, const char *str)
 Almacena en "L<>" la lista de hileras construida en base a "str".
 
std::list< std::string > str2list (const char *str)
 Usa str2list(L,str) para retornar la lista de valores de "str".
 
template<class N , class ATON_wrap >
std::list< N > str2list_wrap (const char *str)
 Retorna la lista de valores construida en base a "str".
 
std::list< int > intlist (const char *str)
 Sinónimo de makeList_int().
 
std::list< int > makeList_int (const char *str)
 Retorna la lista de enteros (int) construida en base a "str".
 
std::list< long > longlist (const char *str)
 Sinónimo de makeList_long().
 
std::list< long > makeList_long (const char *str)
 Retorna la lista de enteros (long) construida en base a "str".
 
std::list< double > doublelist (const char *str)
 Retorna la lista de flotantes construida en base a "str".
 
std::list< char > charlist (const char *str)
 Sinónimo de makeList_char().
 
std::list< char > makeList_char (const char *str)
 Retorna la lista de caracteres (char) construida en base a "str".
 
template<class STRING >
size_t str2matrix (std::list< std::list< STRING > > &M, const char *str)
 Almacena en "M<<>>" la matriz de hileras construida en base a "str".
 
template<class N , class ATON_wrap , unsigned Nrows, unsigned Ncols>
void matrix2list_wrap (N MATRIX[Nrows][Ncols], const char *str)
 Almacena en MATRIX[][] la matriz construida en base a "str".
 
template<unsigned Nrows, unsigned Ncols>
void intmatrix (int M[Nrows][Ncols], const char *str)
 Almacena en M[][] la matriz de enteros (int) construida en base a "str".
 
template<unsigned Nrows, unsigned Ncols>
void longmatrix (long M[Nrows][Ncols], const char *str)
 Almacena en M[][] la matriz de enteros (long) construida en base a "str".
 
template<unsigned Nrows, unsigned Ncols>
void doublematrix (double M[Nrows][Ncols], const char *str)
 Almacena en M[][] la matriz de flotantes construida en base a "str".
 
template<unsigned Nrows, unsigned Ncols>
void charmatrix (char M[Nrows][Ncols], const char *str)
 Almacena en M[][] la matriz de caracteres construida en base a "str".
 

Descripción detallada

Funciones para crear listas y matrices a partir de hileras.

Autor
Adolfo Di Mare adolf.nosp@m.o@di.nosp@m.-mare.nosp@m..com
Fecha
2011

Definición en el archivo str2list.h.

Documentación de los 'defines'

#define str2list_h

Evita la inclusión múltiple.

Definición en la línea 11 del archivo str2list.h.

Documentación de las funciones

template<class CHAR >
bool iswhitespace_str2list ( CHAR  ch)

Retorna true para todos los caracters considerados como espacios en blanco por str2list().

  • { , () <> {} [] } && isspace().
  • El punto char('.') no es considerado espacio en blanco ( pues forma parte de un número flotante: 1.0e22 ).
  • false == iswhitespace_str2list( '.' ) .
{{ // test::iswhitespace()
const char blank = ' ';
assertTrue( iswhitespace_str2list(blank) ); assertTrue( iswhitespace_str2list(',') );
assertTrue( ! iswhitespace_str2list('.') ); assertFalse( iswhitespace_str2list('.') );
assertTrue( ! iswhitespace_str2list('\0') ); assertFalse( iswhitespace_str2list('\0') );
assertTrue( iswhitespace_str2list('(') ); assertTrue( iswhitespace_str2list(')') );
assertTrue( iswhitespace_str2list('[') ); assertTrue( iswhitespace_str2list(']') );
assertTrue( iswhitespace_str2list('{') ); assertTrue( iswhitespace_str2list('}') );
assertTrue( iswhitespace_str2list('<') ); assertTrue( iswhitespace_str2list('>') );
assertTrue( iswhitespace_str2list('\r') ); assertTrue( iswhitespace_str2list('\n') );
assertTrue( iswhitespace_str2list('\f') );
assertTrue( iswhitespace_str2list('\t') ); assertTrue( iswhitespace_str2list('\v') );
}}

Ver también
test_str2list::test_iswhitespace()

Definición en la línea 30 del archivo str2list.h.

template<class STRING >
const char* str2list ( std::list< STRING > &  L,
const char *  str 
)

Almacena en "L<>" la lista de hileras construida en base a "str".

  • En "str" están los valores que serán almacenados en "L<>" separados por varios delimitadores.
  • Como delimitadores se usan los caracteres blancos y la coma.
  • Como delimitadores se usan los caracteres ispace() y ','.
  • El punto '.' no se interpreta como delimitador.
  • Los caracteres { , () <> {} [] } son interpretados como blancos y no verifica que estén balanceados o en parejas.
  • Ignora el paréntesis del principio y del final de "str".
  • Si al principio encuentra el caracter '|' procesa la hilera hasta que encuentra el siguiente caracter '|'.
  • No examina lo que está después de la barrita final '|'.
  • Siempre modifica el valor de "L<>".
  • Retorna la última posición de "str" que fue examinada.
{{ // test::str2list::list()
std::list<std::string> Li,Lj,Lk,Ll;
str2list( Li , "( 1 22 333 4444 5555 )" );
str2list( Lj , "< 1,22,333,4444,5555 > | del " );
str2list( Lk , "{ 1 22 333 4444 5555 } | del " );
str2list( Ll , "[ 1.22.333.4444.5555 ] | del " ); // '.' NO '.'
std::list<std::string> :: const_iterator itI,itJ,itK,itL;
itI = Li.begin(); itJ = Lj.begin(); itK = Lk.begin(); itL = Ll.begin();
assertTrue( *itI == "1" ); assertTrue( *itI++ == *itJ++ );
assertTrue( *itI == "22" ); assertTrue( *itI++ == *itJ++ );
assertTrue( *itI == "333" ); assertTrue( *itI++ == *itJ++ );
assertTrue( *itI == "4444" ); assertTrue( *itI++ == *itJ++ );
assertTrue( *itI == "5555" ); assertTrue( *itI++ == *itJ++ );
assertTrue( 5 == Li.size() ); assertTrue( 5 == Lj.size() );
assertTrue( Li == Lj && Lj == Lk && ((Lk != Ll)) ); // '.' NO '.'
assertTrue( *itL == "1.22.333.4444.5555" ); // '.' NO '.'
assertTrue( 1 == Ll.size() && Ll.size() < 2 );
}}

Ver también
test_str2list::str2list_list()

Definición en la línea 62 del archivo str2list.h.

std::list<std::string> str2list ( const char *  str)
inline

Usa str2list(L,str) para retornar la lista de valores de "str".

{{ // test::str2list::example()
assertTrue( str2list("").empty() && "list<>.empty() !!!" );
assertTrue( str2list("") == str2list("()") );
assertTrue( str2list("()") == str2list(" | | del ") );
assertTrue( str2list("{}").size() == 0 );
assertTrue( str2list("[0]") == str2list("| 0 |") );
assertTrue( str2list("(0,1,, ,,2)") == str2list("( 0 1 2 )") );
assertTrue( str2list("( 1 2 3 4 5 )") == str2list("| 1 2 3 4 5 |") );
assertTrue( str2list("(,'c',,'j',)" ) == str2list( "< 'c' 'j' >") );
assertTrue( str2list(" |a| etc... ") == str2list("( a )") );
assertTrue( str2list(" |a| etc... ").size() == 1 );
assertTrue( str2list(" |a| etc... ") == str2list("| a | #1") );
}}

Ver también
test_str2list::str2list_example()

Definición en la línea 104 del archivo str2list.h.

template<class N , class ATON_wrap >
std::list<N> str2list_wrap ( const char *  str)

Retorna la lista de valores construida en base a "str".

Usa str2list() junto con ATON_wrap::ATON().

Parámetros del template
Ntipo de dato: { int long double }
ATON_wrapEmpaque ATON() alrededor del convertidor: { atoi() atol() atof() }.

Definición en la línea 117 del archivo str2list.h.

std::list<int> intlist ( const char *  str)
inline

Sinónimo de makeList_int().

Definición en la línea 147 del archivo str2list.h.

std::list<int> makeList_int ( const char *  str)
inline

Retorna la lista de enteros (int) construida en base a "str".

Usa str2list() junto con atoi().

{{ // test::intlist()
std::list<int> Li, Lj;
Li = intlist( "()" ); assertTrue( Li.empty() );
Li = intlist( " ( ) " ); assertTrue( Li.empty() );
Li = intlist( "(1 2 3 4 5)" );
for ( int j=1; j<=5; ++j ) {
Lj.push_back( j );
}
assertTrue( Li == Lj );
assertTrue( intlist( "( ... )" ) == intlist( "( 0 )" ) );
assertTrue( intlist( "( ... )" ).size() == 1 );
assertTrue( intlist( "(0)" ) == intlist( "( - )" ) );
assertTrue( intlist( "(0)" ) == intlist( "( + )" ) );
assertTrue( intlist( "()" ) == intlist( "( )" ) );
assertTrue( intlist( "( 1 2 3 4 5 )" ) == intlist( "(1,2,3,4,5)" ) );
assertTrue( intlist( "{ 1,2,3,4,5 }" ) == intlist( "[1 2 3 4 5]" ) );
Li = intlist( "( 1,22,333,4444,5555 )" );
Lj = intlist( "(1,22,333,4444,5555)" );
assertTrue( Li == Lj );
Li = intlist( "(1 , - + 22, -333, - 4444, --5555)" );
Lj = intlist( "(1, 0,0,22, -333, 0,4444, 0)" );
assertTrue( Li == Lj );
Li = intlist( "( 1, 22, 333, 4444, 5555 )" );
Lj = intlist( "| [1] [22] [333] [4444] [5555] |... ignore");
assertTrue( Li == Lj );
Li = intlist( "( 1, 22, 333, 4444, 5555, 0, 0 )" );
Lj = intlist( "( [1] [22] [333] [4444] [5555] )etc ...");
assertTrue( Li == Lj );
}}

Ver también
test_str2list::test_intlist()

Definición en la línea 159 del archivo str2list.h.

std::list<long> longlist ( const char *  str)
inline

Sinónimo de makeList_long().

Definición en la línea 164 del archivo str2list.h.

std::list<long> makeList_long ( const char *  str)
inline

Retorna la lista de enteros (long) construida en base a "str".

Usa str2list() junto con atol().

{{ // test::makeList_long()
std::list<long> Li, Lj;
Li = makeList_long( "()" ); assertTrue( Li.empty() );
Li = makeList_long( " ( ) " ); assertTrue( Li.empty() );
Li = makeList_long( "(1 2 3 4 5)" );
for ( int j=1; j<=5; ++j ) {
Lj.push_back( j );
}
assertTrue( Li == Lj );
assertTrue( makeList_long( "( ... )" ) == makeList_long( "( 0 )" ) );
assertTrue( makeList_long( "( ... )" ).size() == 1 );
assertTrue( makeList_long( "(0)" ) == makeList_long( "( - )" ) );
assertTrue( makeList_long( "(0)" ) == makeList_long( "( + )" ) );
assertTrue( makeList_long( "()" ) == makeList_long( "( )" ) );
assertTrue( makeList_long( "( 1 2 3 4 5 )" ) == makeList_long( "(1,2,3,4,5)" ) );
assertTrue( makeList_long( "{ 1,2,3,4,5 }" ) == makeList_long( "[1 2 3 4 5]" ) );
Li = makeList_long( "( 1,22,333,4444,5555 )" );
Lj = makeList_long( "(1,22,333,4444,5555)" );
assertTrue( Li == Lj );
Li = makeList_long( "(1 , - + 22, -333, - 4444, --5555)" );
Lj = makeList_long( "(1, 0,0,22, -333, 0,4444, 0)" );
assertTrue( Li == Lj );
Li = makeList_long( "( 1, 22, 333, 4444, 5555 )" );
Lj = makeList_long( "| [1] [22] [333] [4444] [5555] |... ignore");
assertTrue( Li == Lj );
Li = makeList_long( "( 1, 22, 333, 4444, 5555, 0, 0 )" );
Lj = makeList_long( "( [1] [22] [333] [4444] [5555] )etc ...");
assertTrue( Li == Lj );
}}

Ver también
test_str2list::test_makeList_long()

Definición en la línea 176 del archivo str2list.h.

std::list<double> doublelist ( const char *  str)
inline

Retorna la lista de flotantes construida en base a "str".

Usa str2list() junto con atof().

{{ // test::doublelist()
std::list<double> Li, Lj;
Li = doublelist( "()" ); assertTrue( Li.empty() );
Li = doublelist( " ( ) " ); assertTrue( Li.empty() );
Li = doublelist( "(1. 2. 3. 4. 5.)" );
for ( double j=1; j<=5; ++j ) {
Lj.push_back( j );
}
assertTrue( Li == Lj );
assertTrue( doublelist( "( ... )" ) == doublelist( "( 0 )" ) );
assertTrue( doublelist( "( ... )" ).size() == 1 );
assertTrue( doublelist( "(0)" ) == doublelist( "( - )" ) );
assertTrue( doublelist( "(0)" ) == doublelist( "( + )" ) );
assertTrue( doublelist( "()" ) == doublelist( "( )" ) );
assertTrue( doublelist( "( 1. 2. 3. 4. 5. )" ) == doublelist( "(1,2,3,4,5)" ) );
assertTrue( doublelist( "{ 1.,2.,3.,4.,5. }" ) == doublelist( "[1 2 3 4 5]" ) );
Li = doublelist( "( 1,22,333,4444,5555 )" );
Lj = doublelist( "(1,22,333,4444,5555)" );
assertTrue( Li == Lj );
Li = doublelist( "(1 , - + 22, -333, - 4444, --5555)" );
Lj = doublelist( "(1, 0,0,22, -333, 0,4444, 0)" );
assertTrue( Li == Lj );
Li = doublelist( "( 1, 22, 333, 4444, 5555 )" );
Lj = doublelist( "| [1] [22] [333] [4444] [5555] |... ignore");
assertTrue( Li == Lj );
Li = doublelist( "( 1, 22, 333, 4444, 5555, 0, 0 )" );
Lj = doublelist( "( [1] [22] [333] [4444] [5555] )etc ...");
assertTrue( Li == Lj );
}}

Ver también
test_str2list::test_doublelist()

Definición en la línea 189 del archivo str2list.h.

std::list<char> charlist ( const char *  str)

Sinónimo de makeList_char().

Definición en la línea 193 del archivo str2list.h.

std::list<char> makeList_char ( const char *  str)
inline

Retorna la lista de caracteres (char) construida en base a "str".

Usa str2list() pero se brinca las comillas simples (').

  • No necesita que cada letra venga entre comillas simples.
  • Si alguno de los valores tiene más de un caracter, usa el primero e ignora los demás.
{{ // test::charlist()
std::list<char> Lcon,Lsin;
Lcon = charlist( " { 'a' ' ' 'c' '4' '\'' '.' } " );
Lsin = charlist( " ( a ' ' c 4 ''' . ) " );
// 1 2 3 4 5 6
assertTrue( Lcon == Lsin );
assertTrue( Lcon.size() == 6 );
std::list<char>::const_iterator it;
it = Lcon.begin();
for ( unsigned i=0; i<Lcon.size()-1; ++i ) { ++it; }
assertTrue( *it == '.' );
--it;
assertTrue( *it == '\'' );
}}

Ver también
test_str2list::test_makeList_char()

Definición en la línea 227 del archivo str2list.h.

template<class STRING >
size_t str2matrix ( std::list< std::list< STRING > > &  M,
const char *  str 
)

Almacena en "M<<>>" la matriz de hileras construida en base a "str".

  • Cada renglón de la matriz debe estar entre caracteres '|'.
  • Para obtener cada renglón se usa str2list().
  • La matriz se retorna como una lista de listas de hileras.
  • Ignora sublistas nulas pues "M<<>>" nunca contiene sublistas nulas.
  • Siempre modifica el valor de "M<<>>".
  • Retorna la longitud de la sublista más grande de "M<<>>" (para calcular cuántas columnas tiene la matriz).
{{ // test::str2matrix()
std::list< std::list<std::string> > M;
size_t sz = str2matrix( M , " | 99 | " // L0
" | . 2 , , : | " // L1
" | . . 3 , . | " // L2
" | a b c 4 . | " ); // L3
std::list< std::list<std::string> > :: const_iterator itL = M.begin();
const std::list<std::string> & L0 = *itL; itL++;
const std::list<std::string> & L1 = *itL; itL++;
const std::list<std::string> & L2 = *itL; itL++;
const std::list<std::string> & L3 = *itL; itL++;
assertTrue( itL==M.end() && M.size() == 4 && sz == L3.size() );
assertTrue( L0 == str2list( " ( 99 ) " ) ); // L0
assertTrue( L1 == str2list( " [ . 2 , , : ] " ) ); // L1
assertTrue( L2 == str2list( " < . . 3 , . > " ) ); // L2
assertTrue( L3 == str2list( " { a b c 4 . } " ) ); // L3
assertTrue( L0.size() == 1 && L0.back() == "99" );
assertTrue( L1.size() == 3 && L1.back() == ":" );
assertTrue( L2.size() == 4 && L2.front() == "." );
assertTrue( L3.size() == 5 && L3.front() == "a" );
assertTrue( L0 == str2list( "(99)" ) ); // L0
assertTrue( L1 == str2list( "(. 2 :)" ) ); // L1
assertTrue( L2 == str2list( "(. . 3 .)" ) ); // L2
assertTrue( L3 == str2list( "( a b c 4 .)" ) ); // L3
}}

Ver también
test_str2list::test_str2matrix()

Definición en la línea 246 del archivo str2list.h.

template<class N , class ATON_wrap , unsigned Nrows, unsigned Ncols>
void matrix2list_wrap ( MATRIX[Nrows][Ncols],
const char *  str 
)

Almacena en MATRIX[][] la matriz construida en base a "str".

Usa str2matrix() junto con ATON_wrap::ATON().

Parámetros del template
Ntipo de dato: { int long double }
ATON_wrapEmpaque ATON() alrededor del convertidor: { atoi() atol() atof() }
NrowsCantidad de filas de MATRIX[][].
NcolsCantidad de columnas de MATRIX[][].

Definición en la línea 276 del archivo str2list.h.

template<unsigned Nrows, unsigned Ncols>
void intmatrix ( int  M[Nrows][Ncols],
const char *  str 
)
inline

Almacena en M[][] la matriz de enteros (int) construida en base a "str".

Usa str2matrix() junto con atoi().

{{ // test::intmatrix()
int M[4][5]; // [0][1][2][3][4]
intmatrix<4,5>( M , " | 1 // 3 4 5 | " // [0]
" | :: 7 8 9 10 | " // [1]
" | 11 12 13 .. 15 | " // [2]
" | 16 17 // 19 20 | " );// [3]
assertTrue( M[0][0] == 1 ); assertTrue( M[2][1] == 12 );
assertTrue( M[2][3] == 0 ); assertTrue( M[1][0] == 0 );
int k=1;
for ( size_t i=0; i<4; ++i ) {
for ( size_t j=0; j<5; ++j ) {
assertTrue( M[i][j]==k++ || M[i][j]==0 );
}
}
}}

Ver también
test_str2list::test_intmatrix()

Definición en la línea 309 del archivo str2list.h.

template<unsigned Nrows, unsigned Ncols>
void longmatrix ( long  M[Nrows][Ncols],
const char *  str 
)
inline

Almacena en M[][] la matriz de enteros (long) construida en base a "str".

Usa str2matrix() junto con atol().

{{ // test::longmatrix()
long M[4][5]; // [0][1][2][3][4]
longmatrix<4,5>( M , " | 1 // 3 4 5 | " // [0]
" | :: 7 8 9 10 | " // [1]
" | 11 12 13 .. 15 | " // [2]
" | 16 17 // 19 20 | " );// [3]
assertTrue( M[0][0] == 1 ); assertTrue( M[2][1] == 12 );
assertTrue( M[0][1] == 0 ); assertTrue( M[3][2] == 0 );
long k=1;
for ( size_t i=0; i<4; ++i ) {
for ( size_t j=0; j<5; ++j ) {
assertTrue( M[i][j]==k++ || M[i][j]==0 );
}
}
}}

Ver también
test_str2list::test_longmatrix()

Definición en la línea 321 del archivo str2list.h.

template<unsigned Nrows, unsigned Ncols>
void doublematrix ( double  M[Nrows][Ncols],
const char *  str 
)
inline

Almacena en M[][] la matriz de flotantes construida en base a "str".

Usa str2matrix() junto con atof().

{{ // test::doublematrix()
double M[4][5]; // [0] [1] [2] [3] [4]
doublematrix<4,5>( M , " | 10. /// 30 40. 5.e1 | " // [0]
" | . 70. 80 90. 100. | " // [1]
" | 110 120 130 .. 150. | " // [2]
" | 160 170 /// 190 2.e2 | " );
assertTrue( M[2][1] == 120.0 );
assertTrue( M[1][0] == 0.0 && M[2][3] == 0.0 );
double k=10.0;
for ( size_t i=0; i<4; ++i ) {
for ( size_t j=0; j<5; ++j ) {
assertTrue( M[i][j]==k || M[i][j]==0 );
k += 10.0;
}
}
}}

Ver también
test_str2list::test_doublematrix()

Definición en la línea 333 del archivo str2list.h.

template<unsigned Nrows, unsigned Ncols>
void charmatrix ( char  M[Nrows][Ncols],
const char *  str 
)
inline

Almacena en M[][] la matriz de caracteres construida en base a "str".

Usa str2matrix() pero se brinca las comillas simples (').

  • No necesita que cada letra venga entre comillas simples.
  • Si alguno de los valores tiene más de un caracter, usa el primero e ignora los demás.
{{ // test::charmatrix()
char A[5][3];
charmatrix<5,3>( A , " | 1 a V | "
" | 2 b W | "
" | 3 c X | "
" | 4 d Y | "
" | 5 e Z | " );
char D[5][3];
charmatrix<5,3>( D , " | 2 c Y | "
" | 3 d Z | "
" | 4 e V | "
" | 5 a W | "
" | 1 b X | " );
for ( int j=0; j<5; ++j ) {
assertTrue( A[j][0] == (j)+'1' );
}
for ( int j=0; j<5; ++j ) {
assertTrue( A[j][1] == (j)+'a' );
}
for ( int j=0; j<5; ++j ) {
assertTrue( A[j][2] == (j)+'V' );
}
}}

Ver también
test_str2list::test_charmatrix()

Definición en la línea 350 del archivo str2list.h.