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. Más...

Funciones
template<class CHAR >
bool	iswhitespace_str2list (CHAR ch)
	Retorna true para todos los caracters considerados como espacios en blanco por str2list(). Más...
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". Más...
std::list< std::string >	str2list (const char *str)
	Usa str2list(L,str) para retornar la lista de valores de "str". Más...
template<class N , class ATON_wrap >
std::list< N >	str2list_wrap (const char *str)
	Retorna la lista de valores construida en base a "str". Más...
std::list< int >	intlist (const char *str)
	Sinónimo de makeList_int(). Más...
std::list< int >	makeList_int (const char *str)
	Retorna la lista de enteros (int) construida en base a "str". Más...
std::list< long >	longlist (const char *str)
	Sinónimo de makeList_long(). Más...
std::list< long >	makeList_long (const char *str)
	Retorna la lista de enteros (long) construida en base a "str". Más...
std::list< double >	doublelist (const char *str)
	Retorna la lista de flotantes construida en base a "str". Más...
std::list< char >	charlist (const char *str)
	Sinónimo de makeList_char(). Más...
std::list< char >	makeList_char (const char *str)
	Retorna la lista de caracteres (char) construida en base a "str". Más...
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". Más...
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". Más...
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". Más...
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". Más...
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". Más...
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". Más...

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

N	tipo de dato: { int long double }
ATON_wrap	Empaque 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	(	N	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

N	tipo de dato: { int long double }
ATON_wrap	Empaque ATON() alrededor del convertidor: { atoi() atol() atof() }
Nrows	Cantidad de filas de MATRIX[][].
Ncols	Cantidad 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.