AString.h

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

#ifndef CMR_ASTRING_INCLUDED
#define CMR_ASTRING_INCLUDED


#include "Commore.h"

namespace commore
{
    struct RawAString
    {
        size_t  size;
        size_t  capacity;
        AChar  data[4];
    };
    typedef RawAString* PRawAString;

    class CMREXD AString
    {
        friend class Iterator;

    public:
        AString();
        AString(const AString& str);
        AString(const AString& str, size_t pos, size_t n = (size_t)npos);
        AString(const AChar* str, size_t n);
        AString(const AChar* str);
        AString(const Char* str);
        AString(size_t n, AChar c);
        AString(AChar c, size_t n);
        AString(const void* v, size_t n, size_t base = 16);
        AString& operator = (const AString& str)
        {
            return assign(str);
        }
        AString& operator = (const AChar* str)
        {
            return assign(str);
        }
        AString& operator = (AChar c)
        {
            assign_helper(c, 1);
            return *this;
        }
        operator const AChar* () const
        {
            return c_str();
        }
        ~AString();

    public:

        typedef            AChar  value_type;
        typedef             size_t  size_type;
        typedef            AChar& reference;
        typedef      const AChar& const_reference;
        typedef            AChar* pointer;
        typedef      const AChar* const_pointer;

        enum { STRING_INCREMENT_SIZE = 16 };

    public:
        bool  operator == (const AString& str) const
        {
            return compare(str) == 0;
        }
        bool  operator == (const AChar* str) const
        {
            return compare(str) == 0;
        }
        bool  operator != (const AString& str) const
        {
            return !compare(str) == 0;
        }
        bool  operator != (const AChar* str) const
        {
            return !compare(str) == 0;
        }
        bool operator < (const commore::AString& str) const
        {
            return compare(str) < 0;
        }
        bool operator > (const commore::AString& str) const
        {
            return compare(str) > 0;
        }
        AString& operator += (const AString& str)
        {
            return append(str);
        }
        AString  operator + (const AString& str) const;

        AString& operator += (const AChar* str)
        {
            return append(str);
        }
        AString& operator += (AChar c)
        {
            append_helper(c, 1);
            return *this;
        }

        AString& append(const AString& str)
        {
            append_helper(str, 0, (size_t)npos);
            return *this;
        }

        AString& append(const AString& str, size_t pos, size_t n)
        {
            append_helper(str, pos, n);
            return *this;
        }
        AString& append(const AChar* str, size_t n)
        {
            append_helper(str, n);
            return *this;
        }
        AString& append(const AChar* str)
        {
            append_helper(str, length(str));
            return *this;
        }

        AString& append(size_t n, AChar c)
        {
            append_helper(c, n);
            return *this;
        }

        bool validate_range(size_t pos, size_t* len) const
        {
            size_t s = size();
            if (pos > s)
            {
                *len = 0;
                // ERROR OUT OF RANGE
                return false;
            }
            if (*len > (s - pos))
            {
                *len = s - pos; // Clamp to actual length.
                return false;
            }
            return true;
        }
        AString& assign(const AString& other);
        AString& assign(const AString& str, size_t pos, size_t n)
        {
            if (str.validate_range(pos, &n))
            {
                assign_helper(str.data_->data + pos, n);
            }
            return *this;
        }
        AString& assign(const AChar* str, size_t n)
        {
            assign_helper(str, n);
            return *this;
        }
        AString& assign(const AChar* str)
        {
            assign_helper(str, length(str));
            return *this;
        }
        AString& assign(size_t n, AChar c)
        {
            assign_helper(c, n);
            return *this;
        }

        void  swap(AString& str);
        void  splice(AString& str);

        AString& insert(size_t pos1, const AString& str)
        {
            replace_helper(pos1, 0, str, 0, (size_t)npos);
            return *this;
        }
        AString& insert(size_t pos1, const AString& str, size_t pos2, size_t n)
        {
            replace_helper(pos1, 0, str, pos2, n);
            return *this;
        }
        AString& insert(size_t pos, const AChar* str, size_t n)
        {
            replace_helper(pos, 0, str, n);
            return *this;
        }
        AString& insert(size_t pos, const AChar* str)
        {
            replace_helper(pos, 0, str, length(str));
            return *this;
        }
        AString& insert(size_t pos, size_t n, AChar c)
        {
            replace_helper(pos, 0, c, n);
            return *this;
        }

        AString& clear()
        {
            init();
            return *this;
        }
        AString& erase(size_t pos = 0, size_t n = (size_t)npos)
        {
            replace_helper(pos, n, (const AChar*)0, 0);
            return *this;
        }
        void Delete(size_t pos = 0, size_t n = 1)
        {
            replace_helper(pos, n, (const AChar*)0, 0);
        }
        AString& replace(size_t pos1, size_t n, const AString& str)
        {
            replace_helper(pos1, n, str, 0, str.size());
            return *this;
        }

        AString& replace(size_t pos1, size_t n1, const AString& str, size_t pos2, size_t n2)
        {
            replace_helper(pos1, n1, str, pos2, n2);
            return *this;
        }
        AString& replace(size_t pos1, size_t n1, const AChar* str, size_t n2)
        {
            replace_helper(pos1, n1, str, n2);
            return *this;
        }
        AString& replace(size_t pos, size_t n1, const AChar* str)
        {
            replace_helper(pos, n1, str, length(str));
            return *this;
        }
        AString& replace(size_t pos, size_t n1, size_t n2, AChar c)
        {
            replace_helper(pos, n1, c, n2);
            return *this;
        }

        AString& replace(const AChar* s1, const AChar* s2, bool case_sensitive = true);
        AString& Replace(const AChar* s1, const AChar* s2, bool case_sensitive = true)
        {
            return replace(s1, s2, case_sensitive);
        }

        AChar  operator[](size_t pos) const
        {
            return pos == size() ? eos() : get_at(pos);
        }
        AChar& operator[](size_t pos)
        {
            if (pos < size())
            {
                return *(data_->data + pos);
            }
            else
            {
                return *((AChar*)0);
            }
        }
        AChar  operator[](int pos) const
        {
            return pos == (int)size() ? eos() : get_at((size_t)pos);
        }
        AChar& operator[](int pos)
        {
            if (pos < (int)size())
            {
                return *(data_->data + pos);
            }
            else
            {
                return *((AChar*)0);
            }
        }
        AChar  at(size_t pos) const
        {
            return get_at(pos);
        }

        AChar& at(size_t pos)
        {
            return operator[](pos);
        }
        const AChar* c_str() const
        {
            return data_ ? data_->data : nil_data();
        }
        const AChar* data() const
        {
            return data_ ? data_->data : nil_data();
        }

        size_t  size() const
        {
            return data_->size;
        }
        size_t  length() const
        {
            return data_->size;
        }
        size_t  max_size() const
        {
            return (size_t)npos - 1;
        }
        bool  is_empty() const
        {
            return size() == 0;
        }
        void  resize(size_t n, AChar c)
        {
            resize_helper(n, c);
        }
        void  resize(size_t n)
        {
            resize(n, eos());
        }
        void  resize();
        size_t capacity() const
        {
            return data_->capacity;
        }
        void  reserve(size_t size)
        {
            reserve_helper(size);
        }
        char*  set_buffer(size_t size)
        {
            return allocate(size);
        }
        size_t  copy(AChar* str, size_t n, size_t pos = 0) const
        {
            if (validate_range(pos, &n))
            {
                copy(str, data_->data + pos, n);
            }
            return n;
        }
        
        size_t  find(const AString& str, size_t pos = 0) const { return find(str.data(), pos, str.size()); }
        size_t  find(const AChar* s, size_t pos, size_t n) const;
        size_t  find(const AChar* str, size_t pos = 0) const { return find(str, pos, length(str)); }
        size_t  find(AChar c, size_t pos = 0) const { return find(&c, pos, 1); }
        size_t  find_first_of(const AString& str, size_t pos = 0) const { return find_first_of(str.data(), pos, str.size()); }
        size_t  find_first_of(const AChar* s, size_t pos, size_t n) const;
        size_t  find_first_of(const AChar* str, size_t pos = 0) const { return find_first_of(str, pos, length(str)); }
        size_t  find_first_of(AChar c, size_t pos = 0) const { return find_first_of(&c, pos, 1); }
        size_t  find_first_not_of(const AString& str, size_t pos = 0) const { return find_first_not_of(str.data(), pos, str.size()); }
        size_t  find_first_not_of(const AChar* s, size_t pos, size_t n) const;
        size_t  find_first_not_of(AChar c, size_t pos = 0) const { return find_first_not_of(&c, pos, 1); }
        size_t  find_first_not_of(const AChar* str, size_t pos = 0) const { return find_first_not_of(str, pos, length(str)); }
        size_t  rfind(const AChar* str, size_t pos, size_t n) const;
        size_t  find_last_of(const AChar* s, size_t pos, size_t n) const;
        size_t  find_last_not_of(const AChar* s, size_t pos, size_t n) const;
        size_t  rfind(const AString& str, size_t pos = (size_t)npos) const { return rfind(str.data(), pos, str.size()); }
        size_t  rfind(const AChar* str, size_t pos = (size_t)npos) const { return rfind(str, pos, length(str)); }
        size_t  rfind(AChar c, size_t pos = (size_t)npos) const { return rfind(&c, pos, 1); }
        size_t  find_last_of(const AString& str, size_t pos = (size_t)npos) const { return find_last_of(str.data(), pos, str.size()); }
        size_t  find_last_of(AChar c, size_t pos = (size_t)npos) const { return find_last_of(&c, pos, 1); }
        size_t  find_last_of(const AChar* str, size_t pos = (size_t)npos) const { return find_last_of(str, pos, length(str)); }
        size_t  find_last_not_of(const AString& str, size_t pos = (size_t)npos) const { return find_last_not_of(str.data(), pos, str.size()); }
        size_t  find_last_not_of(const AChar& c, size_t pos = (size_t)npos) const { return find_last_not_of(&c, pos, 1); }
        size_t  find_last_not_of(const AChar* str, size_t pos = (size_t)npos) const { return find_last_not_of(str, pos, length(str)); }
        
        AString  substr(size_t pos = 0, size_t n = (size_t)npos) const;
        
        int  compare(const AString& str) const { return compare_helper(str, 0, (size_t)npos); }
        int  compare(size_t pos, size_t n, const AString& str) const { return compare_helper(str, pos, n); }
        int  compare(size_t pos1, size_t n1, const AString& str, size_t pos2, size_t n2) const
        {
            AString temp(str, pos2, n2);
            return compare_helper(temp, pos1, n1);
        }
        int  compare(const AChar* s) const
        {
            return compare_helper(s, 0, length(s));
        }
        int  compare(size_t pos, size_t n1, const AChar* str, size_t n2 = (size_t)npos) const;
        
        int  icompare(const AString& str) const
        {
            return icompare_helper(str, 0, (size_t)npos);
        }
        int  icompare(size_t pos, size_t n, const AString& str) const
        {
            return icompare_helper(str, pos, n);
        }
        int  icompare(size_t pos1, size_t n1, const AString& str, size_t pos2, size_t n2) const
        {
            AString temp(str, pos2, n2);
            return icompare_helper(temp, pos1, n1);
        }
        int  icompare(const AChar* s) const
        {
            return icompare_helper(s, 0, length(s));
        }
        int  icompare(size_t pos, size_t n1, const AChar* str, size_t n2 = (size_t)npos) const;
        int  CompareNoCase(const AChar* s) const
        {
            return icompare_helper(s, 0, length(s));
        }
        
        Int  to_int() const;
        
        AString&  make_upper();
        AString&  MakeUpper() { return make_upper(); } 
        AString&  make_lower();
        AString&  MakeLower() { return make_lower();}  
        
        bool  match(const AString& pattern) const;
        bool  match(const AString& pattern, AString& a0) const;
        bool  match(const AString& pattern, AString& a0, AString& a1) const;
        bool  match(const AString& pattern, AString& a0, AString& a1, AString& a2) const;
        bool  match(const AString& pattern, AString& a0, AString& a1, AString& a2, AString& a3) const;
        bool  match(const AString& pattern, AString& a0, AString& a1, AString& a2, AString& a3, AString& a4) const;
        bool  match(const AString& pattern, AString& a0, AString& a1, AString& a2, AString& a3, AString& a4, AString& a5) const;
        bool  match(const AString& pattern, AString& a0, AString& a1, AString& a2, AString& a3, AString& a4, AString& a5, AString& a6) const;
        bool  match(const AString& pattern, AString& a0, AString& a1, AString& a2, AString& a3, AString& a4, AString& a5, AString& a6, AString& a7) const;
        
        long  write_xml(OBStream& o) const;
        long  read_xml(IBStream& i);

    public:
        static AChar eos()
        {
            return AChar();
        }

    public:
        static          int compare(const AChar* s1, const AChar* s2, size_t n);
        static          int icompare(const AChar* s1, const AChar* s2, size_t n);
        static  const AChar* find(const AChar* s, int n, const AChar& a);
        static       size_t length(const AChar* s);
        static        AChar* copy(AChar* dest, const AChar* src, size_t n);
        static        AChar* move(AChar* dest, const AChar* src, size_t n);
        static        AChar* assign(AChar* dest, size_t n, const AChar& c);
        static         void assign(AChar& c1, const AChar& c2)
        {
            c1 = c2;
        }
        static         bool eq(const AChar& c1, const AChar& c2)
        {
            return c1 == c2;
        }
        static         bool ne(const AChar& c1, const AChar& c2)
        {
            return !eq(c1, c2);
        }
        static         bool lt(const AChar& c1, const AChar& c2)
        {
            return c1 < c2;
        }
        static         bool ieq(const AChar& c1, const AChar& c2);
        static         bool ine(const AChar& c1, const AChar& c2)
        {
            return !ieq(c1, c2);
        }
        static         bool ilt(const AChar& c1, const AChar& c2);

    private:
        AString& assign(AChar c, size_t n = 1)
        {
            assign_helper(c, n);
            return *this;
        }

        AString& append(AChar c, size_t n = 1)
        {
            append_helper(c, n);
            return *this;
        }

        const AChar& get_at(size_t pos) const
        {
            if (pos < size())
            {
                return *(data_->data + pos);
            }
            else
            {
                return *(const AChar*)0;
            }
        }

        void put_at(size_t pos, AChar c);

        void assign_helper(const AChar* data, size_t n);
        void assign_helper(AChar c, size_t n);
        void replace_helper(size_t pos, size_t n1, const AChar* s, size_t n2);
        void replace_helper(size_t pos, size_t n1, AChar c, size_t n2);
        void replace_helper(size_t pos, size_t n1, const AString& str, size_t pos2, size_t n2);
        void append_helper(const AString& str, size_t pos, size_t n);
        void append_helper(const AChar* s, size_t n);
        void append_helper(AChar c, size_t n);

        int compare_helper(const AString& str, size_t pos, size_t n) const;
        int compare_helper(const AChar* s, size_t pos, size_t n) const;

        int icompare_helper(const AString& str, size_t pos, size_t n) const;
        int icompare_helper(const AChar* s, size_t pos, size_t n) const;

        void reserve_helper(size_t capacity);
        void resize_helper(size_t new_count, AChar fill_char);

        AChar* allocate(size_t count);
        void reallocate(size_t count);
        void size(size_t n);
        void init();
        AChar* data()
        {
            return data_->data;
        }
        void assign_(PRawAString& dest, PRawAString src);
        PRawAString reallocate_nocopy_(PRawAString p, size_t new_size);
        PRawAString allocate_(size_t size);
        void release_(PRawAString p);
        PRawAString reallocate_(PRawAString p, size_t new_size);

    private:
        RawAString* data_;

    private:
        static        AChar* nil_data();

        AString& Format(const AChar* format, ...);
    }; // class AString

    long CMREXD read_xml(AString& sOut, IBStream& i);
    long CMREXD write_xml(const AString& sIn, OBStream& o);
    AString CMREXD create_guid();
    AString CMREXD create_cmr_guid();

}


CMREXD commore::AString operator +(const commore::AString& string1, const commore::AString& string2);
CMREXD commore::AString operator +(const commore::AString& string, commore::AChar ch);
CMREXD commore::AString operator +(commore::AChar ch, const commore::AString& string);
CMREXD commore::AString operator +(const commore::AString& string, const commore::AChar* lpsz);
CMREXD commore::AString operator +(const commore::AChar* lpsz, const commore::AString& string);




//CMREXD commore::Log& operator << (commore::Log& log, const commore::AString& t);
//CMREXD commore::Log& operator << (commore::Log& log, const commore::ListAString& t);

CMREXD commore::OBStream& operator << (commore::OBStream& o, const commore::AString& s);
CMREXD commore::IBStream& operator >> (commore::IBStream& i, commore::AString& s);
const CMREXD commore::OBStreamFormat& operator << (const commore::OBStreamFormat& o, const commore::AString&);

CMREXD void DecodeFromUTF8(const commore::AString& source, commore::AString& dest);


#endif