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;

namespace K3d
{
        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()
                {
                        m_str.clear();
                };

                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 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;
        }
}       // End namespace K3d

---