Subversion Repositories spk

#ifndef STRING_BUILDER_INCLUDED
#define STRING_BUILDER_INCLUDED

#include <math.h>
#include <string.h>
#include "stream_base.h"

template <class Ty>
class string_builder_base : public mystream::stream_base
{
        public:
                typedef mystream::stream_base base;
                typedef Ty value_type;
                typedef Ty* value_type_ptr;
                typedef const Ty* const_value_type_ptr;
                typedef size_t size_type;
                
        private:
                value_type_ptr m_buffer;
                size_type m_bufferSize;
                size_type m_stringSize;
                size_type m_growby;
                
                bool allocate(size_type newsize)
                {
                        if(allocated() < newsize) {
                                value_type_ptr old=m_buffer;
                                size_type oldsize=m_bufferSize;
                                
                                int c=(int)ceil((float)newsize / growby());
                                m_bufferSize=c * growby();
                                m_buffer=new value_type[m_bufferSize];
                                if(m_buffer==NULL){
                                        setstate(failbit);
                                        m_buffer=old;
                                        m_bufferSize=oldsize;
                                }
                                else{
                                        memcpy(m_buffer, old, oldsize * sizeof(value_type));
                                        delete[] old;
                                }
                        }
                        return (state() & failbit)==0;
                }
                
                void init()
                {
                        m_buffer=0; m_bufferSize=m_stringSize=0; 
                        base::clear(badbit);
                }
                
                size_type strlen(const wchar_t *str) { return (size_type)::wcslen(str); }
                size_type strlen(const char *str) { return (size_type)::strlen(str); }
                
        public:
                string_builder_base() { init(); growby(0); }
                string_builder_base(const_value_type_ptr str) 
                {
                        init(); growby(0);
                        append(str);
                }
                
                string_builder_base(const string_builder_base& str) 
                {
                        init(); growby(0);
                        append(str);
                }
                
                bool reserve(size_type newsize) { return allocate(newsize); }
                size_type allocated() const { return m_bufferSize; }
                size_type size() const { return m_stringSize; }
                void size(size_type newsize) { m_stringSize=(newsize > allocated() ? allocated() : newsize); }
                
                size_type growby() const { return m_growby; }
                void growby(size_type newgrow) { if(newgrow==0) newgrow=100; m_growby=newgrow; }
                
                ~string_builder_base() { delete[] m_buffer; }
                
                string_builder_base& append(const_value_type_ptr str)
                {
                        size_type s=strlen(str);
                        size_type newsize=size() + s;
                        if(allocate(newsize + 1)==false)
                                return *this;
                        memcpy(m_buffer + size(), str, (s + 1) * sizeof(value_type));
                        size(newsize);
                        base::clear(m_buffer ? goodbit : badbit);
                        
                        return *this;
                }
                
                string_builder_base& append(const string_builder_base& str)
                {
                        size_type newsize=size() + str.size();
                        if(allocate(newsize + 1)==false)
                                return *this;
                        memcpy(m_buffer + size(), str, (str.size() + 1) * sizeof(value_type));
                        size(newsize);
                        base::clear(m_buffer ? goodbit : badbit);
                        
                        return *this;
                }
                
                string_builder_base& append(const value_type& ch)
                {
                        //if(!good()) return;
                        size_type newsize=size() + 1;
                        if(allocate(newsize + 1)==false) 
                                return *this;
                        m_buffer[size()]=ch;
                        m_buffer[size() + 1]=0;
                        size(newsize);
                        base::clear(m_buffer ? goodbit : badbit);
                        return *this;
                }
                
                value_type_ptr getbuffer() 
                {
                        value_type_ptr b=m_buffer;
                        init();
                        return b;
                }
                
                void clear()
                {
                        delete[] m_buffer;
                        init();
                }
                
                const_value_type_ptr buffer() const { return m_buffer; }
                
                operator const_value_type_ptr () const { return m_buffer; }
                
                string_builder_base& operator = (const string_builder_base& other)
                {
                        if(other.m_buffer==0) {
                                delete[] m_buffer;
                                init();
                        }
                        else 
                                (*this)=other.m_buffer;
                        
                        return *this;
                }
                
                string_builder_base& operator = (const_value_type_ptr str)
                {
                        size(0);
                        append(str);
                        base::clear(m_buffer ? goodbit : badbit);
                        return *this;
                }
                
};

class string_builder : public string_builder_base<char>
{
        public:
                typedef string_builder_base<char> base;
                string_builder() : string_builder_base<char>() { }
                string_builder(const char *str) : string_builder_base<char>(str) { }
                
                string_builder& operator = (const_value_type_ptr str) { return (string_builder&)base::operator =(str); }
};

inline string_builder& operator << (string_builder& is, const char *str)
{
        is.append(str);
        return is;
}

inline string_builder& operator << (string_builder& is, char ch)
{
        is.append(ch);
        return is;
}

class wstring_builder : public string_builder_base<wchar_t>
{
        public:
                wstring_builder() : string_builder_base<wchar_t>() { }
                wstring_builder(const wchar_t *str) : string_builder_base<wchar_t>(str) { }
};

inline wstring_builder& operator << (wstring_builder& is, const wchar_t *str)
{
        is.append(str);
        return is;
}

inline wstring_builder& operator << (wstring_builder& is, wchar_t ch)
{
        is.append(ch);
        return is;
}

inline wstring_builder& operator << (wstring_builder& is, int i)
{
        is.append((wstring_builder::value_type)i);
        return is;
}

#endif // !defined(STRING_BUILDER_INCLUDED)