D:/Zythum/DinoKod/Common/Str.h

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : Str.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 25/05/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#ifndef __STR_H__
#define __STR_H__

#include "Common/CommonDll.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "Common/Types.h"
#include "Common/Assert.h"

//---------------------------------------------------------------------------------------------------------------------
class COMMON_API KStr
{
private:
        char*           m_pString;
        u32                     m_Length;

public:
        KStr()
        {
                m_pString       = strdup( "" );
                m_Length        = (u32)strlen( m_pString );
        }

        KStr( KStr& sString )
        {
                m_pString       = strdup( sString.GetpString() );
                m_Length        = (u32)strlen( m_pString );
        }

        KStr( char* pString )
        {
                KASSERT( pString );
                m_pString       = strdup( pString );
                m_Length        = (u32)strlen( m_pString );
        }

        KStr( const char* pString )
        {
                KASSERT( pString );
                m_pString       = strdup( pString );
                m_Length        = (u32)strlen( m_pString );
        }

        KStr( s32 Value )
        {
                char    pBuffer[20];
                sprintf( pBuffer, "%i", (int)Value );
                m_pString       = strdup( pBuffer );
                m_Length        = (u32)strlen( m_pString );
        }

        KStr( float Value )
        {
                char    pBuffer[20];
                sprintf( pBuffer, "%f", Value );
                m_pString       = strdup( pBuffer );
                m_Length        = (u32)strlen( m_pString );
        }

        KStr( char* pString, const char* pFormat, ... );

        ~KStr()
        {
                Free();
        }



        char*           GetpString()            { return m_pString;     }
        u32                     GetLength()                     { return m_Length;      }

        void            SetpString( char* pString )
        {
                Free();
                m_pString       = strdup( pString ? pString : "" );
                m_Length        = (u32)strlen( m_pString );
        }

        void            Free()
        {
                if( m_pString )
                {
                        SafeFreep( m_pString );
                        m_Length = 0;
                }
        }

        //
        //      =
        //
        KStr&   operator =( KStr& Str )
        {
                SetpString( Str.GetpString() );
                return *this;
        }

        KStr&   operator =( char* pString )
        {
                SetpString( pString );
                return *this;
        }

        KStr&   operator =( const char* pString )
        {
                SetpString( (char*)pString );
                return *this;
        }

        KStr&   operator =( s32 Value )
        {
                char    pBuffer[20];
                sprintf( pBuffer, "%i", (int)Value );
                m_pString       = strdup( pBuffer );
                m_Length        = (u32)strlen( m_pString );
                return *this;
        }

        KStr&   operator =( float Value )
        {
                char    pBuffer[20];
                sprintf( pBuffer, "%f", Value );
                m_pString       = strdup( pBuffer );
                m_Length        = (u32)strlen( m_pString );
                return *this;
        }

        //
        //      +=
        //
        KStr&   operator +=( KStr& Str )
        {
                char*   pTemp;

                pTemp = (char*)malloc( GetLength() + Str.GetLength() + 1 );
                strcpy( pTemp, m_pString );
                strcat( pTemp, Str.GetpString() );
                SetpString( pTemp );
                free( pTemp );
                return *this;
        }

        KStr&   operator +=( char* pString )
        {
                char*   pTemp;

                pTemp = (char*)malloc( GetLength() + strlen( pString ) + 1 );
                strcpy( pTemp, m_pString );
                strcat( pTemp, pString );
                SetpString( pTemp );
                free( pTemp );
                return *this;
        }

        KStr&   operator +=( char Char )
        {
                char*   pTemp;

                pTemp = (char*)malloc( GetLength() + 2 );
                strcpy( pTemp, m_pString );
                pTemp[GetLength() + 1] = '\0';
                pTemp[GetLength()] = Char;
                SetpString( pTemp );
                free( pTemp );
                return *this;
        }

        KStr&   operator +=( const char* pString )
        {
                char*   pTemp;

                pTemp = (char*)malloc( GetLength() + strlen( pString ) + 1 );
                strcpy( pTemp, m_pString );
                strcat( pTemp, pString );
                SetpString( pTemp );
                free( pTemp );
                return *this;
        }

        KStr    operator +( const char* pString )
        {
                KStr    sResult( m_pString );
                sResult += pString;

                return sResult;
        }

        KStr&   operator +=( s32 Value )
        {
                char    pBuffer[20];
                char*   pTemp;
                sprintf( pBuffer, "%i", (int)Value );
                pTemp = (char*)malloc( GetLength() + strlen( pBuffer ) +1 );
                strcpy( pTemp, m_pString );
                strcat( pTemp, pBuffer );
                SetpString( pTemp );
                free( pTemp );
                return *this;
        }

        KStr&   operator +=( float Value )
        {
                char    pBuffer[20];
                char*   pTemp;
                sprintf( pBuffer, "%f", Value );
                pTemp = (char*)malloc( GetLength() + strlen( pBuffer ) +1 );
                strcpy( pTemp, m_pString );
                strcat( pTemp, pBuffer );
                SetpString( pTemp );
                free( pTemp );
                return *this;
        }

        char&   operator []( u32 Index )
        {
                KASSERT( Index < m_Length );
                return m_pString[Index];
        }

        operator const char*()
        {
                return m_pString;
        }

        operator char*()
        {
                return m_pString;
        }
        //
        //      ==
        //
        bool    operator ==( KStr& Str )
        {
                return (stricmp( m_pString, Str.GetpString() ) == 0);
        }

        bool    operator !=( KStr& Str )
        {
                return (stricmp( m_pString, Str.GetpString() ) != 0);
        }
};

#endif //       __STR_H__

---