Api-String.h

/* Copyright (C) 2008 Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_API_STRING_H
#define PT_API_STRING_H
 
#include <Pt/Api.h>
#include <Pt/Types.h>
#include <Pt/Locale.h>
#include <string>
#include <iterator>
#include <stdexcept>
#include <cstring>
#include <cctype>
#include <cstddef>
 
namespace Pt {
 
//
// Note copy from Pt/String.h and replace
// String -> String
// basic_string<Char>     -> String
// basic_string           -> String
//

class String
{
    public:
        typedef Pt::Char value_type;
        typedef std::size_t size_type;
        typedef char_traits< Pt::Char > traits_type;
        typedef std::allocator<Pt::Char> allocator_type;
        typedef allocator_type::difference_type difference_type;
        typedef allocator_type::reference reference;
        typedef allocator_type::const_reference const_reference;
        typedef allocator_type::pointer pointer;
        typedef allocator_type::const_pointer const_pointer;
        typedef value_type* iterator;
        typedef const value_type* const_iterator;
 
#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
        typedef std::reverse_iterator<const_iterator,
                                      random_access_iterator_tag, value_type>
                                      const_reverse_iterator;
 
        typedef std::reverse_iterator<iterator,
                                      random_access_iterator_tag, value_type>
                                      reverse_iterator;
#else
        typedef std::reverse_iterator<iterator> reverse_iterator;
        typedef const std::reverse_iterator<const_iterator> const_reverse_iterator;
#endif
 
        static const size_type npos = static_cast<size_type>(-1);
 
    public:
        explicit String( const allocator_type& a = allocator_type());

        String(const Pt::Char* str, const allocator_type& a = allocator_type());

        String(const Pt::Char* str, size_type n, const allocator_type& a = allocator_type());

        String(const wchar_t* str, const allocator_type& a = allocator_type());

        String(const wchar_t* str, size_type n, const allocator_type& a = allocator_type());

        String(const char* str, const allocator_type& a = allocator_type());

        String(const char* str, size_type n, const allocator_type& a = allocator_type());

        String(size_type n, Pt::Char c, const allocator_type& a = allocator_type());

        String(const String& str);

        String(const String& str, const allocator_type& a);

        String(const String& str, size_type pos, size_type n = npos, const allocator_type& a = allocator_type());

        String(const Pt::Char* begin, const Pt::Char* end, const allocator_type& a = allocator_type());
 
        template <typename InputIterator>
        String(InputIterator begin, InputIterator end, const allocator_type& a = allocator_type());

        ~String();
 
    public:
        iterator begin()
        { return privdata_rw(); }

        iterator end()
        { return privdata_rw() + length(); }

        const_iterator begin() const
        { return privdata_ro(); }

        const_iterator end() const
        { return privdata_ro() + length(); }

        reverse_iterator rbegin()
        { return reverse_iterator( this->end() ); }

        reverse_iterator rend()
        { return reverse_iterator( this->begin() ); }

        const_reverse_iterator rbegin() const
        { return const_reverse_iterator( this->end() ); }

        const_reverse_iterator rend()   const
        { return const_reverse_iterator( this->begin() ); }

        reference operator[](size_type n)
        { return privdata_rw()[n]; }

        const_reference operator[](size_type n) const
        { return privdata_ro()[n]; }

        reference at(size_type n)
        {
            if( n >= size() )
                throw out_of_range("at");
 
            return privdata_rw()[n];
        }

        const_reference at(size_type n) const
        {
            if( n >= size() )
                throw out_of_range("at");
 
            return privdata_ro()[n];
        }
 
    public:
        void push_back(Pt::Char ch)
        { (*this) += ch; }

        void resize( std::size_t n, Pt::Char ch = value_type() );

        void reserve(std::size_t n = 0);

        void swap(String& str);

        allocator_type get_allocator() const
        { return _d; }

        size_type copy(Pt::Char* a, size_type n, size_type pos = 0) const;

        String substr(size_type pos = 0, size_type n = npos) const
        { return String(*this, pos, n); }
 
    public:
        size_type length() const
        { return isShortString() ? shortStringLength() : longStringLength(); }

        size_type size() const
        { return length(); }

        bool empty() const
        { return length() == 0; }

        size_type max_size() const
        { return ( size_type(-1) / sizeof(Pt::Char) ) - 1; }

        size_type capacity() const
        { return isShortString() ? shortStringCapacity() : longStringCapacity(); }

        const Pt::Char* data() const
        { return privdata_ro(); }

        const Pt::Char* c_str() const
        { return privdata_ro(); }

        String& assign(const String& str);

        String& assign(const String& str, size_type pos, size_type n);

        String& assign(const wchar_t* str);

        String& assign(const wchar_t* str, size_type n);

        String& assign(const Pt::Char* str);

        String& assign(const Pt::Char* str, size_type length);

        String& assign(const char* str);

        String& assign(const char* str, size_type length);

        String& assign(size_type n, Pt::Char c);
 
        template <typename InputIterator>
        String& assign(InputIterator begin, InputIterator end);

        String& append(const Pt::Char* str);

        String& append(const Pt::Char* str, size_type n);

        String& append(size_type n, Pt::Char ch);

        String& append(const String& str);

        String& append(const String& str, size_type pos, size_type n);
 
        template <typename InputIterator>
        String& append(InputIterator begin, InputIterator end);

        String& append(const Pt::Char* begin, const Pt::Char* end);

        String& insert(size_type pos, const Pt::Char* str);

        String& insert(size_type pos, const Pt::Char* str, size_type n);

        String& insert(size_type pos, size_type n, Pt::Char ch);

        String& insert(size_type pos, const String& str);

        String& insert(size_type pos, const String& str, size_type pos2, size_type n);

        String& insert(iterator p, Pt::Char ch);

        String& insert(iterator p, size_type n, Pt::Char ch);
 
        // unimplemented
        //template <typename InputIterator>
        //String& insert(iterator p, InputIterator first, InputIterator last);

        void clear()
        { setLength(0); }

        String& erase(size_type pos = 0, size_type n = npos);

        iterator erase(iterator pos);

        iterator erase(iterator first, iterator last);

        String& replace(size_type pos, size_type n, const Pt::Char* str);

        String& replace(size_type pos, size_type n, const Pt::Char* str, size_type n2);

        String& replace(size_type pos, size_type n, size_type n2, Pt::Char ch);

        String& replace(size_type pos, size_type n, const String& str);

        String& replace(size_type pos, size_type n, const String& str, size_type pos2, size_type n2);

        String& replace(iterator i1, iterator i2, const Pt::Char* str);

        String& replace(iterator i1, iterator i2, const Pt::Char* str, size_type n);

        String& replace(iterator i1, iterator i2, size_type n, Pt::Char ch);

        String& replace(iterator i1, iterator i2, const String& str);

        int compare(const String& str) const;

        int compare(const Pt::Char* str) const;

        int compare(const Pt::Char* str, size_type n) const;

        int compare(const wchar_t* str) const;

        int compare(const wchar_t* str, size_type n) const;

        int compare(const char* str) const;

        int compare(const char* str, size_type n) const;

        int compare(size_type pos, size_type n, const String& str) const;

        int compare(size_type pos, size_type n, const String& str, size_type pos2, size_type n2) const;

        int compare(size_type pos, size_type n, const Pt::Char* str) const;

        int compare(size_type pos, size_type n, const Pt::Char* str, size_type n2) const;

        size_type find(const String& str, size_type pos = 0) const;

        size_type find(const Pt::Char* str, size_type pos, size_type n) const;

        size_type find(const Pt::Char* str, size_type pos = 0) const;

        size_type find(Pt::Char ch, size_type pos = 0) const;

        size_type rfind(const String& str, size_type pos = npos) const;

        size_type rfind(const Pt::Char* str, size_type pos, size_type n) const;

        size_type rfind(const Pt::Char* str, size_type pos = npos) const;

        size_type rfind(Pt::Char ch, size_type pos = npos) const;

        size_type find_first_of(const String& str, size_type pos = 0) const
        { return this->find_first_of( str.data(), pos, str.size() ); }

        size_type find_first_of(const Pt::Char* s, size_type pos, size_type n) const;

        size_type find_first_of(const Pt::Char* str, size_type pos = 0) const
        { return this->find_first_of( str, pos, traits_type::length(str) ); }

        size_type find_first_of(const Pt::Char ch, size_type pos = 0) const
        { return this->find(ch, pos); }

        size_type find_last_of(const String& str, size_type pos = npos) const
        { return this->find_last_of( str.data(), pos, str.size() ); }

        size_type find_last_of(const Pt::Char* s, size_type pos, size_type n) const;

        size_type find_last_of(const Pt::Char* str, size_type pos = npos) const
        { return this->find_last_of( str, pos, traits_type::length(str) ); }

        size_type find_last_of(const Pt::Char ch, size_type pos = npos) const
        { return this->rfind(ch, pos); }

        size_type find_first_not_of(const String& str, size_type pos = 0) const
        { return this->find_first_not_of( str.data(), pos, str.size() ); }

        size_type find_first_not_of(const Pt::Char* s, size_type pos, size_type n) const;

        size_type find_first_not_of(const Pt::Char* str, size_type pos = 0) const
        { return this->find_first_not_of( str, pos, traits_type::length(str) ); }

        size_type find_first_not_of(const Pt::Char ch, size_type pos = 0) const;

        size_type find_last_not_of(const String& str, size_type pos = npos) const
        { return this->find_last_not_of( str.data(), pos, str.size() ); }

        size_type find_last_not_of(const Pt::Char* tok, size_type pos, size_type n) const;

        size_type find_last_not_of(const Pt::Char* str, size_type pos = npos) const
        { return this->find_last_not_of( str, pos, traits_type::length(str) ); }

        size_type find_last_not_of(Pt::Char ch, size_type pos = npos) const;
 
    public:
        std::string narrow(char dfault = '?') const;

        static String widen(const char* str);

        static String widen(const std::string& str);

        template <typename OutIterT>
        OutIterT toUtf16(OutIterT to) const;

        template <typename InIterT>
        static String fromUtf16(InIterT from, InIterT fromEnd);
 
    public:
        String& operator=(const String& str)
        { return this->assign(str); }

        String& operator=(const wchar_t* str)
        { return this->assign(str); }

        String& operator=(const char* str)
        { return this->assign(str); }

        String& operator=(const Pt::Char* str)
        { return this->assign(str); }

        String& operator=(Pt::Char ch)
        {
            // no privreserve(1), short string capacity is large enough
 
            Pt::Char* p = privdata_rw();
            p[0] = ch;
            setLength(1);
            return *this;
        }

        String& operator+=(const String& str)
        { return this->append(str); }

        String& operator+=(const Pt::Char* str)
        { return this->append(str); }

        String& operator+=(Pt::Char c);
 
    private:
        struct Ptr
        {
            Pt::Char* _begin;
            Pt::Char* _end;
            Pt::Char* _capacity;
        };
 
        // minimum possible short string character count
        static const unsigned _minN = (sizeof(Ptr) / sizeof(Pt::Char)) + 1;
 
        // short string character count
        static const unsigned _nN = _minN < 8 ? 8 : _minN;
 
        // short string raw storage size in bytes
        static const unsigned _nS = _nN * sizeof(Pt::Char);
 
        struct Data : public allocator_type
        {
            Data(const allocator_type& a)
            : allocator_type(a)
            {
                Pt::Char* str = reinterpret_cast<Pt::Char*>(&_u._s[0]);
                *str = 0;
 
                _u._s[_nS - 1] = _nN - 1;
            }
 
            union
            {
                Ptr _p;
                unsigned char _s[_nS];
            } _u;
        } _d;
 
    private:
        const Pt::Char* privdata_ro() const
        { return isShortString() ? shortStringData() : longStringData(); }
 
        Pt::Char* privdata_rw()
        { return isShortString() ? shortStringData() : longStringData(); }
 
        void privreserve(std::size_t n);
 
        bool isShortString() const
        { return shortStringMagic() != 0xff; }
 
        void markLongString()
        { shortStringMagic() = 0xff; }
 
        const Pt::Char* shortStringData() const
        { return reinterpret_cast<const Pt::Char*>(&_d._u._s[0]); }
 
        Pt::Char* shortStringData()
        { return reinterpret_cast<Pt::Char*>(&_d._u._s[0]); }
 
        unsigned char shortStringMagic() const
        { return _d._u._s[_nS - 1]; }
 
        unsigned char& shortStringMagic()
        { return _d._u._s[_nS - 1]; }
 
        size_type shortStringLength() const
        { return _nN - 1 - shortStringMagic(); }
 
        size_type shortStringCapacity() const
        { return _nN - 1; }
 
        void setShortStringLength(size_type n)
        {
            shortStringData()[n] = Pt::Char(0);
            shortStringMagic() = static_cast<unsigned char>(_nN - n - 1);
        }
 
        void shortStringAssign(const Pt::Char* str, size_type n)
        {
            traits_type::copy(shortStringData(), str, n);
            shortStringData()[n] = Pt::Char(0);
            shortStringMagic() = static_cast<unsigned char>(_nN - n - 1);
        }
        void shortStringAssign(const wchar_t* str, size_type n)
        {
            for (size_type nn = 0; nn < n; ++nn)
                shortStringData()[nn] = str[nn];
            shortStringData()[n] = Pt::Char(0);
            shortStringMagic() = static_cast<unsigned char>(_nN - n - 1);
        }
 
        const Pt::Char* longStringData() const
        { return _d._u._p._begin; }
 
        Pt::Char* longStringData()
        { return _d._u._p._begin; }
 
        size_type longStringLength() const
        { return _d._u._p._end - _d._u._p._begin; }
 
        size_type longStringCapacity() const
        { return _d._u._p._capacity - _d._u._p._begin; }
 
        void setLength(size_type n)
        {
            if (isShortString())
                setShortStringLength(n);
            else
            {
                _d._u._p._end = _d._u._p._begin + n;
                _d._u._p._begin[n] = 0;
            }
        }
};

inline void swap(String& a, String& b)
{ a.swap(b); }
 
// operator +

inline String operator+(const String& a, const String& b)
{ String temp; temp += a; temp += b; return temp; }

inline String operator+(const String& a, const Pt::Char* b)
{ String temp; temp += a; temp += b; return temp; }

inline String operator+(const Pt::Char* a, const String& b)
{ String temp; temp += a; temp += b; return temp; }

inline String operator+(const String& a, Pt::Char b)
{ String temp; temp += a; temp += b; return temp; }

inline String operator+(Pt::Char a, const String& b)
{ String temp; temp += a; temp += b; return temp; }
 
// operator ==

inline bool operator==(const String& a, const String& b)
{ return a.compare(b) == 0; }

inline bool operator==(const Pt::Char* a, const String& b)
{ return b.compare(a) == 0; }

inline bool operator==(const String& a, const Pt::Char* b)
{ return a.compare(b) == 0; }

inline bool operator==(const String& a, const wchar_t* b)
{ return a.compare(b) == 0; }

inline bool operator==(const wchar_t* b, const String& a)
{ return a.compare(b) == 0; }

inline bool operator==(const String& a, const char* b)
{ return a.compare(b) == 0; }

inline bool operator==(const char* b, const String& a)
{ return a.compare(b) == 0; }
 
// operator !=

inline bool operator!=(const String& a, const String& b)
{ return a.compare(b) != 0; }

inline bool operator!=(const Pt::Char* a, const String& b)
{ return b.compare(a) != 0; }

inline bool operator!=(const String& a, const Pt::Char* b)
{ return a.compare(b) != 0; }

inline bool operator!=(const String& a, const wchar_t* b)
{ return a.compare(b) != 0; }

inline bool operator!=(const wchar_t* b, const String& a)
{ return a.compare(b) != 0; }

inline bool operator!=(const String& a, const char* b)
{ return a.compare(b) != 0; }

inline bool operator!=(const char* b, const String& a)
{ return a.compare(b) != 0; }
 
// operator <

inline bool operator<(const String& a, const String& b)
{ return a.compare(b) < 0; }

inline bool operator<(const Pt::Char* a, const String& b)
{ return b.compare(a) > 0; }

inline bool operator<(const String& a, const Pt::Char* b)
{ return a.compare(b) < 0; }

inline bool operator<(const String& a, const wchar_t* b)
{ return a.compare(b) < 0; }

inline bool operator<(const wchar_t* b, const String& a)
{ return a.compare(b) > 0; }

inline bool operator<(const String& a, const char* b)
{ return a.compare(b) < 0; }

inline bool operator<(const char* b, const String& a)
{ return a.compare(b) > 0; }
 
// operator <=

inline bool operator<=(const String& a, const String& b)
{ return a.compare(b) <= 0; }

inline bool operator<=(const Pt::Char* a, const String& b)
{ return b.compare(a) >= 0; }

inline bool operator<=(const String& a, const Pt::Char* b)
{ return a.compare(b) <= 0; }

inline bool operator<=(const String& a, const wchar_t* b)
{ return a.compare(b) <= 0; }

inline bool operator<=(const wchar_t* b, const String& a)
{ return a.compare(b) >= 0; }

inline bool operator<=(const String& a, const char* b)
{ return a.compare(b) <= 0; }

inline bool operator<=(const char* b, const String& a)
{ return a.compare(b) >= 0; }
 
// operator >

inline bool operator>(const String& a, const String& b)
{ return a.compare(b) > 0; }

inline bool operator>(const Pt::Char* a, const String& b)
{ return b.compare(a) < 0; }

inline bool operator>(const String& a, const Pt::Char* b)
{ return a.compare(b) > 0; }

inline bool operator>(const String& a, const wchar_t* b)
{ return a.compare(b) > 0; }

inline bool operator>(const wchar_t* b, const String& a)
{ return a.compare(b) < 0; }

inline bool operator>(const String& a, const char* b)
{ return a.compare(b) > 0; }

inline bool operator>(const char* b, const String& a)
{ return a.compare(b) < 0; }
 
// operator >=

inline bool operator>=(const String& a, const String& b)
{ return a.compare(b) >= 0; }

inline bool operator>=(const Pt::Char* a, const String& b)
{ return b.compare(a) <= 0; }

inline bool operator>=(const String& a, const Pt::Char* b)
{ return a.compare(b) >= 0; }

inline bool operator>=(const String& a, const wchar_t* b)
{ return a.compare(b) >= 0; }

inline bool operator>=(const wchar_t* b, const String& a)
{ return a.compare(b) <= 0; }

inline bool operator>=(const String& a, const char* b)
{ return a.compare(b) >= 0; }

inline bool operator>=(const char* b, const String& a)
{ return a.compare(b) <= 0; }

PT_API ostream& operator<< (ostream& out, const String& str);
 
} // namespace Pt
 
 
#endif