xmog_quickstring.h

//
// Copyright (c) 1999-2020 by Codemesh, Inc.. ALL RIGHTS RESERVED.
//
 
 
#ifndef xmog_quickstring_inc
#define xmog_quickstring_inc
 
 
#if (XMOG_WINDOWS==1 && _MSC_VER <= 1200)
 
#define     XMOG_QSTR(x)        xmog_qstr_##x##_char
#define     XMOG_QSTR_1(x,y)    xmog_qstr_##x##_##y
#define     XMOG_QSTR_TYPE(x,y) class xmog_qstr_##x##_##y \
{\
private:\
        \
    y       buffer[ x ];\
    \
    y *     pBuffer;\
    \
    size_t      cUsed;\
    \
public:\
       \
    xmog_qstr_##x##_##y() :\
      pBuffer( 0 ),\
      cUsed( 0 )\
    {\
    }\
    \
    \
    xmog_qstr_##x##_##y( const y * pStr, size_t max = (size_t)-1 ) :\
      pBuffer( 0 ),\
      cUsed( 0 )\
    {\
        if( max != 0 )\
            append( pStr, max == (size_t)-1 ? 0 : max );\
        else\
            buffer[ 0 ] = 0;\
    }\
    \
    xmog_qstr_##x##_##y( xmog_qstr_##x##_##y & rhs ) :\
        pBuffer( 0 ),\
        cUsed( 0 )\
    {\
        if( rhs.cUsed > 0 )\
            append( (const y*)rhs, rhs.cUsed );\
        else\
            buffer[ 0 ] = 0;\
    }\
    \
    \
    xmog_qstr_##x##_##y &   operator = ( const xmog_qstr_##x##_##y & rhs )\
    {\
        if( pBuffer != NULL )\
        {\
            delete[] pBuffer;\
            pBuffer = NULL;\
        }\
        \
        cUsed = 0;\
        \
        if( rhs.cUsed > 0 )\
            append( (const y*)rhs, rhs.cUsed );\
        else\
            buffer[ 0 ] = 0;\
            \
        return *this;\
    }\
    \
    \
    xmog_qstr_##x##_##y &   operator = ( const y * pStr )\
    {\
        if( pBuffer != NULL )\
        {\
            delete[] pBuffer;\
            pBuffer = NULL;\
        }\
        \
        cUsed = 0;\
        buffer[ 0 ] = 0;\
        \
        append( pStr );\
        \
        return *this;\
    }\
    \
    ~xmog_qstr_##x##_##y()\
    {\
        if( pBuffer )\
            delete[] pBuffer;\
        buffer[ 0 ] = 0;\
        pBuffer = 0;\
    }\
    \
    operator    y * ()\
    {\
        return pBuffer ? pBuffer : buffer;\
    }\
    \
    operator    const y * () const\
    {\
        return pBuffer ? pBuffer : buffer;\
    }\
    \
    void        alloc( size_t size )\
    {\
        if( size > x )\
            pBuffer = new y[ size ];\
    }\
    \
    void        append( const y * str, size_t max = 0 )\
    {\
        if( str == 0 )\
            return;\
            \
        size_t  len = max ? max : strlen( str );\
        \
        if( pBuffer == 0 && cUsed + len < x )\
        {\
            strncpy( buffer + cUsed, str, len + 1 );\
            cUsed += len;\
        }\
        else\
        {\
            y * temp = new y[ cUsed + len + 1 ];\
            \
            if( pBuffer )\
            {\
                strncpy( temp, pBuffer, cUsed );\
                delete[] pBuffer;\
            }\
            else\
                strncpy( temp, buffer, cUsed );\
                \
            strncpy( temp + cUsed, str, len + 1 );\
            pBuffer = temp;\
            cUsed += len;\
        }\
        \
        (pBuffer?pBuffer:buffer)[ cUsed ] = 0;\
    }\
    \
    void    replace( y src, y dest )\
    {\
        y * pElem = pBuffer ? pBuffer : buffer;\
        \
        for( jint i=(jint)cUsed-1; i>=0; --i, pElem++ )\
            if( *pElem == src )\
                *pElem = dest;\
    }\
    \
    size_t  length() const\
    {\
        return cUsed;\
    }\
};
 
XMOG_QSTR_TYPE(32,char)
XMOG_QSTR_TYPE(64,char)
XMOG_QSTR_TYPE(256,char)
XMOG_QSTR_TYPE(512,char)
XMOG_QSTR_TYPE(1024,char)
 
#else
 
#define     XMOG_QSTR(x)        xmog_qstr<x>
#define     XMOG_QSTR_1(x,y)    xmog_qstr<x,y>
 
template < int PreAlloc, class ElemType = char > class xmog_qstr
{
private:
 
    ElemType        buffer[ PreAlloc ];
 
    ElemType *      pBuffer;
 
    size_t      cUsed;
 
public:
 
    xmog_qstr() :
      pBuffer( 0 ),
      cUsed( 0 )
    {
    }
 
 
    xmog_qstr( const ElemType * pStr, size_t max = (size_t)-1 ) :
      pBuffer( 0 ),
      cUsed( 0 )
    {
        if( max != 0 )
            append( pStr, max == (size_t)-1 ? 0 : max );
        else
            buffer[ 0 ] = 0;
    }
 
    xmog_qstr( xmog_qstr & rhs ) :
        pBuffer( 0 ),
        cUsed( 0 )
    {
        if( rhs.cUsed > 0 )
            append( (const ElemType*)rhs, rhs.cUsed );
        else
            buffer[ 0 ] = 0;
    }
 
 
    xmog_qstr & operator = ( const xmog_qstr & rhs )
    {
        if( pBuffer != NULL )
        {
            delete[] pBuffer;
            pBuffer = NULL;
        }
        
        cUsed = 0;
 
        if( rhs.cUsed > 0 )
            append( (const ElemType*)rhs, rhs.cUsed );
        else
            buffer[ 0 ] = 0;
 
        return *this;
    }
 
 
    xmog_qstr & operator = ( const ElemType * pStr )
    {
        if( pBuffer != NULL )
        {
            delete[] pBuffer;
            pBuffer = NULL;
        }
        
        cUsed = 0;
        buffer[ 0 ] = 0;
 
        append( pStr );
 
        return *this;
    }
 
    ~xmog_qstr()
    {
        if( pBuffer )
            delete[] pBuffer;
        buffer[ 0 ] = 0;
        pBuffer = 0;
    }
 
    operator    ElemType * ()
    {
        return pBuffer ? pBuffer : buffer;
    }
 
    operator    const ElemType * () const
    {
        return pBuffer ? pBuffer : buffer;
    }
 
    void        alloc( size_t size )
    {
        if( size > PreAlloc )
            pBuffer = new ElemType[ size ];
    }
 
    void        append( const ElemType * str, size_t max = 0 )
    {
        if( str == 0 )
            return;
 
        size_t  len = max ? max : strlen( str );
 
        if( pBuffer == 0 && cUsed + len < PreAlloc )
        {
            strncpy( buffer + cUsed, str, len + 1 );
            cUsed += len;
        }
        else
        {
            ElemType *  temp = new ElemType[ cUsed + len + 1 ];
 
            if( pBuffer )
            {
                strncpy( temp, pBuffer, cUsed );
                delete[] pBuffer;
            }
            else
                strncpy( temp, buffer, cUsed );
 
            strncpy( temp + cUsed, str, len + 1 );
            pBuffer = temp;
            cUsed += len;
        }
 
        (pBuffer?pBuffer:buffer)[ cUsed ] = 0;
    }
 
    void    replace( ElemType src, ElemType dest )
    {
        ElemType *  pElem = pBuffer ? pBuffer : buffer;
 
        for( jint i=(jint)cUsed-1; i>=0; --i, pElem++ )
            if( *pElem == src )
                *pElem = dest;
    }
 
    size_t  length() const
    {
        return cUsed;
    }
};
 
#endif // _MSC_VER <= 1200
 
#endif //xmog_quickstring_inc