StringView.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/ObjectInfo.h>
#include <NDEVR/StringStream.h>
namespace NDEVR
{
    class String;
    class StringAllocatingView;
    typedef AlocatingAlignedBuffer<String, sizeof(char*) == 4 ? 8 : 16> StringBuffer;
    class StringView
    {
    public:
        friend class UTF8Iterator;
        constexpr StringView()
        {}

        constexpr StringView(StringView&& other) noexcept
            : m_start(other.m_start)
            , m_size(other.m_size)
        {}

        constexpr StringView(const StringView& other) noexcept
            : m_start(other.m_start)
            , m_size(other.m_size)
        {}

        template<std::size_t N>
        constexpr StringView(const char(&string)[N])
            : StringView(string, str_len(string))
        {}

        constexpr StringView(const char* string)
            : StringView(string, string == nullptr ? 0 : str_len(string))
        {
        }

        constexpr StringView(const char* const string, uint04 size)
            : m_start(string)
            , m_size(size)
        {
            //lib_assert(!contains('\0'), "Bad string");
        }

        explicit StringView(String&& s) = delete;
        explicit NDEVR_BASE_API constexpr StringView(const String& s);
        template <class t_type>
        [[nodiscard]] t_type getAs() const
        {
            t_type value;
            StringStream<t_type>::fromString(*this, value);
            return 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 initial_index = 0) const;
 

        NDEVR_BASE_API uint04 indexOf(const StringView& sub_string, bool ignore_case = false, uint04 start_index = 0) const;
        template<size_t t_size>
        inline uint04 indexOf(const char(&value)[t_size], bool ignore_case, uint04 start_index = 0) const
        {
            StringView view(value, StringView::str_len(value));
            return indexOf(view, ignore_case, start_index);
        }

        NDEVR_BASE_API uint04 indexOf(const char& sub_string) const;

        NDEVR_BASE_API uint04 indexOf(const char& sub_string, uint04 start_pos) const;

        NDEVR_BASE_API uint04 indexOf(const char& sub_string, uint04 start_pos, uint04 size) 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 char value, bool ignore_case = false) const;

        NDEVR_BASE_API StringViewBuffer split(char delimiter, bool preserve_empty = true) const;

        NDEVR_BASE_API StringView splitPart(char delimiter, uint04 index) const;
        NDEVR_BASE_API 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;
 

        NDEVR_BASE_API bool isSameNoCase(const StringView& s) const;

        NDEVR_BASE_API bool matchesWildcard(const StringView& pattern) const;

        [[nodiscard]] constexpr const char& operator[](const uint04 idx) const
        {
            return m_start[idx];
        }

        NDEVR_BASE_API constexpr uint08 hash() const
        {
            uint08 hash = 5381;//random number
            for (uint04 i = 0; i < size(); i++)//while string is not null
                hash = ((hash << 5) + hash) + cast<sint04>((*this)[i]); // hash * 33 + c
            return hash;
        }

        static constexpr uint08 hash(const char* value)
        {
            uint08 hash_value = 5381U;
            for (const char* n_value = value; *n_value; n_value++)
            {
                hash_value = ((hash_value << 5) + hash_value) + cast<uint08>(*n_value);
            }
            return hash_value;
        }

        NDEVR_BASE_API constexpr uint08 hashUpper() const
        {
            uint08 hash = 5381;
            for (uint04 i = 0; i < size(); i++)//while string is not null
            {
                char upper = cast<char>(toupper((*this)[i]));
                hash = ((hash << 5) + hash) + cast<sint04>(upper); // hash * 33 + c
            }
            return hash;
        }

        NDEVR_BASE_API constexpr uint08 hashLower() const
        {
            uint08 hash = 5381;
            for (uint04 i = 0; i < size(); i++)//while string is not null
                hash = ((hash << 5) + hash) + cast<sint04>(tolower((*this)[i])); // hash * 33 + c
            return hash;
        }

        NDEVR_BASE_API StringView substr(uint04 start) const;
        NDEVR_BASE_API StringView substr(uint04 start, uint04 end) const;

        NDEVR_BASE_API uint04 fromHex() const;

        NDEVR_BASE_API StringAllocatingView shortenString(uint04 size) const;
        NDEVR_BASE_API StringAllocatingView insertNewLines(uint04 max_line_size) const;
        NDEVR_BASE_API String predictNextStringIncrement() const;
        NDEVR_BASE_API StringAllocatingView toUpper() const;
        NDEVR_BASE_API StringAllocatingView toLower() const;
        constexpr uint04 size() const
        {
            return m_size;
        }

        static NDEVR_BASE_API StringViewBuffer Convert(const StringBuffer& strings);
        static void Convert(StringBuffer&& strings) = delete;
        static NDEVR_BASE_API StringBuffer Convert(const StringViewBuffer& views);

        NDEVR_BASE_API String toTitleString() const;
        
        NDEVR_BASE_API bool isNumeric() const;
        NDEVR_BASE_API bool operator==(const String& value) const;
        NDEVR_BASE_API bool operator!=(const String& value) const;
        constexpr 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;
        }

        constexpr 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<std::size_t t_size>
        constexpr bool operator==(const char(&string)[t_size])
        {
            if (t_size <= size())
                return false;
            for (uint04 i = 0; i < size(); i++)
            {
                if (string[i] != (*this)[i])
                    return false;
            }
            return string[size()] == '\0';
        }

        constexpr 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>
        constexpr 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;
        }

        constexpr 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;//check if strings are same size
        }

        constexpr StringView& operator=(const StringView& value)
        {
            m_size = value.size();
            m_start = value.m_start;
            return *this;
        }

        NDEVR_BASE_API StringView& operator=(const String& value);
        StringView& operator=(String&& value) = delete;
        template<std::size_t t_size>
        constexpr StringView& operator=(const char(&string)[t_size])
        {
            m_size = str_len(string);
            m_start = string;
            return *this;
        }

        constexpr StringView& operator=(const char* value)
        {
            m_size = str_len(value);
            m_start = value;
            return *this;
        }

        NDEVR_BASE_API bool operator<(const StringView& value) const;
        NDEVR_BASE_API bool operator>(const StringView& value) const;
        NDEVR_BASE_API bool isLessNoCase(const StringView& other) const;
        NDEVR_BASE_API bool isGreaterNoCase(const StringView& other) const;
        [[nodiscard]] constexpr const char* begin() const
        {
            return m_start;
        }

        [[nodiscard]] constexpr const char* begin(uint04 idx_offset) const
        {
            return m_start + idx_offset;
        }

        [[nodiscard]] constexpr const char* end() const
        {
            return m_start + m_size;
        }

        [[nodiscard]] constexpr bool contains(char c) const
        {
            for (const char& iter : *this)
            {
                if (iter == c)
                    return true;
            }
            return false;
        }

        [[nodiscard]] NDEVR_BASE_API uint04 count(char c) const;
        NDEVR_BASE_API StringView& trimWhiteSpace();
        NDEVR_BASE_API void removeLast(uint04 count = 1);
        NDEVR_BASE_API void removeFirst(uint04 count = 1);
        [[nodiscard]] NDEVR_BASE_API char last() const;
        bool isNullTerminated() const;
        NDEVR_BASE_API void ensureNullTerminated(String& s);
    public:
        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;
        }

        void addToSize(uint04 size)
        {
            m_size += size;
        }
    protected:
        const char* m_start = nullptr; 
        uint04 m_size = 0; 
    };
    template<> inline const StringView Constant<StringView>::Invalid = StringView(); 
    template<>
    constexpr bool IsInvalid(const StringView& value)
    {
        return value.size() == 0;
    }

    template<>
    constexpr bool IsValid(const StringView& value)
    {
        return value.size() > 0;
    }

    template<>
    struct ObjectInfo<StringView, false, false>
    {
        static const uint01 Dimensions = 0; 
        static const bool Vector = false; 
        static const bool Buffer = false; 
        static const bool Primitive = true; 
        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>(); }
    };

    class NDEVR_BASE_API UTF8Iterator
    {
    public:
        UTF8Iterator(const StringView& string);
        wchar nextChar();
        uint04 location(const StringView& original_string) const;
    protected:
        StringView string; 
    };
}
namespace std//Define things to allow use within std libs
{
    template<>
    struct equal_to<NDEVR::StringView>
    {
        using is_transparent = std::true_type; 
        bool operator()(const StringView& a, const String& b) const { return a == b; }
        bool operator()(const StringView& a, const StringView& b) const { return a == b; }
        bool operator()(const StringView& a, const char* b) const { return a == b; }
        template<std::size_t N>
        bool operator()(const StringView& a, const char(&b)[N]) { return a == b; }
        template<std::size_t N>
        bool operator()(const char(&a)[N], const StringView& b) { return a == b; }
    };
    template <>
    struct hash<StringView>
    {
        using is_transparent = std::true_type; 
        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>(StringView::hash(s));
        }
        NDEVR_BASE_API size_t operator()(const String& s) const;
        template<size_t N>
        constexpr size_t operator()(const char(&s)[N]) const noexcept
        {
            return static_cast<size_t>(StringView::hash(s));
        }
    };
    NDEVR_BASE_API istream& operator>>(istream& in, String& string);
    NDEVR_BASE_API ostream& operator<<(ostream& in, const String& string);
};