longstring.h

Go to the documentation of this file.

#ifndef LONGSTRING_H_
#define LONGSTRING_H_

#include <string>
#include "utils.h"

namespace AP_LSystem {
static unsigned int ZERO = 0;

class LongString
{
private:
    char * m_String;                
    unsigned int m_Length;          
    unsigned int m_Allocated;       
    unsigned int m_Increment;       


    inline Parameter::Type getType(double) { return Parameter::LS_DOUBLE; }
    inline Parameter::Type getType(double *) { return Parameter::LS_DOUBLE; }
    inline Parameter::Type getType(unsigned int) { return Parameter::LS_UINT; }
    inline Parameter::Type getType(unsigned char) { return Parameter::LS_UBYTE; }
    inline Parameter::Type getType(int) { return Parameter::LS_INT; }
    inline Parameter::Type getType(int *) { return Parameter::LS_INT; }

    void resize();

    void append( std::string str );

    void append( Parameter::Type type );
public:
    LongString( unsigned int length = 1048576); // 2^20 bytes - 1 MB

    LongString( const LongString& c );

    LongString& operator=( const LongString & c );

    ~LongString( );
    
    void convertFromString( std::string * str, unsigned int & = ZERO, const char = '\0' );
    
    template< class T >
    void append( T par )
    {
        if(m_Allocated < m_Length + sizeof( T ) + 2)
        {
            resize( );
        }
        append( getType(par) );
        memcpy( m_String + m_Length, &par, sizeof( T ) );
        m_Length += sizeof( T );
        append( getType(par) );
    }

    void append( const char ch );
    

    void append( const char * data, int length);

    void append( LongString * ls);

    template< class T >
    bool getParameters( unsigned int & pos, T * pParams, int & paramsCnt )
    {
        if(pos >= m_Length)
            return false;

        char * pPos = m_String + pos + 1;
        // while pointer pPos points correctly to m_String buffer
        //                      and 
        //       the parameter in buffer has the same type as parameter array pParams
        while(((pPos - m_String) < static_cast<int>(m_Length) ) && (*pPos == getType(pParams)))
        {
            // copy parameter to parameter array
            memcpy(pParams + paramsCnt, ++pPos, sizeof(T));
            // increment parameter counter
            paramsCnt++;
            // move pointer behind the parameter in m_String buffer
            pPos += sizeof(T)+1;
        }
        pos = pPos - m_String - 1;
        return true;
    }

    char * getData( );


    char * getData( unsigned int & pos, unsigned int & length, char delimiter);

    char * getSymbol( unsigned int & pos );

    int matchRight( char ch, int pos, const std::string * ignore = NULL, const std::string * consider = NULL );

    int matchLeft( char ch, int pos, const std::string * ignore = NULL, const std::string * consider = NULL );

    char peekSymbol( int & pos, bool direction );

    int findMatchingRightBracket( int pos );

    int findMatchingLeftBracket( int pos );
    
    std::string toString( );

    inline char& operator[](unsigned int i) const
    {
        return m_String[i];
    }

    inline unsigned int length() const
    {
        return m_Length;
    }
};
}
#endif // LONGSTRING_H