String.h

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

#ifndef CMR_STRING_INCLUDED
#define CMR_STRING_INCLUDED

#include <string.h>
#include "Commore.h"

namespace commore
{
    class AString;

    struct RawString
    {
        size_t  size;
        size_t  capacity;
        Char  data[4];
    };
    typedef RawString* PRawString;

    class CMREXD String
    {
        friend class Iterator;

    public:
        class Allocator
        {
        public:
            virtual ~Allocator() {}
            virtual PRawString allocate(size_t size) = 0;
            virtual PRawString reallocate(PRawString p, size_t size) = 0;

            virtual       void release(PRawString p) = 0;
            virtual       void assign(PRawString& dest, PRawString src) = 0;
        };
        typedef Allocator* PAllocator;

    public:
        typedef            Char  value_type;
        typedef           size_t  size_type;
        typedef            Char& reference;
        typedef      const Char& const_reference;
        typedef            Char* pointer;
        typedef      const Char* const_pointer;

        enum { STRING_INCREMENT_SIZE = 16 };

    public:
        String();
        String(const String& str);
        String(const String& str, size_t pos, size_t n = (size_t)npos);
        String(const Char* str, size_t n);
        String(const Char* str);
        String(const AChar* str, size_t n);
        String(const AChar* str);
        String(size_t n, Char c);
        String& operator = (const String& str) { return assign(str); }
        
        String& operator = (const AChar* str) { return assign(str); }
        String& operator = (const Char* str) { return assign(str); }
        String& operator = (Char c) { assign_helper(c, 1); return *this; }
        ~String();

    public:
        bool  operator == (const AChar* str) const { return compare(str) == 0; }
        bool  operator == (const String& str) const { return compare(str) == 0; }
        bool  operator == (const Char* str) const { return compare(str) == 0; }
        bool  operator != (const AChar* str) const { return !compare(str) == 0; }
        bool  operator != (const String& str) const { return !compare(str) == 0; }
        bool  operator != (const Char* str) const { return !compare(str) == 0; }
        String& operator += (const String& str) { return append(str); }
        inline  String  operator + (const String& str) const;

        String& operator += (const Char* str) { return append(str); }
        String& operator += (const AChar* str) { return append(str); }
        String& operator += (Char c) { append_helper(c, 1); return *this; }
        String& operator += (AChar c) { append_helper(c, 1); return *this; }
        
        inline bool operator < (const String& s) const;
        inline bool operator > (const String& s) const;


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

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

        String& append(size_t n, Char 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;
        }
        String& assign(const String& other);
        String& assign(const String& str, size_t pos, size_t n)
        {
            if (str.validate_range(pos, &n))
            {
                assign_helper(str.data_->data + pos, n);
            }
            return *this;
        }
        String& assign(const Char* str, size_t n)
        {
            assign_helper(str, n);
            return *this;
        }
        String& assign(const Char* str)
        {
            assign_helper(str, length(str));
            return *this;
        }
        String& assign(size_t n, Char c)
        {
            assign_helper(c, n);
            return *this;
        }
        String& assign(const AChar* str, size_t n)
        {
            assign_helper(str, n);
            return *this;
        }
        String& assign(const AChar* str)
        {
            assign_helper(str, length(str));
            return *this;
        }
        String& assign(size_t n, AChar c)
        {
            assign_helper(c, n);
            return *this;
        }

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

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

        String& clear()
        {
            init();
            return *this;
        }

        String& erase(size_t pos = 0, size_t n = (size_t)npos)
        {
            replace_helper(pos, n, (const Char*)0, 0);
            return *this;
        }

        String& replace(size_t pos1, size_t n1, const String& str)
        {
            replace_helper(pos1, n1, str, 0, str.size());
            return *this;
        }

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

        Char  operator[](size_t pos) const
        {
            return pos == size() ? eos() : get_at(pos);
        }

        Char& operator[](size_t pos)
        {
            if (pos < size())
            {
                return *(data_->data + pos);
            }
            else
            {
                return *((Char*)0);
            }
        }

        Char  at(size_t pos) const
        {
            return get_at(pos);
        }

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

        size_t  length() const
        {
            return data_->size;
        }
        size_t  size() const
        {
            return data_->size;
        }
        size_t  max_size() const
        {
            return (size_t)npos - 1;
        }
        bool  empty() const
        {
            return size() == 0;
        }

        void  resize(size_t n, Char c)
        {
            resize_helper(n, c);
        }
        void  resize(size_t n)
        {
            resize(n, eos());
        }
        size_t capacity() const
        {
            return data_->capacity;
        }

        void  reserve(size_t size)
        {
            reserve_helper(size);
        }

        
        size_t  copy(Char* 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 String& str, size_t pos = 0) const
        {
            return find(str.data(), pos, str.size());
        }
        size_t  find(const Char* s, size_t pos, size_t n) const;
        size_t  find(const Char* str, size_t pos = 0) const
        {
            return find(str, pos, length(str));
        }
        size_t  find(Char c, size_t pos = 0) const
        {
            return find(&c, pos, 1);
        }
        size_t  find_first_of(const String& str, size_t pos = 0) const
        {
            return find_first_of(str.data(), pos, str.size());
        }
        size_t  find_first_of(const Char* s, size_t pos, size_t n) const;
        size_t  find_first_of(const Char* str, size_t pos = 0) const
        {
            return find_first_of(str, pos, length(str));
        }
        size_t  find_first_of(Char c, size_t pos = 0) const
        {
            return find_first_of(&c, pos, 1);
        }
        size_t  find_first_not_of(const String& str, size_t pos = 0) const
        {
            return find_first_not_of(str.data(), pos, str.size());
        }
        size_t  find_first_not_of(const Char* s, size_t pos, size_t n) const;
        size_t  find_first_not_of(Char c, size_t pos = 0) const
        {
            return find_first_not_of(&c, pos, 1);
        }
        size_t  find_first_not_of(const Char* str, size_t pos = 0) const
        {
            return find_first_not_of(str, pos, length(str));
        }
        size_t  rfind(const Char* str, size_t pos, size_t n) const;
        size_t  find_last_of(const Char* s, size_t pos, size_t n) const;
        size_t  find_last_not_of(const Char* s, size_t pos, size_t n) const;
        size_t  rfind(const String& str, size_t pos = (size_t)npos) const
        {
            return rfind(str.data(), pos, str.size());
        }
        size_t  rfind(const Char* str, size_t pos = (size_t)npos) const
        {
            return rfind(str, pos, length(str));
        }
        size_t  rfind(Char c, size_t pos = (size_t)npos) const
        {
            return rfind(&c, pos, 1);
        }
        size_t  find_last_of(const String& str, size_t pos = (size_t)npos) const
        {
            return find_last_of(str.data(), pos, str.size());
        }
        size_t  find_last_of(Char c, size_t pos = (size_t)npos) const
        {
            return find_last_of(&c, pos, 1);
        }
        size_t  find_last_of(const Char* str, size_t pos = (size_t)npos) const
        {
            return find_last_of(str, pos, length(str));
        }
        size_t  find_last_not_of(const String& 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 Char& c, size_t pos = (size_t)npos) const
        {
            return find_last_not_of(&c, pos, 1);
        }
        size_t  find_last_not_of(const Char* str, size_t pos = (size_t)npos) const
        {
            return find_last_not_of(str, pos, length(str));
        }
        String  substr(size_t pos = 0, size_t n = (size_t)npos) const;
        int  compare(const String& str) const
        {
            return compare_helper(str, 0, (size_t)npos);
        }
        int  compare(size_t pos, size_t n, const String& str) const
        {
            return compare_helper(str, pos, n);
        }
        int  compare(size_t pos1, size_t n1, const String& str, size_t pos2, size_t n2) const
        {
            String temp(str, pos2, n2);
            return compare_helper(temp, pos1, n1);
        }
        int  compare(const Char* s) const
        {
            return compare_helper(s, 0, length(s));
        }
        int  compare(const AChar* s) const
        {
            return compare_helper(s, 0, length(s));
        }
        int  compare(size_t pos, size_t n1, const Char* str, size_t n2 = (size_t)npos) const;

        int  icompare(const String& str) const
        {
            return icompare_helper(str, 0, (size_t)npos);
        }
        int  icompare(size_t pos, size_t n, const String& str) const
        {
            return icompare_helper(str, pos, n);
        }
        int  icompare(size_t pos1, size_t n1, const String& str, size_t pos2, size_t n2) const
        {
            String temp(str, pos2, n2);
            return icompare_helper(temp, pos1, n1);
        }
        int  icompare(const Char* s) const
        {
            return icompare_helper(s, 0, length(s));
        }
        int  icompare(const AChar* s) const
        {
            return icompare_helper(s, 0, length(s));
        }
        int  icompare(size_t pos, size_t n1, const Char* str, size_t n2 = (size_t)npos) const;

        Int  to_int() const;
        String&  make_upper();
        String&  make_lower();
        bool  match(const String& pattern,
                    String& a0) const;
        bool  match(const String& pattern,
                    String& a0, String& a1) const;
        bool  match(const String& pattern,
                    String& a0, String& a1, String& a2) const;
        bool  match(const String& pattern,
                    String& a0, String& a1, String& a2, String& a3) const;
        bool  match(const String& pattern,
                    String& a0, String& a1, String& a2,
                    String& a3, String& a4) const;
        bool  match(const String& pattern,
                    String& a0, String& a1, String& a2,
                    String& a3, String& a4, String& a5) const;
        bool  match(const String& pattern,
                    String& a0, String& a1, String& a2,
                    String& a3, String& a4, String& a5,
                    String& a6) const;
        bool  match(const String& pattern,
                    String& a0, String& a1, String& a2,
                    String& a3, String& a4, String& a5,
                    String& a6, String& a7) const;
        long  write_xml(OBStream& o) const;
        long  write(CommBuffer& buffer) const;
        long  read_xml(IBStream& i);
        long  read(const CommBuffer& buffer);
        String&  from_acsii(const AChar* s);

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

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

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

        const Char& get_at(size_t pos) const
        {
            //if ( pos >= size_ )
            //    os_throw_out_of_range();
            return *(data_->data + pos);
        }

        void put_at(size_t pos, Char c);

        void assign_helper(const Char* data, size_t n);
        void assign_helper(const AChar* data, size_t n);
        void assign_helper(Char c, size_t n);

        void replace_helper(size_t pos, size_t n1, const Char* s, size_t n2);
        void replace_helper(size_t pos, size_t n1, Char c, size_t n2);
        void replace_helper(size_t pos, size_t n1, const String& str, size_t pos2, size_t n2)
        {
            str.validate_range(pos2, &n2);
            replace_helper(pos, n1, str.data_->data + pos2, n2);
        }

        void append_helper(const String& str, size_t pos, size_t n)
        {
            str.validate_range(pos, &n);
            append_helper(str.data_->data + pos, n);
        }

        void append_helper(const Char* s, size_t n);
        void append_helper(Char c, size_t n);

        void append_helper(const AChar* s, size_t n);
        void append_helper(AChar c, size_t n);

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

        int icompare_helper(const String& str, size_t pos, size_t n) const;
        int icompare_helper(const Char* s, size_t pos, size_t n) const;

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

        Char* allocate(size_t count);
        void reallocate(size_t count);
        void size(size_t n)
        {
            if (n <= data_->capacity)
            {
                data_->size = n;
                data_->data[ data_->size ] = eos();
            }
        }

    private:
        static Char* nil_data();
        void init();
        Char* data()
        {
            return data_->data;
        }

    private:
        RawString* data_;
        PAllocator allocator_;

    };


    inline bool String::operator < (const String& s) const
    {
        return compare(s) < 0;
    }
    inline bool String::operator > (const String& s) const
    {
        return compare(s) > 0;
    }

    inline String  String::operator + (const String& str) const
    {
        String r = *this;
        r.append(str);
        return r;
    }
    int strcmp(const Char* s1, const Char* s2);
    int stricmp(const Char* s1, const Char* s2);
};

CMREXD bool FromUTF8(commore::String& so, const commore::AChar* si);

CMREXD void EncodeToUTF8(const commore::String& source, commore::AString& dest);
CMREXD void EncodeToUTF8(commore::Char ch, commore::AString& dest);
CMREXD void EncodeToUTF8(const commore::Char* source, commore::AString& dest);
CMREXD void DecodeFromUTF8(const commore::AString& source, commore::String& dest);

CMREXD commore::OBStream& operator << (commore::OBStream& o, const commore::String& s);

#endif