StringBuilder.h

#pragma once

#include "NPLMemPool.h"

namespace ParaEngine
{
    // forward declare
    template <typename UserAllocator = ParaEngine::CNPLPool_Char_allocator >
    class StringBuilderT;

    typedef StringBuilderT< ParaEngine::CNPLPool_Char_allocator > StringBuilder;

    template <typename UserAllocator>
    class StringBuilderT
    {
    public:
        typedef std::string string_type;
        typedef UserAllocator user_allocator;
        typedef char Char;

        StringBuilderT(const string_type& sz);

        StringBuilderT(const Char* sz);

        StringBuilderT(Char ch, size_t count);

        StringBuilderT(size_t reserved);

        StringBuilderT();

        ~StringBuilderT();

        void reserve(size_t length);

        void resize(size_t length);

        inline size_t length() const { return m_size; }
        inline size_t size() const { return m_size; }

        void clear();

        inline bool empty() const { return m_size == 0; }

        void append(Char c);

        void append(const string_type& sz);

        void append(const Char* sz);

        void append(const Char* sz, size_t len);

        void append(const StringBuilderT<UserAllocator>& b);

        void append(int32 i);
        void append(uint32 i); 
        void append(uint64 i); 
        void appendBinary(uint16 i);
        void appendBinary(uint32 i); 
        void appendHex(uint8 i);
        template <class T> inline void appendHex(const T& i) { for (size_t j = 0; j < sizeof(T); ++j) appendHex(*(((uint8*)&i) + j)); } 
#if defined(WIN32)
        inline void append(int i) { append((int32) i); } 
#ifdef _W64
        inline void append(_W64 unsigned int i) { append((uint32) i); } 
#else
        inline void append(unsigned int i) { append((uint32) i); } 
#endif
#else
        // inline void append(unsigned long i) { append((uint32) i); } /**< See above. */
        inline void append(long i) { append((int32) i); } 
#endif // platform-switch.

        void append(float f);
        void append(double f); 
        template<typename TYPE> 
        void WriteAt(int nIndex, const TYPE& val){
            // *((TYPE*)(m_buffer + nIndex)) = val;
            memcpy(m_buffer + nIndex, &val, sizeof(TYPE)); // fix byte alignment issue
        }

        void WriteAt(int nIndex, const Char* data, size_t nSize);


        template<typename TYPE> inline StringBuilderT& operator+=(const TYPE& val) { append(val); return *this; }

        void appendLine(const Char* sz);

        void remove(int32 start);

        void remove(int32 start, int32 end);

        inline void pop_back() { if (m_size > 0) --m_size; }

        template<typename TYPE> inline void set(const TYPE& val) { clear(); append(val); }
        template<typename TYPE> inline StringBuilderT& operator=(const TYPE& val) { clear(); append(val); return *this; } 
        string_type ToString() const { return string_type(c_str(), length()); };

        const Char* c_str() const;
        inline operator const Char*() const { return c_str(); } 
        Char* str() { return m_buffer; };

        Char& operator[] (const int nIndex) { return *(m_buffer+nIndex); }; 

        int32 index(Char c) const;

        int32 rindex(Char c) const;

        Char back() const { assert(m_size > 0); return m_buffer[m_size-1]; }
    private:
        void enlarge(size_t minimum);

    private:
        Char* m_buffer;
        size_t m_reserved;
        size_t m_size;
    };

    template <typename UserAllocator>
    void ParaEngine::StringBuilderT<UserAllocator>::appendBinary(uint32 i)
    {
        append((const char*)(&i), 4);
    }

    template <typename UserAllocator>
    void ParaEngine::StringBuilderT<UserAllocator>::appendBinary(uint16 i)
    {
        append((const char*)(&i), 2);
    }

}

// required by DLL interface
// EXPIMP_TEMPLATE template class PE_CORE_DECL ParaEngine::StringBuilderT< ParaEngine::CNPLPool_Char_allocator >;