String.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
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 <cmath>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief The core String class for the software.
 
    - Explicitly uses Unicode (UTF8)
    - Easy functions for converting to anything (getAs<class>())
    - Inherits faster Buffer class
    *-----------------------------------------------------------------------------------------------**/
    class String : public Buffer<char, uint04, ObjectAllocator<true>, BufferAllocator<char, uint04, true>>
    {
    public:
        NDEVR_BASE_API String();
        NDEVR_BASE_API String(const String& string);
        NDEVR_BASE_API String(String&& string) noexcept;
        
        template<std::size_t N>
        String(const char (&string)[N])
            : Buffer(string, str_len(string))
        {}
        template<std::size_t N>
        String(const wchar(&string)[N])
        {
            addUnicodeAsUTF8(string);
        }
        String(const char* string)
            : Buffer(string, string == nullptr ? 0 : str_len(string))
        {}
        NDEVR_BASE_API String(const char* const string, uint04 size);
 
        String(uint04 size, const char& value)
            : Buffer(size, value)
        {}
 
        template<class t_type>
        explicit String(const t_type& value)
        {
            StringStream<t_type>::toString(value, *this);
        }
 
        // ----------------------------------------------------------------------------
        // Tests if this starts with the specified prefix.
        // ----------------------------------------------------------------------------
        NDEVR_BASE_API bool beginsWith(const String& s, bool ignore_case = false) const;
 
        // ----------------------------------------------------------------------------
        // Tests if this ends with the specified postfix.
        // ----------------------------------------------------------------------------
        NDEVR_BASE_API bool endsWith(const String& s, bool ignore_case = false) const;
 
        // ----------------------------------------------------------------------------
        // Given a substtring specified by the input, returns the first index of that 
        // string, if it exists. If it does not exist, Math::getNull<uint04>() is 
        // returned. start_index specifies an index to begin checking at. All values
        // prior to start_index will not be checked.
        // ----------------------------------------------------------------------------
        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 char value, bool ignore_case = false) const;
        NDEVR_BASE_API bool hasSubString(const String& sub_string, bool ignore_case = false) const;
        NDEVR_BASE_API bool hasSubString(const char* sub_string, bool ignore_case = false) const;
        
        NDEVR_BASE_API String& replace(const String& sub_string, const String& replace_sub_string, bool ignore_case = false);
        NDEVR_BASE_API String& replace(const Buffer<String, uint04, ObjectAllocator<false>>& sub_string, const Buffer<String, uint04, ObjectAllocator<false>>& replace_sub_string, bool ignore_case = false);
 
        NDEVR_BASE_API Buffer<String, uint04, ObjectAllocator<false>> splitString(char delimiter, bool preserve_empty = true) const;
        NDEVR_BASE_API Buffer<String, uint04, ObjectAllocator<false>> splitString(const Buffer<char>& delimiter, bool preserve_empty = true) const;
        NDEVR_BASE_API void splitString(char delimiter, Buffer<String, uint04, ObjectAllocator<false>>& strings, bool preserve_empty = true) const;
        NDEVR_BASE_API void splitString(const Buffer<char>& delimiter, Buffer<String, uint04, ObjectAllocator<false>>& strings, bool preserve_empty = true) const;
        
        NDEVR_BASE_API Buffer<String, uint04, ObjectAllocator<false>> splitStringLength(uint04 max_chars_per_line) const;
 
        NDEVR_BASE_API Buffer<String, uint04, ObjectAllocator<false>> splitStringLength(fltp04 length, fltp04 (&font_width)[256]) const;
        NDEVR_BASE_API const char* c_str() const;
 
        NDEVR_BASE_API bool isSameNoCase(const String& s) const;
        NDEVR_BASE_API bool matchesWildcard(const String& pattern) const;
        NDEVR_BASE_API String& append(const String& string);
        NDEVR_BASE_API uint08 hash() const;
        NDEVR_BASE_API uint08 hashUpper() const;
        NDEVR_BASE_API uint08 hashLower() const;
 
        NDEVR_BASE_API static bool AlphaNumericCompare(const String& left, const String& right);
 
        template<class t_type>
        static TranslatedString DisplayString(const t_type& value);
        
        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)
        {
            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;
        }
        operator uint08() const
        {
            return hash();
        }
        operator uint04() const
        {
            return cast<uint04>(hash() % Constant<uint04>::Max);
        }
        size_t operator()() const
        {
            return cast<size_t>(hash());
        }
        NDEVR_BASE_API String substr(uint04 start) const;
        NDEVR_BASE_API String substr(uint04 start, uint04 end) const;
        NDEVR_BASE_API static bool IsWhiteSpace(char s);
        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 static String NumberString(fltp08 value, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, char decimal = '.', char comma = ',');
        NDEVR_BASE_API String formatTitleString() 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 String shortenString(uint04 size) const;
        NDEVR_BASE_API String insertNewLines(uint04 max_line_size) const;
 
        NDEVR_BASE_API String predictNextStringIncrement() const;
 
        NDEVR_BASE_API String toUpper() const;
 
        NDEVR_BASE_API String toLower() const;
 
        NDEVR_BASE_API bool isNumeric() const;
        NDEVR_BASE_API static String ConvertToCharString(uint04 number);
        NDEVR_BASE_API uint04 fromHex() const;
        NDEVR_BASE_API static String toHex(uint01 value);
        NDEVR_BASE_API static String toHex(char value);
        NDEVR_BASE_API static wchar UTF8toUnicode(const char* utf8, uint04& advance);
        NDEVR_BASE_API void addUnicodeAsUTF8(const wchar* unicode);
        NDEVR_BASE_API bool addUnicodeCharAsUTF8(const wchar* unicode, uint04& advance);
        NDEVR_BASE_API static String UnicodetoUTF8(const wchar* unicode, uint04& advance);
        
        void addWChar(const wchar& object);
 
        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++)
            {
                String local_hex = toHex(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, class t_buff>
        static String toHex(const Buffer<t_object, t_allocator, t_buff>& 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 String& values)
        {
            String hex;
            hex.ensureCapacity(values.size());
            for (uint04 i = 0; i < values.size(); i++)
            {
                hex += toHex(values[i]);
            }
            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;
        }
 
        String& operator=(const String& value)
        {
            Buffer::operator=(value);
            return *this;
        }
 
        String& operator=(String&& value) noexcept
        {
            Buffer::operator=(std::move(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 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>
        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
        }
        template <class t_type>
        t_type getAs() const
        {
            t_type value;
            StringStream<t_type>::fromString(*this, value);
            return value;
        }
        NDEVR_BASE_API bool operator<(const String& value) const;
        NDEVR_BASE_API bool operator>(const String& value) const;
        private:
            // 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);
    };
    struct NDEVR_BASE_API UTF8Iterator
    {
        UTF8Iterator(const String& string);
        wchar nextChar();
    protected:
        const String& string;
        uint04 m_position;
    };
 
    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+(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+(String&& v1, const char& v2)
    {
        v1.add(v2);
        return std::move(v1);
    }
 
    inline String operator+(const String& v1, const char& v2)
    {
        String s(v1);
        s.add(v2);
        return s;
    }
 
    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;
    }
 
    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(v1);
        combined.addAll(v2, cast<uint04>(String::str_len(v2)));
        return combined;
    }
    
    inline String& operator+=(String& string, const String& value)
    {
        string.addAll(value);
        return string;
    }
    template<size_t t_size>
    inline String& operator+=(String& v1, const char(&v2)[t_size])
    {
        v1.addAll(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;
    }
};
 
 
namespace std//Define things to allow use within std libs
{
    template <>
    struct hash<NDEVR::String>
    {
        std::size_t operator()(const NDEVR::String& s) const noexcept
        {
            return static_cast<size_t>(s.hash());
        }
    };
    NDEVR_BASE_API istream& operator>>(istream& in, NDEVR::String& string);
    NDEVR_BASE_API ostream& operator<<(ostream& in, const NDEVR::String& string);
};