gstr.h

Go to the documentation of this file.

//
// Copyright (C) 2001-2013 Graeme Walker <graeme_walker@users.sourceforge.net>
// 
// This program 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.
// 
// This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
// ===

#ifndef G_STR_H
#define G_STR_H

#include "gdef.h"
#include "gexception.h"
#include "gstrings.h"
#include <string>
#include <sstream>
#include <iostream>
#include <list>
#include <vector>

namespace G
{
        class Str ;
}

class G::Str 
{
public:
        G_EXCEPTION_CLASS( Overflow , "conversion error: over/underflow" ) ;
        G_EXCEPTION_CLASS( InvalidFormat, "conversion error: invalid format" ) ;
        typedef std::string::size_type size_type ;

        static bool replace( std::string & s , 
                const std::string & from , const std::string & to , 
                size_type * pos_p = NULL ) ;

        static unsigned int replaceAll( std::string & s , const std::string & from , const std::string & to ) ;

        static unsigned int replaceAll( std::string & s , const char * from , const char * to ) ;

        static void removeAll( std::string & , char ) ;

        static void trimLeft( std::string & s , const std::string & ws , size_type limit = 0U ) ;

        static void trimRight( std::string & s , const std::string & ws , size_type limit = 0U ) ;

        static void trim( std::string & s , const std::string & ws ) ;

        static std::string trimmed( const std::string & s , const std::string & ws ) ;

        static bool isNumeric( const std::string & s , bool allow_minus_sign = false ) ;

        static bool isPrintableAscii( const std::string & s ) ;

        static bool isUShort( const std::string & s ) ;

        static bool isUInt( const std::string & s ) ;

        static bool isULong( const std::string & s ) ;

        static std::string fromBool( bool b ) ;

        static std::string fromDouble( double d ) ;

        static std::string fromInt( int i ) ;

        static std::string fromLong( long l ) ;

        static std::string fromShort( short s ) ;

        static std::string fromUInt( unsigned int ui ) ;

        static std::string fromULong( unsigned long ul ) ;

        static std::string fromUShort( unsigned short us ) ;

        static bool toBool( const std::string & s ) ;

        static double toDouble( const std::string & s ) ;

        static int toInt( const std::string & s ) ;

        static long toLong( const std::string & s ) ;

        static short toShort( const std::string & s ) ;

        static unsigned int toUInt( const std::string & s , bool limited = false ) ;

        static unsigned long toULong( const std::string & s , bool limited = false ) ;

        static unsigned short toUShort( const std::string & s , bool limited = false ) ;

        static void toUpper( std::string & s ) ;
                
        static void toLower( std::string & s ) ;
                
        static std::string upper( const std::string & s ) ;
                
        static std::string lower( const std::string & s ) ;

        static std::string toPrintableAscii( char c , char escape = '\\' ) ;

        static std::string toPrintableAscii( const std::string & in , char escape = '\\' ) ;

        static std::string toPrintableAscii( const std::wstring & in , wchar_t escape = L'\\' ) ;

        static std::string printable( const std::string & in , char escape = '\\' ) ;

        static void escape( std::string & , const std::string & specials , char escape = '\\' ) ;

        static std::string escaped( const std::string & , const std::string & specials , char escape = '\\' ) ;

        static std::string readLineFrom( std::istream & stream , const std::string & eol = std::string() ) ;

        static void readLineFrom( std::istream & stream , const std::string & eol , std::string & result ,
                bool pre_erase_result = true ) ;

        static std::string wrap( std::string text , 
                const std::string & prefix_first_line , const std::string & prefix_subsequent_lines , 
                size_type width = 70U ) ;

        static void splitIntoTokens( const std::string & in , Strings & out , const std::string & ws ) ;

        static void splitIntoTokens( const std::string & in , StringArray & out , const std::string & ws ) ;

        static void splitIntoFields( const std::string & in , Strings & out , 
                const std::string & seperators , char escape = '\0' , 
                bool discard_bogus_escapes = true ) ;

        static void splitIntoFields( const std::string & in , StringArray & out ,
                const std::string & seperators , char escape = '\0' , bool discard_bogus_escapes = true ) ;

        static std::string join( const Strings & strings , const std::string & sep ) ;

        static std::string join( const StringArray & strings , const std::string & sep ) ;

        static Strings keys( const StringMap & string_map ) ;

        static std::string head( const std::string & in , std::string::size_type pos , 
                const std::string & default_ = std::string() ) ;

        static std::string tail( const std::string & in , std::string::size_type pos , 
                const std::string & default_ = std::string() ) ;

        static bool tailMatch( const std::string & in , const std::string & ending ) ;

        static std::string ws() ;

private:
        static void readLineFromImp( std::istream & , const std::string & , std::string & ) ;
        Str() ; // not implemented
} ;

#endif