StringBuffer.h

//
// Copyright (c) 2006-2014 Raphael David / CANTOR
//


#ifndef CMR_STRING_BUFFER_INCLUDED
#define CMR_STRING_BUFFER_INCLUDED

#include "Commore.h"
#include "AString.h"


namespace commore
{
    typedef StringBuffer* PStringBuffer;

    class CMREXD StringBuffer
    {
    public:
        struct Page;
        typedef Page* PPage;

        class ConstPageIterator
        {
        public :
            ConstPageIterator()
                : current_(0)             {}
            ConstPageIterator(const Page* p)
                : current_(p)              {}
            ConstPageIterator(const StringBuffer& sb)
                : current_(sb.first_)      {}

        public:
            bool more() const { return current_ != 0; }
            const char* current() { if (current_) { return (const char*) &current_->s_[0]; } else { return ""; } }
            size_t next()
            {
                if (current_)
                {
                    current_ = current_->next_;
                }
                if (current_)
                {
                    return current_->size_;
                }
                return 0;
            }
            size_t get_size() const
            {
                if (current_)
                {
                    return current_->size_;
                }
                return 0;
            }
            ConstPageIterator  operator++(int)
            {
                ConstPageIterator r = *this;
                next();
                return r;
            }
            ConstPageIterator& operator++() { next(); return *this; }
            const char* operator*() { return current(); }
            bool  operator==(const ConstPageIterator& i) const { return i.current_ == current_; }
        private:
            const Page* current_;

        };
        friend class  ConstPageIterator;

        class ConstIterator
        {
        public :
            ConstIterator() : size_(0), index_(0), current_(0) {}
            ConstIterator(size_t t, int i, const Page* p) : size_(t), index_(i), current_(p) {}
            ConstIterator(const StringBuffer& sb) : size_(sb.size_), index_(0), current_(sb.first_)  {}
        public:
            bool more() const { return size_ > index_; }
            const char& current()
            {
                if (current_)
                {
                    return *(const char*)&current_->s_[index_ % PAGE_SIZE];
                }
                else
                {
                    return *"";
                }
            }
            size_t pos() { return index_; }
            size_t next()
            {
                if (size_ > index_)
                {
                    if ((index_ + 1) % PAGE_SIZE == 0)
                    {
                        current_ = current_->next_;
                    }
                    ++index_;
                }
                return index_;
            }
            ConstIterator  operator++(int)
            {
                ConstIterator r = *this;
                next();
                return r;
            }
            ConstIterator& operator++() { next(); return *this; }
            const char& operator*() { return current(); }
            bool  operator==(const ConstIterator& i) const { return i.index_ == index_; }

        private:
            size_t size_;
            size_t index_;
            const Page* current_;

        };
        friend class  ConstIterator;
        typedef ConstIterator const_iterator;   // naming consistency with other commore classes

        class Iterator
        {
        public :
            Iterator()
                : size_(0), index_(0), current_(0)                 {}
            Iterator(size_t t, int i, Page* p)
                : size_(t), index_(i), current_(p)                 {}
            Iterator(StringBuffer& sb)
                : size_(sb.size_), index_(0), current_(sb.first_)  {}

        public:
            bool more() const { return size_ > index_; }
            char& current()
            {
                char* u = (char*) &current_->s_[0];

                int i = index_ % PAGE_SIZE;
                return u[i];
            }
            size_t next()
            {
                if (size_ > index_)
                {
                    if ((index_ + 1) % PAGE_SIZE == 0)
                    {
                        current_ = current_->next_;
                    }
                    ++index_;
                }
                return index_;
            }
            Iterator  operator++(int)
            {
                Iterator r = *this;
                next();
                return r;
            }
            Iterator& operator++()
            {
                next();
                return *this;
            }
            char& operator*() { return current(); }
            bool  operator==(const Iterator& i) const { return i.index_ == index_; }

        private:
            size_t size_;
            size_t index_;
            Page* current_;

        };
        friend class Iterator;
        typedef Iterator iterator;

        struct Page
        {
            Page() : next_(0) {}
            PStringBuffer cont_;
            size_t size_;
            PPage next_;
            unsigned char s_[4];

        };

        //class StreamBuf;
        //friend class StreamBuf;

    public:
        enum { PAGE_SIZE = 128 };

    public :
        StringBuffer(size_t page_size = PAGE_SIZE);
        StringBuffer(const char* s, size_t page_size = PAGE_SIZE);
        StringBuffer(const StringBuffer& s);
        StringBuffer(const StringBuffer& s, size_t page_size);
        StringBuffer& operator =(const StringBuffer& C)
        {
            clear();
            append(C);
            return *this;
        }
        StringBuffer& operator =(const char* s)
        {
            clear();
            append(s);
            return *this;
        }
        ~StringBuffer();

    public:
        size_t  get_size() const { return size_; }
        size_t  size() const { return size_; }
        size_t  get_page_size() const { return page_size_; }
        void  clear();
        void  splice(StringBuffer& x);
        size_t  append(char);
        size_t  append(const char*);
        size_t  append(const StringBuffer&);
        char* append();
        size_t  add_size(size_t size);
        
        StringBuffer& operator +=(char c)
        {
            append(c);
            return *this;
        }
        StringBuffer& operator +=(const char* s)
        {
            append(s);
            return *this;
        }
        StringBuffer& operator +=(const StringBuffer& C)
        {
            append(C);
            return *this;
        }
        StringBuffer& operator +=(const StringBuffer* C)
        {
            append(*C);
            return *this;
        }
        StringBuffer& operator <<(char c)
        {
            append(c);
            return *this;
        }
        StringBuffer& operator <<(const char* s)
        {
            append(s);
            return *this;
        }
        StringBuffer& operator <<(const StringBuffer& C)
        {
            append(C);
            return *this;
        }
        StringBuffer& operator <<(const StringBuffer* C)
        {
            append(*C);
            return *this;
        }
        const char* c_str(char* s, size_t size) const;
        const char* c_str(AString& s) const;
        const char* c_str(const AString& s = AString()) const;

        const_iterator begin() const
        {
            return const_iterator(size_, 0, first_);
        }
        iterator  begin()
        {
            return iterator(size_, 0, first_);
        }
    
        const_iterator cbegin() const 
        {
            return begin();
        }

        int  compare(const StringBuffer&) const;
        int  compare(const char*) const;
        bool  operator<(const StringBuffer& s) const
        {
            return compare(s) < 0;
        }
        bool  operator>(const StringBuffer& s) const
        {
            return compare(s) > 0;
        }
        bool  operator>(const char* s) const
        {
            return compare(s) > 0;
        }
        bool  operator<(const char* s) const
        {
            return compare(s) < 0;
        }
        bool  operator==(const StringBuffer& s) const
        {
            return compare(s) == 0;
        }
        bool  operator==(const char* s) const
        {
            return compare(s) == 0;
        }

        long  write(CommBuffer& buffer) const;
        long  read(const CommBuffer& buffer);
        long  write_xml(OBStream& o) const;
        long  write(OBStream& o) const;
        long  write(OBStream& o, const char* delimitor) const;
        long  read(IBStream& i);
        long  read(IBStream& i, const char* delimitor);
        long  read_xml(IBStream& i);
        long  write(const Path& file_name, bool check = false) const;
        long  read(const Path& fileName);

    private:
        size_t  page_size_;
        size_t  size_;
        PPage first_;
        PPage last_;
        void  add_page_();
        PPage  allocate_(size_t size);
        void  release_(PPage p);


    };
};

inline commore::OBStream& operator<<(commore::OBStream& o,  const commore::StringBuffer& b)
{
    b.write(o);
    return o;
}
#endif