string_tool.cpp

Go to the documentation of this file.

// string_tool.cpp (C) 2012 adolfo@di-mare.com
 
/** \file   string_tool.cpp
    \brief  Implementación de \c string_tool.cpp.
    \author Adolfo Di Mare <adolfo@di-mare.com>
    \date   2012
*/
 
#include <cctype>
#include "string_tool.h"
 
/** Convierte a minúscula todas las letras de \c line.
    - Solo funciona para letras ASCII.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::tolower()
    \until       }}
*/
void tolower( std::string& line ) {
    std::string::iterator it = line.begin();
    while ( it!=line.end() ) {
        *it = tolower(*it);
        ++it;
    }
}
 
/** Retorna la letra sin acento que corresponde a \c ch.
    - Funciona para letras del alfabeto ISO-8859-1 Latin No.1.
    - Funciona para letras del alfabeto Windows-1252 (Latin).
    - Modifica letras cuyo código está en el rango [192..255].
    - Por ejemplo: <code>assertTrue( 'n' == removeAccented('ñ') )</code>
    - \see http://en.wikipedia.org/wiki/ISO/IEC_8859-1
    - \see https://en.wikipedia.org/wiki/Windows-1252
 
    \dontinclude string_tool_test.cpp
    \skipline    test::removeAccented(char)
    \until       }}
*/
char removeAccented( char ch ) {
    const char*
    //   A_TILDE_64
    tr = A_SIMPLE_64;
 
    unsigned char uch = ch;
    if ( uch >=192 ) {
        uch = tr[ uch-192 ];
    }
    // http://stackoverflow.com/questions/14094621/
 
    return char(uch);
}
 
/** Convierte todas las letras con acento en letras sin accento.
    - Funciona para letras del alfabeto ISO-8859-1 Latin No.1.
    - Funciona para letras del alfabeto Windows-1252 (Latin).
    - Modifica letras cuyo código está en el rango [192..255].
    - \see http://en.wikipedia.org/wiki/ISO/IEC_8859-1
    - \see https://en.wikipedia.org/wiki/Windows-1252
 
    \dontinclude string_tool_test.cpp
    \skipline    test::removeAccented(char*)
    \until       }}
*/
const char* removeAccented( char* str ) {
    char *p = str;
    while ( (*p)!=0 ) {
    #if 1
        const char*
        //   A_TILDE_64
        tr = A_SIMPLE_64;
        unsigned char ch = (*p);
        if ( ch >=192 ) {
            (*p) = tr[ ch-192 ];
        }
    #else
        *p = removeAccented(*p) ;
    #endif // 0
        ++p;
        // http://stackoverflow.com/questions/14094621/
    }
    return str;
}
 
/** Convierte todas las letras con acento en letras sin accento.
    - Funciona para letras del alfabeto ISO-8859-1 Latin No.1.
    - Funciona para letras del alfabeto Windows-1252 (Latin).
    - Modifica letras cuyo código está en el rango [192..255].
    - \see http://en.wikipedia.org/wiki/ISO/IEC_8859-1
    - \see https://en.wikipedia.org/wiki/Windows-1252
 
    \dontinclude string_tool_test.cpp
    \skipline    test::removeAccented(string)
    \until       }}
*/
const std::string& removeAccented( std::string& str ) {
    std::string::iterator p = str.begin();
    while ( p!=str.end() ) {
    #if 1
        const char*
        //   A_TILDE_64
        tr = A_SIMPLE_64;
        unsigned char ch = (*p);
        if ( ch >=192 ) {
            (*p) = tr[ ch-192 ];
        }
    #else
        *p = removeAccented(*p) ;
    #endif // 0
        ++p;
        // http://stackoverflow.com/questions/14094621/
    }
    return str;
}
 
/** Elimina comillas ['] ["] del principio o final de 'word'.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::trimQuote(string)
    \until       }}
*/
void trimQuote( std::string& word ) {
    unsigned len = word.length();
    if ( len == 0 ) { return; }
    --len;
    if ( word[len]=='\"' || word[len]=='\'' ) { --len; }
 
    unsigned from=0;
    if ( word[0]=='\"' || word[0]=='\'' ) { ++from; --len; }
 
    word = word.substr( from, len );
}
 
/** Regresa \c true si todos los caracteres de \c line son alfabéticos.
    - Usa la rutina estándar \c isalpha().
 
    \dontinclude string_tool_test.cpp
    \skipline    test::isalpha()
    \until       }}
*/
bool isalpha( const std::string& line ) {
    std::string::const_iterator it = line.begin();
    while ( it!=line.end() ) {
        if ( !isalpha(*it) ) { return false; }
        ++it;
    }
    return true;
}
 
/** Retorna \c true si todos las caracteres en \c word son blancos.
    - Usa la rutina estándar \c isspace() para determinar si
      un caracter es blanco.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::is_blank()
    \until       }}
*/
bool is_blank( const std::string& word ) {
    std::string::const_iterator it = word.begin();
    while ( isspace(*it) ) {
        it++;
    }
    return (it == word.end() );
}
 
/** Verifica si \c suffix es un sufijo de \c str.
    - Ignora las diferencias entre mayúsculas y minúsculas.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::issuffix()
    \until       }}
*/
bool issuffix( const char* str, const char* suffix ) {
    {   // la hilera nula siempre es sufijo de cualquier hilera
        bool check_null = (suffix==0);
        if (!check_null) { check_null = (*suffix==0); }
        if (check_null) { return true; }
    }
    {   // nadie es sufijo de la hilera nula
        bool check_null = (str==0);
        if (!check_null) { check_null = (*str==0); }
        if (check_null) { return false; }
    }
    // assert( (str!=0) && (suffix!=0) );
 
    unsigned str_len    = strlen( str );
    unsigned suffix_len = strlen( suffix );
 
    if ( str_len < suffix_len ) { return false; }
 
    const char *p = str+str_len;
    const char *q = suffix+suffix_len;
    do {
        --p; --q;
        if ( tolower(*p) != tolower(*q) ) { return false; }
    } while ( q!=suffix );
 
    return true; // assert( q==suffix );
}
 
/** Retorna la cantidad de dígitos consecutivos a partir de \c str[i].
    - Usa la rutina estándar \c isdigit().
    - Retorna \c 0 (cero) si no hay dígitos a partir de \c str[i].
    - Retorna \c string::npos si hay errores.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::digitCount()
    \until       }}
*/
unsigned digitCount( const std::string& str , unsigned i ) {
    unsigned N=str.length();
    if ( (i>=N) ) { return std::string::npos; }
    unsigned n=0;
    while ( i<N ) {
        if ( !isdigit(str[i]) ) { return n; }
        ++i; ++n;
    }
    return n;
}
 
/** Retorna la cantidad de letras consecutivas a partir de 'str[i]'.
    - Usa la rutina estándar \c isalpha().
    - Retorna \c 0 (cero) si no hay letras a partir de 'str[i]'.
    - Retorna \c string::npos si hay errores.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::alphaCount()
    \until       }}
*/
unsigned alphaCount( const std::string& str , unsigned i ) {
    unsigned N=str.length();
    if ( (i>=N) ) { return std::string::npos; }
    unsigned n=0;
    while ( i<N ) {
        if ( !isalpha(str[i]) ) { return n; }
        ++i; ++n;
    }
    return n;
}
 
/** Retorna el número que está al final de \c str.
    - Retorna \c std::string::npos si el sufijo de 'str' no es numérico.
    - Nunca retorna valores negativos (pues siempre ignora '-').
 
    \dontinclude string_tool_test.cpp
    \skipline    test::number_suffix()
    \until       }}
*/
unsigned number_suffix( const std::string& str ) {
    if ( str.empty() ) { return std::string::npos; }
    unsigned i = str.size()-1;
    if ( !isdigit(str[i]) ) { return std::string::npos; }
 
    unsigned n    = 0;
    unsigned mult = 1;
    for (;;) {
        char ch = str[i];
        if ( !isdigit(ch) ) { break;}
        n += (ch-'0')*mult;
        if ( i==0 ) { break; }
        --i; mult *= 10;
    }
    return n;
}
 
 
/** Convierte 's' un número entero sin signo.
    - Solo convierte el prefijo numérico 'str'.
    - Ignora el signo si está presente.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::str2uint()
    \until       }}
*/
unsigned str2uint( const std::string& str ) {
    unsigned i=0; // comienza desde el principio
    unsigned N=str.length();
    while ( i<N ) {
        if ( isspace(str[i]) ) { ++i; }
        else { break; }
    }
    if ( i==N ) { return 0; }
    if ( str[i]=='-' || str[i]=='+' ) { ++i; }
    if ( i==N ) { return 0; }
 
    // periodo multiplicador
    unsigned n=0, nMult;
    while ( i<N ) {
        if ( !isdigit(str[i]) ) { break; }
        nMult = 10 * n;
        n = nMult + (str[i]-'0');
        ++i;
    }
    return n;
}
 
 
/** Retorna la hilera que contiene los últimos 'width' dígitos de 'N'.
    - Rellena con ceros al principio si hace falta.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::tostring()
    \until       }}
*/
std::string tostring( unsigned N, unsigned width ) {
    if ( width==0 ) { return std::string(); }
    // -> http://stackoverflow.com/questions/26587110
    std::string ret; ret.resize( width );
    unsigned i=width;
    do {
        --i;
        ret[i]= N%10+'0';
        N /= 10;
    } while (i>0);
    return ret;
}
 
/** Almacena en 'str' los últimos 'width' dígitos de 'N'.
    - Rellena con ceros al principio si hace falta.
    - Graba el fin de hilera '\0' en 'str[width]'.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::tostring_char()
    \until       }}
*/
void tostring( unsigned N, unsigned width, char *str ) {
    if ( width==0 ) { *str = 0; return; }
    unsigned i=width;
    do {
        --i;
        str[i]= N%10+'0';
        N /= 10;
    } while (i>0);
    *(str+width)=0;
}
 
 
/** Separa las palabras de 'renglon' y las deja en la lista 'L'.
    Usa los caracteres 'delimiters' como separadores.
    Se brinca los espacios en blanco.
    El contenido anterior del contenedor 'L' siempre queda eliminado.
    \pre Siempre es necesario que el blanco ' ' aparezca como
         caracter delimitador en \c delimiters.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::tokens()
    \until       }}
*/
void tokens( const std::string& renglon, std::list<std::string>& L, const char* delimiters ) {
    // Implementación de \c tokens() que usa \c find_first_of().
    L.clear();
    // using namespace std;
    // http://cplusplus.com/faq/sequences/strings/split/#string-find_first_of
    size_t current = 0;
    size_t next = renglon.find_first_of( delimiters, current );
    while (next != std::string::npos) {
        if ( ' ' == renglon[current] ) {
            current = next+1;  // skip blanks
        }
        else if ( current==next ) {
            L.push_back( renglon.substr(current,(1) ) );
        //  std::cout <<"<"<< renglon.substr(current,(1) ) << ">";
            current = next+1;
        }
        else {
            L.push_back( renglon.substr(current,(next-current) ) );
        //  std::cout <<"<"<< renglon.substr(current,(next-current) ) << ">";
            current = next;
        }
        next = renglon.find_first_of( delimiters, current );
    }
    if ( current < renglon.size() ) {
        L.push_back( renglon.substr(current,(std::string::npos) ) );
    //  std::cout << renglon.substr(current,(std::string::npos) ) << " !!!\n";
    }
    // http://www.cplusplus.com/reference/string/string/find_first_of/
}
 
/** Deletes 'len' chars from 'str' starting at index 'from'.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::strdel()
    \until       }}
*/
char *strdel(char *str, size_t from, size_t len) {
    size_t slen = strlen(str);
 // if (len==0) { return str; }
    if (from >= slen) { return str; } // out of bounce
    if (from+len > slen) { len = slen-from; }
    memmove( str+(from), str+(from+len), slen-(from+len)+1 );
    return str;
}
/*
    (p+2,3)
    01...567890123456
    16 -> slen
    13 -> slen-3
     5 -> 2+3 -> from+len
 
    13 -> 16-5+1 -> slen-(from+len)+1
*/
/** Deletes 'len' chars from the start of 'str'.
 
    \dontinclude string_tool_test.cpp
    \skipline    test::strdel2()
    \until       }}
*/
char *strdel2(char *str, size_t len) {
    size_t slen = strlen(str);
 // if (len==0) { return str; }
    if (len > slen) { len = slen; }
    memmove( str, str+len, slen-len+1 );
    return str;
}
/*
    Implementation copied from strdel() replacing ing 'from' by 0.
*/
 
 
// EOF: string_tool.cpp