string.hpp

Go to the documentation of this file.

#ifndef __LOGOG_STRING_HPP__
#define __LOGOG_STRING_HPP__

#ifdef LOGOG_UNICODE

typedef wchar_t LOGOG_CHAR;
#define L0 (const LOGOG_CHAR *)'\0'
#define LNULL (const LOGOG_CHAR *)'\0'
#define L__null (const LOGOG_CHAR *)'\0'

/* Two indirect references are necessary in order to expand a string and append the L to it. */
#define LOGOG_CONST_STRING_INDIRECT(x) L ## x
/* This macro will cause a const string to be stored as a Unicode string on a Unicode build. */
#define LOGOG_CONST_STRING(x) LOGOG_CONST_STRING_INDIRECT(x)
#define LOGOG_COUT  std::wcout
#define LOGOG_CERR  std::wcerr

#else // LOGOG_UNICODE

typedef char LOGOG_CHAR;
#define LOGOG_CONST_STRING(x) (x)
#define LOGOG_COUT  std::cout
#define LOGOG_CERR  std::cerr
#endif // LOGOG_UNICODE

#ifndef LOGOG_USE_PREFIX

#define _LG( x ) LOGOG_CONST_STRING( x )
#endif 

namespace logog
{
        class String : public Object
        {
        public:

                static const size_t npos = (size_t) -1;

                String();
                virtual ~String();
                virtual void Free();
                static size_t Length( const LOGOG_CHAR *chars );

                String( const String &other );
                String( const LOGOG_CHAR *pstr );
                String & operator =( const String & other);
                String & operator =( const LOGOG_CHAR *pstr );
                size_t size() const;
                virtual void clear();
                virtual size_t reserve( size_t nSize );
                virtual size_t reserve_for_int();
                virtual operator const LOGOG_CHAR *() const;
                virtual size_t assign( const String &other );
                virtual size_t append( const String &other );
                virtual size_t append( const LOGOG_CHAR *other );
                virtual void reverse( LOGOG_CHAR* pStart, LOGOG_CHAR* pEnd);
                virtual size_t assign( const int value );
                virtual size_t append( const LOGOG_CHAR c );
                virtual bool is_valid() const;
                virtual size_t assign( const LOGOG_CHAR *other, const LOGOG_CHAR *pEnd = NULL );

                virtual size_t find( String &other ) const;
                virtual void format( const LOGOG_CHAR *cFormatString, ... );
                virtual void format_va( const LOGOG_CHAR *cFormatString, va_list args );

                virtual const LOGOG_CHAR* c_str() const;

        protected:
                virtual void Initialize();

                /* Code modified from http://www-igm.univ-mlv.fr/~lecroq/string/node8.html#SECTION0080 */
                void preKmp(size_t m);

                size_t KMP( const LOGOG_CHAR *y, size_t n );

#define LOGOG_MAX( a, b ) ( ( a > b ) ? a : b )

                size_t BM(LOGOG_CHAR *y, size_t n);

                LOGOG_CHAR *m_pBuffer;
                LOGOG_CHAR *m_pOffset;
                LOGOG_CHAR *m_pEndOfBuffer;
                size_t *m_pKMP;
                bool m_bIsConst;
        };
}

#define LOGOG_STRING ::logog::String

#endif // __LOGOG_STRING_HPP_