WString.h

#pragma once
// ===========================================================================
// Copyright (c) 2015-2024 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
#include <ToolchefsSTL/Globals.h>
#include <ToolchefsSTL/Allocators/Allocator.h>
#include <stdint.h>
 
 
namespace ToolchefsSTL
{
 
    class TOOLCHEFSSTL_EXPORT WString
    {
    public:
 
        template <class Iter>
        struct ReverseIterator
        {
            ReverseIterator(Iter* ptr) : m_ptr(ptr) {}
            ~ReverseIterator() = default;
            Iter* operator +(size_t value) const { return m_ptr - value; }
            Iter* operator -(size_t value) const { return m_ptr + value; }
            Iter* operator ++() const { return --m_ptr; }
            Iter* operator --() const { return ++m_ptr; }
            bool operator ==(const ReverseIterator& rhs) const { return m_ptr == rhs.m_ptr; }
            bool operator !=(const ReverseIterator& rhs) const { return m_ptr != rhs.m_ptr; }
            Iter operator *() const { return *m_ptr; }
            Iter* operator->() const { return m_ptr; }
            Iter* m_ptr;
        };
 
        typedef wchar_t* iterator;
        typedef const wchar_t* const_iterator;
        typedef ReverseIterator<wchar_t> reverse_iterator;
        typedef ReverseIterator<const wchar_t> const_reverse_iterator;
        typedef uint32_t size_type;
 
        static constexpr const size_type DataSize{ 16 };
        static constexpr const size_type MaxLength{ DataSize - 1 };
        static constexpr size_type npos{ static_cast<size_type>(-1) };
 
        bool is_internal() const noexcept { return m_capacity <= DataSize; }
 
        explicit WString(Allocator* allocator = defaultAllocator()) noexcept;
 
        WString(const wchar_t* value, Allocator* allocator = defaultAllocator()) noexcept;
 
        WString(const WString& rhs, Allocator* allocator = defaultAllocator()) noexcept;
 
        WString(WString&& rhs) noexcept;
 
        WString& operator=(const WString& rhs) noexcept;
 
        WString& operator=(const wchar_t* rhs) noexcept;
 
        WString& operator=(WString&& rhs) noexcept;
 
        ~WString();
 
        inline size_type size() const noexcept { return m_length; }
 
        inline size_type length() const noexcept { return m_length; }
 
        inline size_type capacity() const noexcept { return m_capacity; }
 
        void reserve(size_type max_length) noexcept;
 
        void resize(size_type new_length) noexcept;
 
        void resize(size_type new_length, wchar_t value) noexcept;
 
        void clear();
 
        bool empty() const noexcept;
 
 
        iterator begin() noexcept;
        iterator end() noexcept;
        const_iterator cbegin() const noexcept;
        const_iterator cend() const noexcept;
 
        reverse_iterator rbegin() noexcept;
        reverse_iterator rend() noexcept;
        const_reverse_iterator crbegin() const noexcept;
        const_reverse_iterator crend() const noexcept;
 
        wchar_t& back() noexcept;
        const wchar_t& back() const noexcept;
 
        wchar_t& front() noexcept;
        const wchar_t& front() const noexcept;
 
        wchar_t& operator[](const size_type pos) noexcept;
 
        const wchar_t& operator[](const size_type pos) const noexcept;
 
        const wchar_t* c_str() const noexcept;
 
        bool operator==(const WString& rhs) const noexcept;
        bool operator!=(const WString& rhs) const noexcept;
 
        bool operator<(const WString& rhs) const noexcept;
        bool operator<=(const WString& rhs) const noexcept;
 
        bool operator>(const WString& rhs) const noexcept;
        bool operator>=(const WString& rhs) const noexcept;
 
        WString& operator+=(const WString& rhs) noexcept;
        WString& operator+=(const wchar_t* cstr) noexcept;
        WString& operator+=(const wchar_t chr) noexcept;
        WString& operator+=(int num) noexcept;
 
        WString operator+(const WString& rhs) const noexcept;
        WString operator+(const wchar_t* cstr) const noexcept;
        WString operator+(const wchar_t chr) const noexcept;
 
        size_type find(const WString& str, size_type pos = 0) const noexcept;
        size_type find(const wchar_t* s, size_type pos = 0) const noexcept;
        size_type find(const wchar_t s, size_type pos = 0) const noexcept;
 
        size_type rfind(const WString& str, size_type pos = npos) const noexcept;
        size_type rfind(const wchar_t* s, size_type pos = npos) const noexcept;
        size_type rfind(const wchar_t s, size_type pos = npos) const noexcept;
 
        WString substr(size_type pos = 0, size_type len = npos) const noexcept;
 
        WString replace(const WString& src, const WString& dest) const noexcept;
 
        int compare(const WString& str) const  noexcept;
        int compare(const wchar_t* s) const  noexcept;
 
        bool endswith(const WString& ending) const noexcept;
        bool startswith(const WString& prefix)const noexcept;
 
        size_type count(const WString& substr, size_type start = 0, size_type end = npos) const noexcept;
 
        WString capitalize() const noexcept;
        WString upper() const noexcept;
        WString lower() const noexcept;
        WString swapcase() const noexcept;
        WString zfill(size_type width) const noexcept;
 
        bool isalnum() const noexcept;
 
        bool isalpha() const noexcept;
 
        bool isdigit() const noexcept;
 
        bool islower() const noexcept;
 
        bool isspace() const noexcept;
 
        bool istitle() const noexcept;
 
        bool isupper() const noexcept;
 
 
        static WString fromInt(int num) noexcept;
 
        static WString fromFloat(float num) noexcept;
 
        static WString format(const wchar_t* format, ...);
 
        int toInt() const;
 
        double toDouble() const;
 
    private:
 
        void convert_to_external(const size_type new_capacity);
 
        void convert_to_internal(const size_type new_length);
 
        void clear_buffer();
 
        wchar_t* alloc_mem(size_type num_char) const noexcept;
 
        void free_mem(wchar_t* ptr) const noexcept;
 
    private:
 
        union
        {
            wchar_t internal[DataSize];
            wchar_t* external;
        } m_data;
 
        size_type m_length;
        size_type m_capacity;
        Allocator* m_allocator;
    };
 
    inline WString operator+(const wchar_t* cstr, const WString& str) { return WString(cstr) + str; }
}