xmog_quickstring.h

/*
 * Copyright 1999-2006 by Codemesh, Inc.  ALL RIGHTS RESERVED.
 */

#ifndef xmog_quickstring_inc
#define xmog_quickstring_inc


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 = -1 ) :
      pBuffer( 0 ),
      cUsed( 0 )
    {
        if( max != 0 )
            append( pStr, max == -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 //xmog_quickstring_inc

---