stringUtils.cpp

Go to the documentation of this file.

/** \file stringUtils.cpp
 * \brief Implementation of utilities for working with strings
 *
 * \author Jared R. Males (jaredmales@gmail.com)
 *
 * \ingroup stringutils
 *
 */
 
//***********************************************************************//
// Copyright 2020 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#include "ioutils/stringUtils.hpp"
 
namespace mx
{
namespace ioutils
{
 
// Specialization of convertToString to avoid converting a string to a string
template <>
std::string convertToString<std::string>( const std::string &value, int precision )
{
    static_cast<void>( precision );
    return value;
}
 
// Template specialization of convertFromString for char
template <>
char convertFromString<char>( const std::string &str )
{
    return (char)atoi( str.c_str() );
}
 
// Template specialization of convertFromString for char16_t
template <>
char16_t convertFromString<char16_t>( const std::string &str )
{
    return (char16_t)atoi( str.c_str() );
}
 
// Template specialization of convertFromString for char32_t
template <>
char32_t convertFromString<char32_t>( const std::string &str )
{
    return (char32_t)atoi( str.c_str() );
}
 
// Template specialization of convertFromString for char32_t
template <>
wchar_t convertFromString<wchar_t>( const std::string &str )
{
    return (wchar_t)atoi( str.c_str() );
}
 
// Template specialization of convertFromString for unsigned char
template <>
signed char convertFromString<signed char>( const std::string &str )
{
    return (signed char)atoi( str.c_str() );
}
 
// Template specialization of convertFromString for unsigned char
template <>
unsigned char convertFromString<unsigned char>( const std::string &str )
{
    return (unsigned char)atoi( str.c_str() );
}
 
// Template specialization of convertFromString for short
template <>
short convertFromString<short>( const std::string &str )
{
    return (short)atoi( str.c_str() );
}
 
// Template specialization of convertFromString for unsigned short
template <>
unsigned short convertFromString<unsigned short>( const std::string &str )
{
    return (unsigned short)atoi( str.c_str() );
}
 
// Template specialization of convertFromString for int
template <>
int convertFromString<int>( const std::string &str )
{
    return atoi( str.c_str() );
}
 
// Template specialization of convertFromString for unsigned int
template <>
unsigned int convertFromString<unsigned int>( const std::string &str )
{
    return (unsigned int)strtoul( str.c_str(), 0, 0 );
}
 
// Template specialization of convertFromString for long
template <>
long convertFromString<long>( const std::string &str )
{
    return strtol( str.c_str(), 0, 0 );
}
 
// Template specialization of convertFromString for unsigned long
template <>
unsigned long convertFromString<unsigned long>( const std::string &str )
{
    return strtoul( str.c_str(), 0, 0 );
}
 
// Template specialization of convertFromString for long long
template <>
long long convertFromString<long long>( const std::string &str )
{
    return strtoll( str.c_str(), 0, 0 );
}
 
// Template specialization of convertFromString for unsigned long long
template <>
unsigned long long convertFromString<unsigned long long>( const std::string &str )
{
    return strtoull( str.c_str(), 0, 0 );
}
 
// Template specialization of convertFromString for float
template <>
float convertFromString<float>( const std::string &str )
{
    return strtof( str.c_str(), 0 );
}
 
// Template specialization of convertFromString for double
template <>
double convertFromString<double>( const std::string &str )
{
    return strtod( str.c_str(), 0 );
}
 
// Template specialization of convertFromString for long double
template <>
long double convertFromString<long double>( const std::string &str )
{
    return strtold( str.c_str(), 0 );
}
 
// Template specialization of convertFromString for bool
template <>
bool convertFromString<bool>( const std::string &str )
{
    char c = str[0];
    size_t i = 0;
    while( isspace( c ) && i < str.length() )
        c = str[i++];
 
    if( c == '0' || c == 'f' || c == 'F' )
        return false;
    if( c == '1' || c == 't' || c == 'T' )
        return true;
 
    return (bool)convertFromString<int>( str );
}
 
// Convert a string to all lower case.
void toLower( std::string &outstr, const std::string &instr )
{
    outstr.resize( instr.size() );
 
    for( size_t i = 0; i < instr.size(); ++i )
        outstr[i] = tolower( instr[i] );
}
 
// Convert a string to all lower case.
std::string toLower( const std::string &instr )
{
    std::string outstr;
 
    toLower( outstr, instr );
 
    return outstr;
}
 
// vConvert a string to all upper case.
void toUpper( std::string &outstr, const std::string &instr )
{
    outstr.resize( instr.size() );
 
    for( size_t i = 0; i < instr.size(); ++i )
        outstr[i] = toupper( instr[i] );
}
 
// Convert a string to all upper case.
std::string toUpper( const std::string &instr )
{
    std::string outstr;
 
    toUpper( outstr, instr );
 
    return outstr;
}
 
// Remove all white space from a string.
void removeWhiteSpace( std::string &outstr, const std::string &instr )
{
    outstr = instr;
 
    outstr.erase( std::remove_if( outstr.begin(), outstr.end(), ::isspace ), outstr.end() );
}
 
// Remove all white space from a string.
std::string removeWhiteSpace( const std::string &instr )
{
    std::string outstr;
 
    removeWhiteSpace( outstr, instr );
 
    return outstr;
}
 
// Wrap a string by breaking it into smaller sized portions of a desired width
int stringWrap( std::vector<std::string> &lines, const std::string &str, int width )
{
    int L = str.length();
 
    if( L == 0 )
        return 0;
    int startPos, tmpPos, endPos;
 
    bool done = false;
 
    startPos = 0;
 
    while( !done )
    {
        if( startPos == L )
            --startPos; // Just to make sure
 
        endPos = startPos + width;
 
        if( endPos >= L )
        {
            lines.push_back( str.substr( startPos, L - startPos ) );
            done = true;
        }
        else
        {
            // Backup to nearest space
            tmpPos = endPos;
            while( !isspace( str[tmpPos] ) && tmpPos >= startPos )
                --tmpPos;
 
            // If we aren't at the beginning (i.e. splitting consecutive characters) we use new end position
            if( tmpPos > startPos )
                endPos = tmpPos;
 
            lines.push_back( str.substr( startPos, endPos - startPos ) );
 
            startPos = endPos;
 
            // Clear 1 space
            if( str[startPos] == ' ' )
                ++startPos;
        }
    }
 
    return 0;
}
 
} // namespace ioutils
} // namespace mx