String.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: String
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/Buffer.h>
#include <NDEVR/StringStream.h>
#include <NDEVR/StringView.h>
#include <cmath>
#include <utility>
namespace NDEVR
{
    //Specialized Class to help return correct item
    template<class t_type>
    struct FromStringItemReturn
    {
        t_type get(const String& s)
        {
            t_type value;
            StringStream<t_type>::fromString(StringView(s), value);
            return value;
        }
    };
    template<>
    struct FromStringItemReturn<String>
    {
        const String& get(const String& s) { return s; }
    };
    template<>
    struct FromStringItemReturn<StringView>
    {
        StringView get(const String& s) { return StringView(s); }
    };
 
    class String : public Buffer<char, BufferAllocator<char, 0, true, uint04, true>>
    {
    public:
        friend class StringView;
        constexpr String() noexcept 
            : Buffer()
        {}

        constexpr String(const String& string)
            : Buffer(string)
        {}

        constexpr explicit String(const StringView& string)
            : Buffer(string.begin(), string.size())
        {}

        constexpr String(String&& string) noexcept 
            : Buffer(std::move(string))
        {
            //lib_assert(!contains('\0'), "Invalid string");
        }
        
        template<std::size_t N>
        constexpr explicit String(const char (&string)[N])
            : Buffer(string, str_len(string))
        {}

        template<std::size_t N>
        explicit String(const wchar(&string)[N])
        {
            addUTF16AsUTF8(string);
        }

        explicit String(const char* string)
            : Buffer(string, string == nullptr ? 0 : str_len(string))
        {}

        constexpr String(const char* const string, uint04 size)
            : Buffer(string, size)
        {
            //lib_assert(!contains('\0'), "Tried to create string with terminator");
        }

        constexpr String(uint04 size, const char& value)
            : Buffer(size, value)
        {}

        template<class t_type>
        explicit String(const t_type& value);
 

        template<class t_type>
        [[nodiscard]] decltype(auto) getAs() const
        {
            return FromStringItemReturn<t_type>().get(*this);
        }
        template<class t_type>
        void setFrom(const t_type& value)
        {
            clear();
            append(value);
        }
        template<class t_type>
        static TranslatedString DisplayString(const t_type& value);
        NDEVR_BASE_API bool beginsWith(const StringView& s, bool ignore_case = false) const;

        NDEVR_BASE_API bool endsWith(const StringView& s, bool ignore_case = false) const;

        NDEVR_BASE_API bool hasSubString(const StringView& sub_string, bool ignore_case = false, uint04 start_idx = 0) const;

        NDEVR_BASE_API uint04 indexOf(const StringView& sub_string, bool ignore_case = false, uint04 start_index = 0) const;

        NDEVR_BASE_API uint04 indexOf(const String& sub_string, bool ignore_case = false, uint04 start_index = 0) const;

        NDEVR_BASE_API uint04 indexOf(const char& sub_string) const  { return Buffer::indexOf(sub_string); }

        NDEVR_BASE_API uint04 indexOf(const char& sub_string, uint04 start_pos) const { return Buffer::indexOf(sub_string, start_pos); }

        NDEVR_BASE_API uint04 indexOf(const char& sub_string, uint04 start_pos, uint04 size) const { return Buffer::indexOf(sub_string, start_pos, size); }

        NDEVR_BASE_API uint04 indexOf(const char* sub_string, bool ignore_case = false, uint04 start_index = 0) const;

        NDEVR_BASE_API uint04 indexOf(const char* sub_string, bool ignore_case, uint04 start_index, uint04 size) const;

        NDEVR_BASE_API uint04 indexOf(const char* sub_string, char escape_char, bool ignore_case = false, uint04 start_index = 0) const;

        NDEVR_BASE_API uint04 lastIndexOf(const char* sub_string, bool ignore_case = false) const;

        NDEVR_BASE_API uint04 lastIndexOf(const StringView& sub_string, bool ignore_case = false) const;

        NDEVR_BASE_API uint04 lastIndexOf(const char value, bool ignore_case = false) const;

        NDEVR_BASE_API String& replace(const StringView& sub_string, const StringView& replace_sub_string, bool ignore_case = false, uint04 start_index = 0);

        NDEVR_BASE_API String& replace(const StringViewBuffer& sub_string, const StringViewBuffer& replace_sub_string, bool ignore_case = false, uint04 start_index = 0);

        NDEVR_BASE_API String& replace(const StringViewBuffer& sub_string, const StringBuffer& replace_sub_string, bool ignore_case = false, uint04 start_index = 0);

        NDEVR_BASE_API [[nodiscard]] StringViewBuffer split(char delimiter, bool preserve_empty = true) const;
        
 
        NDEVR_BASE_API [[nodiscard]] StringView splitPart(char delimiter, uint04 index) const;
        NDEVR_BASE_API [[nodiscard]] StringViewBuffer split(const Buffer<char>& delimiter, bool preserve_empty = true) const;
        
        NDEVR_BASE_API void splitString(char delimiter, StringViewBuffer& strings, bool preserve_empty = true) const;
        
        NDEVR_BASE_API void splitString(const Buffer<char>& delimiter, StringViewBuffer& strings, bool preserve_empty = true) const;

        constexpr const char* c_str() const
        {
            return Buffer::begin();
        }

        NDEVR_BASE_API bool isSameNoCase(const StringView& s) const;

        NDEVR_BASE_API bool matchesWildcard(const StringView& pattern) const;
        NDEVR_BASE_API String& append(const StringView& string);

        NDEVR_BASE_API String& append(char value)
        {
            add(value);
            return *this;
        }

        template<class t_type>
        String& append(const t_type& value);
        template<size_t t_size>
        inline String& append(const char(&value)[t_size])
        {
            addAll(value);
            return *this;
        }

        inline String& append(const char* value)
        {
            addAll(value);
            return *this;
        }

        template<size_t t_size>
        inline String& append(const wchar(&value)[t_size])
        {
            addUTF16AsUTF8(value);
            return *this;
        }

        inline String& append(const wchar* value)
        {
            addUTF16AsUTF8(value);
            return *this;
        }

        inline String& append(const wchar value)
        {
            addWChar(value);
            return *this;
        }

        constexpr uint08 hash() const
        {
            return StringView::hash(c_str());
        }

        NDEVR_BASE_API uint08 hashUpper() const;
        NDEVR_BASE_API uint08 hashLower() const;
        NDEVR_BASE_API StringView substr(uint04 start) const;
        NDEVR_BASE_API StringView substr(uint04 start, uint04 end) const;
        NDEVR_BASE_API String& trimWhiteSpace();
        NDEVR_BASE_API String& addWhiteSpace(uint04 desired_string_size, uint04 desired_right_alignment_location = 0, char whitespace = ' ');
        NDEVR_BASE_API String& formatNumberString(uint04 decimals);
        NDEVR_BASE_API String& formatNumberString(bool add_comma, uint04 decimals);
        NDEVR_BASE_API String& formatNumberString(bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, char decimal = '.', char comma = ',');
        NDEVR_BASE_API String toTitleString() const;
        NDEVR_BASE_API String& removeNonAlphaNumeric(bool remove_tab = true, bool remove_space = true, bool remove_new_line = true, bool remove_r = true, bool remove_numbers = false);
        NDEVR_BASE_API String& removeNonNumeric();
        NDEVR_BASE_API StringAllocatingView shortenString(uint04 size) const;
        NDEVR_BASE_API String insertNewLines(uint04 max_line_size) const;
        NDEVR_BASE_API String predictNextStringIncrement() const;
        NDEVR_BASE_API StringAllocatingView toUpper() const;
        NDEVR_BASE_API String& makeUpper(uint04 offset = 0);
        NDEVR_BASE_API StringAllocatingView toLower() const;
        NDEVR_BASE_API String& makeLower(uint04 offset = 0);
        NDEVR_BASE_API bool isNumeric() const;
        static NDEVR_BASE_API bool IsNumeric(char value);
        NDEVR_BASE_API uint04 fromHex() const;
        NDEVR_BASE_API void addUTF16AsUTF8(const wchar* unicode);
        NDEVR_BASE_API bool addUTF16CharAsUTF8(const wchar* unicode, uint04& advance);
        void addWChar(const wchar& object);
 
        String& operator=(const String& value)
        {
            Buffer::operator=(value);
            return *this;
        }
 
        String& operator=(String&& value) noexcept
        {
            Buffer::operator=(std::move(value));
            return *this;
        }
        String& operator=(const StringView& value)
        {
            if (value.begin() == begin())
            {
                setSize(value.size());
                return *this;
            }
            if (value.size() > size())
                setSize(value.size());//this is safe because a stringview referenceing us can't be larger than us
            memmove(begin(), value.begin(), sizeof(char) * value.size());
            if (value.size() < size())
                setSize(value.size());//do this after in case referencing us
            return *this;
        }
        String& operator=(const char* value)
        {
            setSize(str_len(value));
            memmove(begin(), value, sizeof(char) * size());
            return *this;
        }
        template<std::size_t N>
        String& operator=(const char (&value)[N])
        {
            setSize(str_len(value));
            memmove(begin(), value, sizeof(char) * size());
            return *this;
        }
        template<std::size_t N>
        String& operator=(const wchar(&value)[N])
        {
            clear();
            addUTF16AsUTF8(value);
            return *this;
        }
        bool operator==(const String& value) const
        {
            if (value.size() != size())
                return false;
            for (uint04 i = 0; i < size(); i++)
            {
                if (value[i] != (*this)[i])
                    return false;
            }
            return true;
        }
        bool operator==(const StringView& value) const
        {
            if (value.size() != size())
                return false;
            for (uint04 i = 0; i < size(); i++)
            {
                if (value[i] != (*this)[i])
                    return false;
            }
            return true;
        }
        bool operator==(const char* const value) const
        {
            for (uint04 i = 0; i < size(); i++)
            {
                if (value[i] != (*this)[i])
                    return false;
            }
            return value[size()] == '\0';//check if strings are same size
        }
        template<size_t t_size>
        bool operator==(const char(&string)[t_size])
        {
            if (t_size <= size())
                return false;
            if (string[size()] != '\0')
                return false;
            return memcmp(string, begin(), sizeof(char) * size()) == 0;
        }
 
        bool operator!=(const char* const value) const
        {
            for (uint04 i = 0; i < size(); i++)
            {
                if (value[i] != (*this)[i])
                    return true;
            }
            return value[size()] != '\0';//check if strings are same size
        }
        template<std::size_t t_size>
        bool operator!=(const char(&string)[t_size])
        {
            if (t_size <= size())
                return true;
            if (string[size()] != '\0')
                return true;
            return memcmp(string, begin(), sizeof(char) * size()) != 0;
        }
        bool operator!=(const String& value) const
        {
            if (value.size() != size())
                return true;
            for (uint04 i = 0; i < size(); i++)
            {
                if (value[i] != (*this)[i])
                    return true;
            }
            return false;//check if strings are same size
        }
        bool operator!=(const StringView& value) const
        {
            if (value.size() != size())
                return true;
            for (uint04 i = 0; i < size(); i++)
            {
                if (value[i] != (*this)[i])
                    return true;
            }
            return false;
        }
 
        NDEVR_BASE_API bool operator<(const String& value) const;
        NDEVR_BASE_API bool operator>(const String& value) const;
        NDEVR_BASE_API bool isLessNoCase(const StringView& other) const;
        NDEVR_BASE_API bool isGreaterNoCase(const StringView& other) const;
        operator StringView() const
        {
            return StringView(*this);
        }
    public:
        NDEVR_BASE_API static String ToAlphaString(uint04 number);
        NDEVR_BASE_API static String UTF16toUTF8(const wchar* unicode, uint04& advance);
        NDEVR_BASE_API static bool IsWhiteSpace(char s);
        NDEVR_BASE_API static String NumberString(fltp08 value, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, char decimal = '.', char comma = ',');
        NDEVR_BASE_API static wchar UTF8toUTF16(const char* utf8, uint04& advance);
        static constexpr Vector<2, char> ToHexVec(uint01 value)
        {
            return Vector<2, char>(BinaryToHexChar(value >> 4), BinaryToHexChar(value & 0x0F));
        }

        static constexpr Vector<2, char> ToHexVec(char value)
        {
            return ToHexVec(rcast<uint01>(value));
        }
        
        
        
        static String ToHex(uint01 value)
        {
            auto vec = ToHexVec(value);
            return String({ vec[0], vec[1], '\0'});
        }

        static String ToHex(char value)
        {
            auto vec = ToHexVec(value);
            return String({ vec[0], vec[1], '\0' });
        }

        template<class t_object>
        static typename std::enable_if<ObjectInfo<t_object>::Integer, String>::type ToHex(t_object value)
        {
            String hex;
            uint04 byte_size = cast<uint04>(sizeof(t_object));
            hex.setSize(2 * byte_size);
            for (uint04 i = 0; i < byte_size; i++)
            {
                auto local_hex = ToHexVec(rcast<uint01>(value % 256));
                hex[2 * (byte_size - i - 1) + 0] = local_hex[0];
                hex[2 * (byte_size - i - 1) + 1] = local_hex[1];
                value /= cast<t_object>(256);
            }
            return hex;
        }

        template<class t_object, class t_allocator>
        static String ToHex(const Buffer<t_object, t_allocator>& values)
        {
            String hex;
            hex.ensureCapacity(values.size() * 2 * sizeof(t_object));
            for (uint04 i = 0; i < values.size(); i++)
            {
                hex += ToHex(values[i]);
            }
            return hex;
        }

        static String ToHex(const StringView& values)
        {
            String hex;
            hex.setSize(values.size() * 2);
            for (uint04 i = 0; i < values.size(); i++)
            {
                auto hex_vec = ToHexVec(values[i]);
                hex[2 * i + 0] = hex_vec[0];
                hex[2 * i + 1] = hex_vec[1];
            }
            return hex;
        }

        template<uint01 t_size, class t_type>
        static String ToHex(const Vector<t_size, t_type>& values)
        {
            String hex;
            hex.ensureCapacity(cast<uint04>(t_size) * 2 * sizeof(t_type));
            for (uint01 i = 0; i < t_size; i++)
            {
                hex += ToHex(values[i]);
            }
            return hex;
        }

        NDEVR_BASE_API static bool AlphaNumericCompare(const StringView& left, const StringView& right);

        static constexpr uint04 str_len(const char* value)
        {
            const char* n_value = value;
            for (; *n_value; ++n_value)
            {
            }
            return cast<uint04>(n_value - value);
        }

        static constexpr uint04 str_len(const wchar* value)
        {
            uint04 count = 0;
            const wchar* n_value = value;
            for (; *n_value; ++n_value)
            {
                if (*n_value < 0x80)
                {
                    count += 1;
                }
                else if (*n_value < 0x800)
                {
                    count += 2;
                }
                else
                {
                    uint04 cp = (*n_value << 16);
                    ++n_value;
                    cp += *n_value;
                    if (cp < 0x10000)
                        count += 3;
                    else
                        count += 4;
                }
            }
            return count;
        }
#if _MSC_VER
#pragma warning( disable : 4307)
#endif
        static constexpr uint08 hash(const char* value)
        {
            return StringView::hash(value);
        }
    private:
        static constexpr char BinaryToHexChar(uint01 value)
        {
            return "0123456789ABCDEF"[value];
        }
        // The preprocessing function for Boyer Moore's bad character heuristic
        static void BadCharHeuristic(const char* str, uint04 size, sint04 badchar[256], bool ignore_case);
        static uint04 Search(const char* txt, const char* pat, uint04 size_m, uint04 size_n, bool ignore_case);
    };
    constexpr StringView::StringView(const String& s)
        : m_start(s.c_str())
        , m_size(s.size())
    {}
    inline String operator+(const String& string_a, const String& string_b)
    {
        String s;
        s.ensureCapacity(string_a.size() + string_b.size());
        s.addAll(string_a);
        s.addAll(string_b);
        return s;
    }
    inline String operator+(const StringView& string_a, const StringView& string_b)
    {
        String s;
        s.ensureCapacity(string_a.size() + string_b.size());
        s.append(string_a);
        s.append(string_b);
        return s;
    }
    inline String operator+(const StringView& string_a, const String& string_b)
    {
        String s;
        s.ensureCapacity(string_a.size() + string_b.size());
        s.append(string_a);
        s.addAll(string_b);
        return s;
    }
    inline String operator+(const String& string_a, const StringView& string_b)
    {
        String s;
        s.ensureCapacity(string_a.size() + string_b.size());
        s.addAll(string_a);
        s.append(string_b);
        return s;
    }
    inline String operator+(String&& v1, const String& v2)
    {
        v1.addAll(v2);
        return std::move(v1);
    }
    inline String operator+(String&& v1, String&& v2)
    {
        v1.addAll(v2);
        return std::move(v1);
    }
 
    inline String operator+(String&& v1, const char*& v2)
    {
        v1.addAll(v2, cast<uint04>(String::str_len(v2)));
        return std::move(v1);
    }
    inline String operator+(const char*& v1, const String& v2)
    {
        String s;
        uint04 size = cast<uint04>(String::str_len(v1));
        s.ensureCapacity(v2.size() + size);
        s.addAll(v1, size);
        s.addAll(v2);
        return s;
    }
    inline String operator+(const char*& v1, const StringView& v2)
    {
        String s;
        uint04 size = String::str_len(v1);
        s.ensureCapacity(v2.size() + size);
        s.addAll(v1, size);
        s.append(v2);
        return s;
    }
    template<size_t t_size>
    inline String operator+(String&& v1, const char(&v2)[t_size])
    {
        v1.addAll(v2, cast<uint04>(String::str_len(v2)));
        return std::move(v1);
    }
 
    template<size_t t_size>
    inline String operator+(const String& v1, const char(&v2)[t_size])
    {
        String combined;
        uint04 length = String::str_len(v2);
        combined.ensureCapacity(v1.size() + length);
        combined.append(v1);
        combined.addAll(v2, length);
        return combined;
    }
    template<size_t t_size>
    inline String operator+(const StringView& v1, const char(&v2)[t_size])
    {
        String combined;
        uint04 length = String::str_len(v2);
        combined.ensureCapacity(v1.size() + length);
        combined.append(v1);
        combined.addAll(v2, length);
        return combined;
    }
    template<size_t t_size>
    inline String operator+(const char(&v1)[t_size], const StringView& v2)
    {
        String combined;
        uint04 length = String::str_len(v1);
        combined.ensureCapacity(v2.size() + length);
        combined.addAll(v1, length);
        combined.append(v2);
        return combined;
    }
    inline String operator+(const String& v1, char v2)
    {
        String s;
        s.ensureCapacity(v1.size() + 1);
        s.addAll(v1);
        s.add(v2);
        return s;
    }
    inline String operator+(const char v1, const String& v2)
    {
        String s;
        s.ensureCapacity(v2.size() + 1);
        s.add(v1);
        s.addAll(v2);
        return s;
    }
    inline String& operator+=(String& string, const wchar* value)
    {
        string.addUTF16AsUTF8(value);
        return string;
    }
    inline String& operator+=(String& string, const String& value)
    {
        string.addAll(value);
        return string;
    }
    inline String& operator+=(String& string, const StringView& value)
    {
        string.append(value);
        return string;
    }
    template<size_t t_size>
    inline String& operator+=(String& v1, const char(&v2)[t_size])
    {
        v1.addAll(v2);
        return v1;
    }
    inline String& operator+=(String& v1, const char* v2)
    {
        v1.addAll(v2);
        return v1;
    }
    inline String& operator+=(String& v1, char v2)
    {
        v1.add(v2);
        return v1;
    }
    template<size_t t_size>
    inline String operator+(const char(&v1)[t_size], const String& v2)
    {
        String s;
        uint04 size = String::str_len(v1);
        s.ensureCapacity(v2.size() + size);
        s.addAll(v1, size);
        s.addAll(v2);
        return s;
    }
    template<size_t t_size>
    inline bool operator==(const char(&v1)[t_size], const String& v2)
    {
        return v2 == v1;
    }
    inline bool operator==(const char*& v1, const String& v2)
    {
        return v2 == v1;
    }
    template<size_t t_size>
    inline String operator+(const char(&v1)[t_size], String&& v2)
    {
        String s;
        uint04 size = String::str_len(v1);
        s.ensureCapacity(v2.size() + size);
        s.addAll((char*)v1, size);
        s.addAll(v2);
        return s;
    }
    template<class t_to>
    constexpr t_to cast(const String& value)
    {
        return static_cast<t_to>(value.getAs<t_to>());
    }
    template<>
    struct ObjectInfo<String, false, true>
    {
        static const uint01 Dimensions = 0;
        static const bool Vector = false;
        static const bool Buffer = true;
        static const bool Primitive = false;
        static const bool Pointer = false;
        static const bool Unsigned = false;
        static const bool Float = false;
        static const bool Integer = false;
        static const bool Number = false;
        static const bool Enum = false;
        static const bool String = true;
        static const bool Color = false;
        static const bool Boolean = false;
        static constexpr ObjectInfo<char, false, false> VectorSub() { return ObjectInfo<char, false, false>(); }
    };
 
    template<> inline const String Constant<String>::Invalid = String();
    template<>
    constexpr bool IsInvalid(const String& value)
    {
        return value.size() == 0;
    }
    template<>
    constexpr bool IsValid(const String& value)
    {
        return value.size() > 0;
    }
    class StringAllocatingView : public StringView
    {
    public:
        friend class String;
        friend class StringAllocation;
        constexpr StringAllocatingView()
        {}
        StringAllocatingView(const StringAllocatingView& other) noexcept
        {
            if (other.m_allocated_string.size() > 0)
                allocate(other);
            else
                reference(other);
        }
        template<size_t N>
        constexpr StringAllocatingView(const char(&string)[N]) noexcept
            : StringView(string, str_len(string))
        {}
        StringAllocatingView(StringAllocatingView&& other) noexcept
            : StringView(other)
        {
            std::swap(other.m_allocated_string, m_allocated_string);
        }
        constexpr StringAllocatingView(String&& other) noexcept
            : StringView(other)
            , m_allocated_string(std::move(other))
        {}
        template<class t_type>
        StringAllocatingView(const t_type& value)
        {
            StringStream<t_type>::toString(value, *this);
        }
        NDEVR_BASE_API StringAllocatingView& replace(const StringView& sub_string, const StringView& replace_sub_string, bool ignore_case = false, uint04 start_index = 0);

        NDEVR_BASE_API StringAllocatingView& replace(const Buffer<StringView>& sub_string, const Buffer<String>& replace_sub_string, bool ignore_case = false, uint04 start_index = 0);
        NDEVR_BASE_API StringAllocatingView& insert(uint04 i, char value);
        void clear()
        {
            m_allocated_string.clear();
            m_start = nullptr;
            m_size = 0;
        }
        constexpr void allocate(const StringView& value)
        {
            m_allocated_string.clear();
            m_allocated_string.addAll(value.begin(), value.size());
            m_start = m_allocated_string.begin();
            m_size = value.size();
        }
        constexpr void allocate(const String& value)
        {
            allocate(StringView(value.begin(), value.size()));
        }
        constexpr void allocate(const StringAllocatingView& value)
        {
            allocate(StringView(value.begin(), value.size()));
        }
        template<size_t N>
        constexpr void allocate(const char(&string)[N]) noexcept
        {
            allocate(StringView(string, str_len(string)));
        }
        template<class t_type>
        void allocate(const t_type& value)
        {
            clear();
            StringStream<t_type>::toString(value, *this);
            allocate();
        }
        inline void allocate()
        {
            if (m_size > 0)
            {
                if (m_allocated_string.size() == 0)
                {
                    m_allocated_string = *this;
                    m_start = m_allocated_string.begin();
                }
                else //clean off end of string for appends
                {
                    uint04 offset = cast<uint04>(m_start - m_allocated_string.begin());
                    m_allocated_string.setSize(m_size - offset);
                }
            }
        }
        inline void allocateWithExtra(uint04 extra_size)
        {
            if (m_allocated_string.size() == 0)
            {
                m_allocated_string.ensureCapacity(extra_size + m_size);
                m_allocated_string.addAll(begin(), m_size);
                m_start = m_allocated_string.begin();
            }
            else //clean off end of string for appends
            {
                uint04 offset = cast<uint04>(m_start - m_allocated_string.begin());
                uint04 new_allocation_size = cast<uint04>(m_size - offset);
                m_allocated_string.ensureCapacity(extra_size + new_allocation_size);
                m_allocated_string.setSize(new_allocation_size);
                m_start = m_allocated_string.begin();
            }
        }
        void ensureNullTerminated()
        {
            StringView::ensureNullTerminated(m_allocated_string);
        }
        StringAllocatingView& operator=(StringAllocatingView&& other) noexcept
        {
            m_start = other.m_start;
            m_size = other.m_size;
            std::swap(other.m_allocated_string, m_allocated_string);
            return *this;
        }
        StringAllocatingView& operator=(const StringAllocatingView& other) noexcept
        {
            if (other.m_allocated_string.size() > 0)
            {
                allocate(other);
            }
            else
            {
                m_start = other.m_start;
                m_size = other.m_size;
            }
            return *this;
        }
        NDEVR_BASE_API void removeElement(char c, uint04 start);
        template<size_t N>
        constexpr void reference(const char(&string)[N]) noexcept
        {
            m_allocated_string.clear();
            m_start = string;
            m_size = str_len(string);
        }
        constexpr void reference(const StringView& value)
        {
            m_allocated_string.clear();
            m_start = value.begin();
            m_size = value.size();
        }
        template<class t_type>
        void append(const t_type& value)
        {
            StringStream<t_type>::toString(value, *this);
        }
        void addSpace(uint04 size)
        {
            m_allocated_string.addSpace<true>(size);
            m_start = m_allocated_string.begin();
            m_size += size;
        }
        void ensureCapacity(uint04 size)
        {
            m_allocated_string.ensureCapacity(size);
            m_start = m_allocated_string.begin();
        }
        NDEVR_BASE_API StringAllocatingView& makeLower(uint04 offset = 0);
        NDEVR_BASE_API StringAllocatingView& makeUpper(uint04 offset = 0);
        void append(const char& value)
        {
            if (m_allocated_string.size() == 0)
                allocateWithExtra(1);
            m_allocated_string.add(value);
            m_start = m_allocated_string.begin();
            ++m_size;
        }
        template<size_t N>
        constexpr void append(const char(&string)[N]) noexcept
        {
            append(StringView(string, str_len(string)));
        }
        constexpr void append(const StringView& value)
        {
            if (value.size() == 0)
                return;
            lib_assert(value.end() < StringView::begin() || value.begin() > StringView::end(), "Cannot append to self" );
            if (m_size > 0 && m_allocated_string.size() == 0)
            {
                allocate();
                m_allocated_string.addAll(value.begin(), value.size());
            }
            else
            {
                lib_assert(value.end() < m_allocated_string.begin() || value.begin() > m_allocated_string.end(), "Cannot append to self" );
                m_allocated_string.addAll(value.begin(), value.size());
            }
            m_start = m_allocated_string.begin();
            m_size += value.size();
        }
        constexpr void append(const String& value)
        {
            append(StringView(value));
        }
        constexpr void append(const StringAllocatingView& value)
        {
            append(StringView(value));
        }
        void referencedAppend(const char& value)
        {
            if (m_size > 0)
            {
                append(value);
            }
            else
            {
                m_start = &value;
                m_size = 1U;
            }
        }
        constexpr void referencedAppend(const StringView& value)
        {
            if (value.size() == 0)
                return;
            if (m_size > 0)
                append(value);
            else
                reference(value);
        }
        constexpr void referencedAppend(const String& value)
        {
            if (value.size() == 0)
                return;
            if (m_size > 0)
                append(value);
            else
                reference(value);
        }
        void referencedAppend(const String&& value) = delete;
        void referencedAppend(char&& value) = delete;
        [[nodiscard]] constexpr char* allocationPtr()
        {
            lib_assert(m_allocated_string.size() > 0, "Bad Allocation");
            return m_allocated_string.begin();
        }
        [[nodiscard]] constexpr char* allocationPtr(uint04 idx_offset)
        {
            lib_assert(m_allocated_string.size() > 0, "Bad Allocation");
            return m_allocated_string.begin(idx_offset);
        }
        void replaceIndexRange(uint04 offset, uint04 replace_size, const char* buffer, uint04 buffer_size)
        {
            allocate();
            uint04 reference_offset = cast<uint04>(m_start - m_allocated_string.begin());
            lib_assert(offset + replace_size <= size(), "invalid replace");
            m_allocated_string.replaceIndexRange(offset + reference_offset, replace_size, buffer, buffer_size);
            m_start = m_allocated_string.begin();
            m_size = m_allocated_string.size();
        }
        template<class t_string_type>
        static StringAllocatingView Reference(const t_string_type& value)
        {
            StringAllocatingView view;
            view.reference(StringView(value));
            return view;
        }
        template<class t_type>
        static StringAllocatingView Allocate(const t_type& value)
        {
            StringAllocatingView view;
            view.allocate(value);
            return view;
        }
    protected:
        String m_allocated_string;
    };
    template<>
    struct ObjectInfo<StringAllocatingView, false, false>
    {
        static const uint01 Dimensions = 0;
        static const bool Vector = false;
        static const bool Buffer = true;
        static const bool Primitive = false;
        static const bool Pointer = false;
        static const bool Unsigned = false;
        static const bool Float = false;
        static const bool Integer = false;
        static const bool Number = false;
        static const bool Enum = false;
        static const bool String = true;
        static const bool Color = false;
        static const bool Boolean = false;
        static constexpr ObjectInfo<char, false, false> VectorSub() { return ObjectInfo<char, false, false>(); }
    };
    template<class t_type>
    String::String(const t_type& value)
    {
        StringAllocatingView view;
        StringStream<t_type>::toString(value, view);
        if (view.m_allocated_string.size() > 0)
            *this = std::move(view.m_allocated_string);
        else if (view.size() > 0)
            addAll(view.begin(), view.size());
    }
    class StringAllocation final
    {
    public:
        explicit StringAllocation(StringAllocatingView& s) noexcept
            : m_reference(s)
        {
            if (s.m_allocated_string.size() > 0)
            {
                m_start_offset = cast<uint04>(s.m_start - s.m_allocated_string.begin());
            }
            else
            {
                m_start_offset = 0;
                m_reference.allocate();
            }
            //lib_assert(m_reference.m_allocated_string.size() == s.size(), "Can only be used with complete allocation");
            
        }
 
        ~StringAllocation() noexcept
        {
            m_reference.m_start = m_start_offset + m_reference.m_allocated_string.begin();
            m_reference.m_size = cast<uint04>(m_reference.m_allocated_string.size() - m_start_offset);
        }
 
        operator String&() noexcept { return m_reference.m_allocated_string; }
        operator const String&() const noexcept { return m_reference.m_allocated_string; }
        String& operator*() noexcept { return m_reference.m_allocated_string; }
        const String& operator*() const noexcept { return m_reference.m_allocated_string; }
        StringAllocation(const StringAllocation&) = delete;
        StringAllocation& operator=(const StringAllocation&) = delete;
        StringAllocation(StringAllocation&&) = delete;
        StringAllocation& operator=(StringAllocation&&) = delete;
        String* operator->() noexcept { return &m_reference.m_allocated_string; }
        const String* operator->() const noexcept { return &m_reference.m_allocated_string; }
    private:
        StringAllocatingView& m_reference;
        uint04 m_start_offset = 0;
    };
    class StringWrappedAllocation : public StringAllocatingView
    {
    public:
        StringWrappedAllocation(String& s)
            : reference(s)
        {
            std::swap(m_allocated_string, reference);
        }
        ~StringWrappedAllocation()
        {
            if (m_allocated_string.size() > 0)
                reference = std::move(m_allocated_string);
            else if (size() > 0)
                reference.addAll(begin(), size());
        }
        String& reference;
    };
    template<class t_type>
    String& String::append(const t_type& value)
    {
        StringAllocatingView view;
        if(size() > 0)
        {
            std::swap(view.m_allocated_string, *this);
            view.m_start = view.m_allocated_string.begin();
            view.m_size = view.m_allocated_string.size();
        }
        StringStream<t_type>::toString(value, view);
        if (view.m_allocated_string.size() > 0)
            *this = std::move(view.m_allocated_string);
        else if (view.size() > 0)
            addAll(view.begin(), view.size());
        return *this;
    }
};
 
 
namespace std//Define things to allow use within std libs
{
    template<>
    struct equal_to<NDEVR::String>
    {
        using is_transparent = std::true_type;
        bool operator()(const String& a, const StringView& b) const { return a == b; }
        bool operator()(const StringView& a, const String& b) const { return a == b; }
        bool operator()(const String& a, const String& b) const { return a == b; }
        bool operator()(const String& a, const char* b) const { return a == b; }
        bool operator()(const char* a, const String& b) const { return a == b; }
        template<std::size_t N>
        bool operator()(const String& a, const char(&b)[N]) const { return a == b; }
        template<std::size_t N>
        bool operator()(const char(&a)[N], const String& b) const { return a == b; }
    };
    template<>
    struct equal_to<StringAllocatingView>
    {
        using is_transparent = std::true_type;
        bool operator()(const String& a, const StringView& b) const { return a == b; }
        bool operator()(const StringView& a, const String& b) const { return a == b; }
        bool operator()(const StringAllocatingView& a, const String& b) const { return a == b; }
        bool operator()(const String& a, const StringAllocatingView& b) const { return a == b; }
        bool operator()(const StringAllocatingView& a, const StringView& b) const { return a == b; }
        bool operator()(const StringView& a, const StringAllocatingView& b) const { return a == b; }
        bool operator()(const StringAllocatingView& a, const StringAllocatingView& b) const { return a == b; }
        bool operator()(const String& a, const String& b) const { return a == b; }
        bool operator()(const StringView& a, const StringView& b) const { return a == b; }
        bool operator()(const String& a, const char* b) const { return a == b; }
        bool operator()(const char* a, const String& b) const { return a == b; }
        template<std::size_t N>
        bool operator()(const String& a, const char(&b)[N]) const { return a == b; }
        template<std::size_t N>
        bool operator()(const char(&a)[N], const String& b) const { return a == b; }
    };
    template <>
    struct hash<String>
    {
        using is_transparent = std::true_type;
        size_t operator()(const String& s) const noexcept
        {
            return static_cast<size_t>(s.hash());
        }
        constexpr size_t operator()(const StringView& s) const noexcept
        {
            return static_cast<size_t>(s.hash());
        }
        constexpr size_t operator()(const char* s) const noexcept
        {
            return static_cast<size_t>(String::hash(s));
        }
        template<size_t N>
        constexpr size_t operator()(const char(&s)[N]) const noexcept
        {
            return static_cast<size_t>(String::hash(s));
        }
    };
    template <>
    struct hash<StringAllocatingView>
    {
        using is_transparent = std::true_type;
        size_t operator()(const String& s) const noexcept
        {
            return static_cast<size_t>(s.hash());
        }
        constexpr size_t operator()(const StringView& s) const noexcept
        {
            return static_cast<size_t>(s.hash());
        }
        constexpr size_t operator()(const StringAllocatingView& s) const noexcept
        {
            return static_cast<size_t>(s.hash());
        }
        constexpr size_t operator()(const char* s) const noexcept
        {
            return static_cast<size_t>(String::hash(s));
        }
        template<size_t N>
        constexpr size_t operator()(const char(&s)[N]) const noexcept
        {
            return static_cast<size_t>(String::hash(s));
        }
    };
    NDEVR_BASE_API istream& operator>>(istream& in, String& string);
    NDEVR_BASE_API ostream& operator<<(ostream& in, const StringView& string);
    NDEVR_BASE_API ostream& operator<<(ostream& in, const String& string);
};