src/tools/tString.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

**************************************************************************

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 2
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, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

***************************************************************************

*/

#ifndef ArmageTron_STRING_H
#define ArmageTron_STRING_H

#include "aa_config.h"

#include "defs.h"

#include <string>
#include <sstream>
#include <iostream>
#include <iosfwd>

// macros that help wrapping operators defined for a base class, they probably
// should be refactored into another header. They assume THISCLASS is a typedef to the
// class just being defined and BASE the base class.

#define WRAP_MUTATING_OPERATOR(op, T) inline THISCLASS & operator op( T t ){ static_cast< BASE & >( *this ) op t; return *this; }
#define WRAP_MUTATING_OPERATOR_ALLTYPES(op) template< class T > WRAP_MUTATING_OPERATOR(op, T const &)

#define WRAP_OPERATOR(op, T) inline THISCLASS operator op( T t ) const { return THISCLASS( static_cast< const BASE & >( *this ) op  t ); }
#define WRAP_OPERATOR_ALLTYPES(op) template< class T > WRAP_OPERATOR(op, T const &)

//typedef tArray<char> string;
class tOutput;

using std::string;

class tString:public string{
private:
public:
    typedef tString          THISCLASS; 
    typedef std::string      BASE;      
    typedef BASE::value_type CHAR;      

    tString();                         
    tString(const BASE &);             
    tString(const tString &);          
    explicit tString(const CHAR *);    
    template<typename T>
    tString(T begin, T end) : string(begin,end) {} 
    // explicit tString(const char *);    //!< conversion from C string
    // explicit tString(const tOutput &); //!< conversion from output

    // wrap base operators so they have the correct type
    // if you end up here in the debugger, don't bother to look up
    WRAP_OPERATOR_ALLTYPES(+)              // concatenation
    WRAP_MUTATING_OPERATOR_ALLTYPES(+=)    // appending
    WRAP_MUTATING_OPERATOR(=,CHAR const *) // assignment of C string
    WRAP_MUTATING_OPERATOR(=,BASE const &) // assignment from C++ string

    tString & operator =( tOutput const & other ); 

    size_type Size() const;                        

#ifdef _MSC_VER
    bool Convert( int & target, size_type startPos = 0 ) const;
    bool Convert( REAL & target, size_type startPos = 0 ) const;
#else
    template < class T > bool Convert( T & target, size_type startPos = 0 ) const;
#endif

    void ReadLine(std::istream &s, bool enableEscapeSequences=false); 

    void Clear();                       
    void SetPos( int len, bool cut );   

    bool StartsWith( const tString & other ) const; 
    bool StartsWith( const CHAR * other ) const;    

    bool EndsWith( const tString & other) const;    
    bool EndsWith( const CHAR* other) const;        

    tString LTrim() const;                          
    tString RTrim() const;                          
    tString Trim() const;                           

    int StrPos( const tString &tofind ) const;      
    int StrPos( int start, const tString &tofind ) const; 
    int StrPos( const CHAR * tofind ) const;        
    int StrPos( int start, const CHAR * tofind ) const; 

    tString SubStr( int start, int len) const;      
    tString SubStr( int start ) const;              

    int ToInt( size_type pos = 0 ) const;           
    REAL ToFloat( size_type pos = 0 ) const;        

    static int CompareAlphaNumerical( const tString& a, const tString &b);

    tString StripWhitespace( void ) const;

    tString ToLower(void) const;
    tString ToUpper(void) const;

    int PosWordRight(int start) const;          
    int PosWordLeft(int start) const;           
    int RemoveWordRight(int start);             
    int RemoveWordLeft(int start);              
    void RemoveSubStr(int start, int length);   
    tString GetFileMimeExtension() const;       
    tString Reverse() const;                    

    tString Truncate( int truncateAt ) const;   


    // TO BE REPLACED
    // auto-expanding subscription operators, will become non-expanding
    CHAR operator[]( size_t i ) const;
    CHAR & operator[]( size_t i );
    CHAR operator[]( int i ) const;
    CHAR & operator[]( int i );

    void SetSize( unsigned int size ); 

#ifdef NOLEGACY
private:
#endif
    // non-expanding subscription operators, will disappear
    CHAR operator()( size_t i ) const;
    CHAR & operator()( size_t i );
    CHAR operator()( int i ) const;
    CHAR & operator()( int i );

    // comparison operators
    int Compare( const CHAR* other ) const;                          
    int Compare( const CHAR* other, bool ignoreCase ) const; 

    // automatic conversion will go away, it's dangerous
    operator const CHAR*() const;

    int Count(CHAR what) const; 
    int LongestLine() const; 

    // LEGACY FUNCTIONS, DON'T USE IN NEW CODE
    int Len() const; 

    void SetLen( int len ); 

    void NetFilter();                           
};

struct tColoredStringProxy
{
    REAL r_, g_, b_;

    tColoredStringProxy( REAL r, REAL g, REAL b )
            : r_(r), g_(g), b_(b)
    {}
};

class tColoredString: public tString
{
public:
    typedef tColoredString   THISCLASS; 
    typedef tString          BASE;      

    ~tColoredString();                                      
    tColoredString();                                       
    tColoredString( const tColoredString& other );          
    explicit tColoredString( const tString& other );        
    explicit tColoredString( const CHAR * other );          
    explicit tColoredString( const tOutput & other );       

    WRAP_MUTATING_OPERATOR(=,CHAR const *)    // assignment of C string
    WRAP_MUTATING_OPERATOR(=,BASE const &)    // assignment from C++ string
    WRAP_MUTATING_OPERATOR(=,tOutput const &) // assignment from output collector

    static tString RemoveColors( const CHAR *c );           
    void SetPos( int len, bool cut=false );                 

    void RemoveTrailingColor();                             

    // void RemoveHex();                                       //!< ?

    int LongestLine() const;

    inline static tColoredStringProxy ColorString( REAL r,REAL g,REAL b )
    {
        return tColoredStringProxy( r, g, b );
    }
};

bool tIsInList( tString const & list, tString const & item );

void tToLower( tString & toTransform );

void tToUpper( tString & toTransform );

template<class T> tString & operator <<(tString &s,const T &c)
{
    std::ostringstream S;

    S << c;

    return s += S.str();
}

tColoredString & operator <<(tColoredString &s, const tColoredStringProxy &colorCode );

template<class T> tColoredString & operator <<(tColoredString &s,const T &c)
{
    // delegate to basic string function...
    static_cast< tString& >( s ) << c;

    // but don't allow overhanging color codes
    s.RemoveTrailingColor();

    return s;
}

std::istream & operator>> (std::istream &s,tString &x);

#ifndef _MSC_VER
// *******************************************************************************
// *
// *    Convert
// *
// *******************************************************************************
// *******************************************************************************

template< class T >
bool tString::Convert( T & target, size_type startPos ) const
{
    // generate string stream and advance it to the start position
    std::istringstream s(*this);
    s.seekg(startPos);

    // read it
    s >> target;

    // return failure condition
    return !s.fail() && s.eof() || isspace(s.get());
}
#endif

#endif

---