K3dString.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   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.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/


#pragma once

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
using namespace std;

typedef std::string TString;
typedef std::stringstream TStrStream;

class K3dToLower
{
        public:
                char operator() ( char c ) const
                {
                        return tolower ( c );
                }
};
class K3dString
{
                TString m_str;
                bool m_bFoundToken;     
        public:
                K3dString() {};
                K3dString ( const char * _str )
                {
                        if ( _str != NULL )
                        {
                                m_str = _str;
                        }
                        else
                        {
                                cerr << "Error in K3dString() constructor -- *_str is NULL" << endl;
                                m_str = "";
                        }
                }
                K3dString ( const K3dString & _rStr )
                {
                        *this = _rStr;
                }
                K3dString ( const TString & _rStr )
                {
                        m_str = _rStr;
                }
                ~K3dString() {};

                size_t Find ( const char *_str );
                size_t RFind ( const char *_str );
                TString& SetNum ( int _iVal );
                TString& SetNum ( bool _bVal );
                TString& SetNum ( unsigned int _uiVal );
                TString& SetNum ( float _fVal );
                K3dString& GetStrTok ( K3dString &_strOut,const K3dString &_strSign );
                K3dString &Left ( size_t _iPos );
                K3dString &Right ( size_t _iPos );
                TString & ToLower();
                void StrLwr ( const char * _str );
                void AddNumber ( const int _iVal );

                bool &GetFoundToken()
                {
                        return m_bFoundToken;
                }

                void GetString ( const char * _strOut )
                {
                        _strOut = m_str.c_str();
                }

                int ToInt()
                {
                        istringstream ss ( m_str );
                        int i;
                        ss >> i;
                        return i;
                }

                float ToFloat()
                {
                        istringstream ss ( m_str );
                        float f;
                        ss >> f;
                        return f;
                }

                double ToDouble()
                {
                        istringstream ss ( m_str );
                        double d;
                        ss >> d;
                        return d;
                }

                TString& GetString()
                {
                        return m_str;
                }

                const TString& GetString() const
                {
                        return m_str;
                }

                void SetString ( const char* _str )
                {
                        m_str = _str;
                }

                K3dString & operator= ( K3dString & _rStr )
                {
                        m_str = _rStr.GetString();
                        return *this;
                }

                K3dString & operator= ( const K3dString & _rStr )
                {
                        m_str = _rStr.GetString();
                        return *this;
                }

                K3dString & operator= ( const char * _str )
                {
                        m_str = _str;
                        return *this;
                }

                K3dString & operator+= ( const K3dString & _rStr )
                {
                        m_str = m_str + _rStr.GetString();
                        return *this;
                }

                K3dString & operator+= ( const char * _str )
                {
                        m_str = m_str + _str;
                        return *this;
                }

                char & operator[] ( int _iPos )
                {
                        return m_str[_iPos];
                }

                bool operator!= ( const char * _str )
                {
                        TString str = _str;
                        if ( m_str != str )
                        {
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                bool operator!= ( const char * _str ) const
                {
                        TString str = _str;
                        if ( m_str != str )
                        {
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                bool operator!= ( const K3dString &_str )
                {
                        TString str = _str.GetString( );
                        if ( m_str != str )
                        {
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                bool operator== ( const char * _str )
                {
                        TString str = _str;
                        if ( m_str == str )
                        {
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                bool operator== ( const char * _str ) const
                {
                        TString str = _str;
                        if ( m_str == str )
                        {
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                bool operator== ( K3dString &_str )
                {
                        TString str = _str.GetString();
                        if ( m_str == str )
                        {
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                bool operator== ( K3dString &_str ) const
                {
                        TString str = _str.GetString();
                        if ( m_str == str )
                        {
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                void Erase ( size_t _uiPos, size_t _uiNumPos )
                {
                        m_str.erase ( _uiPos, _uiNumPos );
                }

                size_t GetSize()
                {
                        return m_str.size();
                }

                size_t GetLength()
                {
                        return m_str.length();
                }

                size_t Find ( const K3dString& _str )
                {
                        return m_str.find ( _str.GetString() );
                }

                void AddString ( char *_strOut, const unsigned int _iStrLen, const char *_strIn, const int _i )
                {
                        snprintf ( _strOut, _iStrLen, "%s %i" , _strIn, _i );
                }

                void AddString ( char *_strOut, const unsigned int _iStrLen, const char *_strIn, const int _iVal0, const int _iVal1 )
                {
                        snprintf ( _strOut, _iStrLen, "%s %i, %i" , _strIn, _iVal0, _iVal1 );
                }

                void AddString ( char *_strOut, const unsigned int _iStrLen, const char *_strIn, const char *_strAdd )
                {
                        snprintf ( _strOut, _iStrLen, "%s %s" , _strIn, _strAdd );
                }

                void AddString ( char *_strOut,const unsigned int _iStrLen, const char *_strIn, const float _f )
                {
                        snprintf ( _strOut, _iStrLen, "%s %f" , _strIn, _f );
                }

                void AddStringNumber ( char *_strOut, const unsigned int _iStrLen, const char *_strIn, const int _i )
                {
                        snprintf ( _strOut, _iStrLen, "%s%i" , _strIn, _i );
                }

                void Clear()
                {
                        m_str.clear();
                }
};

static K3dString g_K3dString;

inline const K3dString& operator+ ( const K3dString &_rstr1, const K3dString &_rstr2 )
{
        TString str1 = _rstr1.GetString();
        TString str2 = _rstr2.GetString();
        TString strResult = str1 + str2;
        g_K3dString.GetString() = strResult;
        return g_K3dString;
}

inline const K3dString& operator+ ( const char *_str1, const K3dString &_rstr2 )
{
        K3dString t ( _str1 );
        t += _rstr2;
        g_K3dString.GetString() = t.GetString( );
        return g_K3dString;
}

inline const K3dString& operator+ ( const K3dString &_rstr1, const char *_str2 )
{
        TString str1 = _rstr1.GetString();
        TString str2 = _str2;
        TString strResult = str1 + str2;
        g_K3dString.GetString() = strResult;
        return g_K3dString;
}

---