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 NDEVR API.
 
    This String class:
        - Explicitly uses Unicode (UTF8)
        - Easy functions for converting to anything (getAs<class>())
        - Inherits faster Buffer class
        - Provides a quick way to easily convert classes to and from a string in a modular way.
 
    See StringStream for details on providing a definition that will allow any object to be used as a 
        constructor for String, or convert a String into any object using getAs<...>()
 
    The string container is guaranteed to be null-terminated meaning that c_str() and begin() will 
        both point directly into the data structure.
 
    TranslatedString should be used, when possible, for any data that will be displayed to the user.
 
    Strings can be used in case statements using string.hash[upper/lower]()
    \code
    switch (string.hashUpper())
    {
    case String::hash("DEFAULT"): value = CompressionMode::e_default; break;
    case String::hash("BEST"): value = CompressionMode::e_best; break;
    case String::hash("NONE"): value = CompressionMode::e_none; break;
    }
    \endcode
    Since the String is null terminated, declaring a String using String(256) will allocate 
        257 bytes on the heap. Thus for memory management, block sizes should be one smaller.
    */
    class String : public Buffer<char, uint04, ObjectAllocator<true>, BufferAllocator<char, uint04, true>>
    {
    public:
        /**
        \brief Constructor used to create an empty String*
        */
        NDEVR_BASE_API String();
        /**
        \brief Copy Constructor
         */
        NDEVR_BASE_API String(const String& string);
        /**
        \brief Move contructor (No new memory allocation).
         */
        NDEVR_BASE_API String(String&& string) noexcept;
        
        /**
        \brief String Constructor for static char arrays.
        \param[in] string The array of characters making up the string. Should be in Unicode (UTF8)
         */
        template<std::size_t N>
        String(const char (&string)[N])
            : Buffer(string, str_len(string))
        {}
        String(const char (&string)[N]) {…}
        /**
        \brief String Constructor for static wchar arrays of UTF16 data.
        \param[in] string UTF16 array of characters making up the string, will be converted to UTF8.
         */
        template<std::size_t N>
        String(const wchar(&string)[N])
        {
            addUTF16AsUTF8(string);
        }
        String(const wchar(&string)[N]) {…}
        /**
        \brief String Constructor for null terminated array of chars
        \param[in] string The array of characters making up the string. Should be in Unicode (UTF8) and
            null terminated.
         */
        String(const char* string)
            : Buffer(string, string == nullptr ? 0 : str_len(string))
        {}
        String(const char* string) {…}
        /**
        \brief String Constructor char arrays when the size is known. Slightly faster than iterating
            over a null-terminated array.
        \param[in] string The array of characters making up the string. Should be in Unicode (UTF8)
        \param[in] size The size of the string
         */
        NDEVR_BASE_API String(const char* const string, uint04 size);
 
        /**
        \brief String Constructor creates a string of a size and fills it with a character
        \param[in] size The size of the string
        \param[in] value The value to set all characters in the string to.
         */
        String(uint04 size, const char& value)
            : Buffer(size, value)
        {}
        String(uint04 size, const char& value) {…}
 
        /**
        \brief String Constructor that creates a string based off an object. To use this function an object
            must have overwritten StringStream<t_type>::toString.
        \param[in] value The value to use as a reference to generate a string representation.
         */
        template<class t_type>
        explicit String(const t_type& value)
        {
            StringStream<t_type>::toString(value, *this);
        }
        explicit String(const t_type& value) {…}
 
        /**
        \brief Converts a string into an object. To use this function an object
            must have overwritten StringStream<t_type>::fromString.
        \returns The object value of this string.
         */
        template <class t_type>
        t_type getAs() const
        {
            t_type value;
            StringStream<t_type>::fromString(*this, value);
            return value;
        }
        t_type getAs() const {…}
        /**
        \brief Converts an object into a TranslatedString. To use this function an object
            must have overwritten StringStream<t_type>::toDisplayString.
        \returns The user-friendly string representation of this object.
         */
        template<class t_type>
        static TranslatedString DisplayString(const t_type& value);
        /**
        \brief Tests if this String starts with the specified prefix.
        \param[in] s the value to test against the start of this string.
        \param[in] ignore_case whether or not to check using case sensitivity.
        \returns true if the String begins with this value
         */
        NDEVR_BASE_API bool beginsWith(const String& s, bool ignore_case = false) const;
 
        /**
        \brief Tests if this String ends with the specified suffix.
        \param[in] s the value to test against the start of this string.
        \param[in] ignore_case whether or not to check using case sensitivity.
        \returns true if the String begins with this value
         */
        NDEVR_BASE_API bool endsWith(const String& s, bool ignore_case = false) const;
 
        /**
        \brief Tests if this String contains the specified substring.
        \param[in] sub_string the value to test for containment.
        \param[in] ignore_case whether or not to check using case sensitivity.
        \returns true if the String contains this value
         */
        NDEVR_BASE_API bool hasSubString(const String& sub_string, bool ignore_case = false) const;
 
        /**
        \brief Tests if this String contains the specified substring.
        \param[in] sub_string the value to test for containment.
        \param[in] ignore_case whether or not to check using case sensitivity.
        \returns true if the String contains this value
         */
        NDEVR_BASE_API bool hasSubString(const char* sub_string, bool ignore_case = false) const;
 
        /**
        \brief Given a substring specified by the input, returns the first index of that string, if it exists.
        \param[in] sub_string the value to find in the String
        \param[in] ignore_case whether or not to check using case sensitivity.
        \param[in] start_index The index of where to begin searching for the sub_string.
        \returns The first index pointing to the beginning of the substring, if it exists. If it is not 
            found, Constant<uint04>::Invalid is returned.
         */
        NDEVR_BASE_API uint04 indexOf(const String& sub_string, bool ignore_case = false, uint04 start_index = 0) const;
 
        /**
        \brief Given a substring specified by the input, returns the first index of that string, if it exists.
        \param[in] sub_string the value to find in the String
        \returns The first index pointing to the beginning of the substring, if it exists. If it is not 
            found, Constant<uint04>::Invalid is returned.
         */
        NDEVR_BASE_API uint04 indexOf(const char& sub_string) const  { return Buffer::indexOf(sub_string); }
 
        /**
        \brief Given a substring specified by the input, returns the first index of that string, if it exists.
        \param[in] sub_string the value to find in the String
        \param[in] start_pos The index of where to begin searching for the sub_string.
        \returns The first index pointing to the beginning of the substring, if it exists. If it is not 
            found, Constant<uint04>::Invalid is returned.
         */
        NDEVR_BASE_API uint04 indexOf(const char& sub_string, uint04 start_pos) const { return Buffer::indexOf(sub_string, start_pos); }
 
        /**
        \brief Given a substring specified by the input, returns the first index of that string, if it exists.
        \param[in] sub_string the value to find in the String
        \param[in] start_pos The index of where to begin searching for the sub_string.
        \param[in] size The max span to continue searching for the sub_string. The sub_string must entirely
            reside within the span from start_pos to sie to be valid.
        \returns The first index pointing to the beginning of the substring, if it exists. If it is not 
            found, Constant<uint04>::Invalid is returned.
         */
        NDEVR_BASE_API uint04 indexOf(const char& sub_string, uint04 start_pos, uint04 size) const { return Buffer::indexOf(sub_string, start_pos, size); }
 
        /**
        \brief Given a substring specified by the input, returns the first index of that string, if it exists.
        \param[in] sub_string the value to find in the String
        \param[in] ignore_case whether or not to check using case sensitivity.
        \param[in] start_index The index of where to begin searching for the sub_string.
        \returns The first index pointing to the beginning of the substring, if it exists. If it is not 
            found, Constant<uint04>::Invalid is returned.
         */
        NDEVR_BASE_API uint04 indexOf(const char* sub_string, bool ignore_case = false, uint04 start_index = 0) const;
 
        /**
        \brief Given a substring specified by the input, returns the first index of that string, if it exists.
        \param[in] sub_string the value to find in the String
        \param[in] ignore_case whether or not to check using case sensitivity.
        \param[in] start_index The index of where to begin searching for the sub_string.
        \param[in] size The max span to continue searching for the sub_string. The sub_string must entirely
            reside within the span from start_pos to sie to be valid.
        \returns The first index pointing to the beginning of the substring, if it exists. If it is not 
            found, Constant<uint04>::Invalid is returned.
         */
        NDEVR_BASE_API uint04 indexOf(const char* sub_string, bool ignore_case, uint04 start_index, uint04 size) const;
 
        /**
        \brief Given a substring specified by the input, returns the first index of that string, if it exists.
        \param[in] sub_string the value to find in the String
        \param[in] escape_char The char that when encountered, ends the search.
        \param[in] ignore_case whether or not to check using case sensitivity.
        \param[in] start_index The index of where to begin searching for the sub_string.
        \returns The first index pointing to the beginning of the substring, if it exists. If it is not 
            found, Constant<uint04>::Invalid is returned.
         */
        NDEVR_BASE_API uint04 indexOf(const char* sub_string, char escape_char, bool ignore_case = false, uint04 start_index = 0) const;
 
        /**
        \brief Given a substring specified by the input, returns the last index of that string, if it exists.
        \param[in] sub_string the value to find in the String
        \param[in] ignore_case whether or not to check using case sensitivity.
        \returns The last index of pointing to the beginning of the substring, if it exists. If it does not 
            exist, Constant<uint04>::Invalid is returned.
         */
        NDEVR_BASE_API uint04 lastIndexOf(const char* sub_string, bool ignore_case = false) const;
 
        /**
        \brief Given a value specified by the input, returns the last index of that char, if it exists.
        \param[in] value the value to find in the String
        \param[in] ignore_case whether or not to check using case sensitivity.
        \returns The last index of pointing to the beginning of the substring, if it exists. If it does not
            exist, Constant<uint04>::Invalid is returned.
         */
        NDEVR_BASE_API uint04 lastIndexOf(const char value, bool ignore_case = false) const;
 
        /**
        \brief Replaces ALL instances of a given substring with the provided replacement. 
        \param[in] sub_string The subsring to replace
        \param[in] replace_sub_string The string to replace ALL instances of the provided sub_string with.
        \param[in] ignore_case whether or not to check using case sensitivity checks. This will not 
            affect the replacement value, only which parts to replace.
        \returns A reference to this String.
         */
        NDEVR_BASE_API String& replace(const String& sub_string, const String& replace_sub_string, bool ignore_case = false);
 
        /**
        \brief Replaces ALL instances of the given substrings with the provided replacements. This allows safe
            replacement when the replacement string might contain the same data being replaced.
 
        \param[in] sub_string The subsrings to replace
        \param[in] replace_sub_string The strings to replace ALL instances of the provided sub_string with.
        \param[in] ignore_case whether or not to check using case sensitivity checks. This will not
            affect the replacement value, only which parts to replace.
        \returns A reference to this String.
         */
        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);
 
        /**
        \brief Given a delimiter, breaks the string into subsections, returning an array of each subsection.
            If the String is empty, an empty String will be appended to the output if preserve_empty is true.
 
        For example, String("The quick, dog,,jumped").splitString(',', true) would 
            return {"The quick", " dog", "", "jumped"}
 
        \param[in] delimiter The delimiter to split the string
        \param[in] preserve_empty If true, when two delimiters are encountered, an empty string is added to
            the return Buffer. If false, there will be no added empty strings.
        \returns A Buffer of substrings that were broken apart from this string using the delimiter.
         */
        NDEVR_BASE_API Buffer<String, uint04, ObjectAllocator<false>> splitString(char delimiter, bool preserve_empty = true) const;
        
        /**
        \brief Given multiple delimiter, breaks the string into subsections, returning an array of each subsection.
            If the String is empty, an empty String will be appended to the output if preserve_empty is true.
        For example, String("The quick, dog,,jumped").splitString({',', ' '}, true) would
            return {"The", "quick", "dog", "", "jumped"}
        \param[in] delimiter The delimiter to split the string
        \param[in] preserve_empty If true, when two delimiters are encountered, an empty string is added to
            the return Buffer. If false, there will be no added empty strings.
        \returns A Buffer of substrings that were broken apart from this string using the delimiters.
         */
        NDEVR_BASE_API Buffer<String, uint04, ObjectAllocator<false>> splitString(const Buffer<char>& delimiter, bool preserve_empty = true) const;
        
        /**
        \brief Given multiple delimiter, breaks the string into subsections, and APPENDS each substring to the given Buffer.
            If the String is empty, an empty Buffer will be appended if preserve_empty is true.
        \param[in] delimiter The delimiter to split the string
        \param[in] preserve_empty If true, when two delimiters are encountered, an empty string is added to
            the return Buffer. If false, there will be no added empty strings.
        \param[out] strings will be appended with substrings that were broken apart from this string using the delimiter.
         */
        NDEVR_BASE_API void splitString(char delimiter, Buffer<String, uint04, ObjectAllocator<false>>& strings, bool preserve_empty = true) const;
        
        /**
        \brief Given multiple delimiter, breaks the string into subsections, and APPENDS each substring to the given Buffer.
            If the String is empty, an empty String will be appended if preserve_empty is true.
        \param[in] delimiter The delimiter to split the string
        \param[in] preserve_empty If true, when two delimiters are encountered, an empty string is added to
            the return Buffer. If false, there will be no added empty strings.
        \param[out] strings will be appended with substrings that were broken apart from this string using the delimiter.
         */
        NDEVR_BASE_API void splitString(const Buffer<char>& delimiter, Buffer<String, uint04, ObjectAllocator<false>>& strings, bool preserve_empty = true) const;  
 
        /**
        \brief Used to access the raw memory of this string.
        \returns A pointer to the internal memory of the string which is guaranteed to be null terminated.
        */
        NDEVR_BASE_API const char* c_str() const;
 
        /**
        \brief Checks whether two strings match in a case-insensitive way.
        \param[in] s The string to compare against
        \returns True if the strings match in a case insensitive way.
        */
        NDEVR_BASE_API bool isSameNoCase(const String& s) const;
 
        /**
        \brief Checks whether two strings match allowing '*' to be used as a wildcard pattern.
        For example, String(\"Hello\").matchesWildcard(\"*ll*\") would return true.
        \param[in] pattern The pattern used to check the string against.
        \returns true if the string matches a given wild card pattern.
        */
        NDEVR_BASE_API bool matchesWildcard(const String& pattern) const;
        /**
        \brief Appends a string to the back of this string.
        \param[in] string The string to append.
        \returns A reference to this string.
        */
        NDEVR_BASE_API String& append(const String& string);
        /**
        \brief Creates a simple, quick hash of the object. See hash(const char* value)
            for details of the implementation.
        \returns A hash value for this string.
        */
        NDEVR_BASE_API uint08 hash() const;
        /**
        \brief Creates a simple, quick hash of the object. See hash(const char* value)
            for details of the implementation.
        \returns A hash value for this string as if it were all uppercase.
        */
        NDEVR_BASE_API uint08 hashUpper() const;
        /**
        \brief Creates a simple, quick hash of the object. See hash(const char* value)
            for details of the implementation.
        \returns A hash value for this string as if where all lowercase.
        */
        NDEVR_BASE_API uint08 hashLower() const;
        /**
        \brief Creates a substring from a given start position, to the end of the string
        \param[in] start The index where to start the substring.
        \returns the substring starting at start.
        */
        NDEVR_BASE_API String substr(uint04 start) const;
        /**
        \brief Creates a substring from a given start position, to the given end position, non-inclusive of the 
            end index. If the end index is greater than the size of the string, all data past start is returned.
        \param[in] start the index where to start the substring.
        \param[in] end the index where to end the substring (non-inclusive).
        \returns the substring starting at start, going until end index or the end of the string.
        */
        NDEVR_BASE_API String substr(uint04 start, uint04 end) const;
        /**
        \brief Trims any white space (tabs, spaces, etc) from the beginning and end of the string.
        \returns A reference to this String.
        */
        NDEVR_BASE_API String& trimWhiteSpace();
        /**
        \brief Used for formatting, will, if necessary, add white space so that the string becomes a
            certain length. desired_right_alignment_location Will try and align the string to a location by
            prepending whitspace. desired_string_size will append space to try and make the string a given size.
        \param[in] desired_string_size The size the string should be once whitespace is added to the end.
        \param[in] desired_right_alignment_location If the string is smaller than desired_right_alignment_location
            will add whitespace until the rightmost terminating index is equal to desired_right_alignment_location.
        \param[in] whitespace the character to use for whitespace.
        \returns A reference to this String.
        */
        NDEVR_BASE_API String& addWhiteSpace(uint04 desired_string_size, uint04 desired_right_alignment_location = 0, char whitespace = ' ');
        /**
        \brief For a string representing a number, makes the decimals equal to the the provided value
        Example: String("1000000").formatNumberString(2); will make "1000000.00"
        \warning Undefined behavior if this string does not represent a single number.
        \param[in] decimals the set number of decimals the string should have.
        \returns A reference to this String.
        */
        NDEVR_BASE_API String& formatNumberString(uint04 decimals);
        /**
        \brief For a string representing a number, makes the decimals equal to the the provided value and
            adds comma seperators if number is large enough
        \warning Undefined behavior if this string does not represent a single number.
        Example: String("1000000").formatNumberString(true, 2); will make "1,000,000.00"
 
        \param[in] add_comma Adds comma seperators if number is large enough
        \param[in] decimals the set number of decimals the string should have.
        \returns A reference to this String.
        */
        NDEVR_BASE_API String& formatNumberString(bool add_comma, uint04 decimals);
        /**
        \brief Modifies the contents of this string, that represents a given number using the provided rules.
        \warning Undefined behavior if this string does not represent a single number.
        \param[in] add_comma Adds comma seperators if number is large enough
        \param[in] min_decimals The minimum number of decimals the formatted number should have (will add 0's to end)
        \param[in] max_decimals The maximum number of decimals the formatted number should have (will remove more decimals)
        \param[in] min_digits The minimum number of digits the formatted number should have (will add 0's to the begining)
        \param[in] decimal The character to use as the decimal ('.')
        \param[in] comma The character to use as the comma (',')
        \returns A reference to this String.
        */
        NDEVR_BASE_API String& formatNumberString(bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, char decimal = '.', char comma = ',');
        /**
        \brief Formats the string to be a title, capitalizing important characters and replacing underscores with spaces
        \returns A reference to this String.
        */
        NDEVR_BASE_API String& formatAsTitleString();
        /**
        \brief Removes any characters that aren't numbers or letters with other options available.
        \param[in] remove_tab Whether or not to remove tabs
        \param[in] remove_space Whether or not to remove spaces
        \param[in] remove_new_line Whether or not to remove new lines '\\n'
        \param[in] remove_r Whether or not to remove carage return '\\r'
        \param[in] remove_numbers Whether or not to remove numbers.
        \returns A reference to this String.
        */
        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);
        /**
        \brief Removes anything that is not a number or decimal ('0'-'9' or .)
        \returns A reference to this String.
        */
        NDEVR_BASE_API String& removeNonNumeric();
        /**
        \brief Shortans the string to the max size provided. If string is longer, searches for
            an ideal place to insert "..."
        \param[in] size The max size of the new string.
        \returns The shortened String
        */
        NDEVR_BASE_API String shortenString(uint04 size) const;
        /**
        \brief Finds key areas to insert new lines such that the rows are at most, the 
            length provided.
        \param[in] max_line_size The max size of any row of the resulting string
        \returns A string with the new lines inserted appropriately
        */
        NDEVR_BASE_API String insertNewLines(uint04 max_line_size) const;
        /**
        \brief Looks in the string for key markers that might be an index, and attempts
            to increment the index. If no index is found a "1" will be inserted to the end
            of the string.
        \returns A string that represents an incremented index
        */
        NDEVR_BASE_API String predictNextStringIncrement() const;
        /**
        \brief changes all lower case characters into upper case characters.
        \returns A string in all upper case
        */
        NDEVR_BASE_API String toUpper() const;
        /**
        \brief changes all upper case characters into lower case characters.
        \returns A string in all lower case
        */
        NDEVR_BASE_API String toLower() const;
        /**
        \brief Checks to see if the string is a numeric string.
        \returns true if the string could be representing a number, false if some non-numeric data is present.
        */
        NDEVR_BASE_API bool isNumeric() const;
        /**
        \brief Converts a hex value into an unsigned 4 byte number 
        \returns the hex value of this string or Constant<uint04>::Invalid if this is not a hex string.
        */
        NDEVR_BASE_API uint04 fromHex() const;
        /**
        \brief Converts a unicode null terminated string of UTF16 wchars into UTF8 and
            appends it to the end of the String
        \param[in] unicode The UTF16 null-terminated string of chars to append to this string
        */
        NDEVR_BASE_API void addUTF16AsUTF8(const wchar* unicode);
        /**
        \brief Converts a single unicode character at advance into UTF8 and appends it to the end 
            of the String
        \param[in] unicode The UTF16 string of chars to append to this string
        \param[in,out] advance the location in unicode to append, will be incremented based on number of
            UT16 characters consumed (1 or 2).
        */
        NDEVR_BASE_API bool addUTF16CharAsUTF8(const wchar* unicode, uint04& advance);
        /**
        \brief Converts a single unicode character UTF16 character into one or more UTF8 characters and
            appends them to the end of this String.
        \param[in] object The UTF16 encoded object to append.
        */
        void addWChar(const wchar& object);
 
        String& operator=(const String& value)
        {
            Buffer::operator=(value);
            return *this;
        }
        String& operator=(const String& value) {…}
 
        String& operator=(String&& value) noexcept
        {
            Buffer::operator=(std::move(value));
            return *this;
        }
        String& operator=(String&& value) noexcept {…}
        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 String& value) const {…}
        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
        }
        bool operator==(const char* const value) const {…}
        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(&string)[t_size]) {…}
 
        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
        }
        bool operator!=(const char* const value) const {…}
        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 char(&string)[t_size]) {…}
        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 String& value) const {…}
        NDEVR_BASE_API bool operator<(const String& value) const;
        NDEVR_BASE_API bool operator>(const String& value) const;
 
        operator uint08() const
        {
            return hash();
        }
        operator uint08() const {…}
        operator uint04() const
        {
            return cast<uint04>(hash() % Constant<uint04>::Max);
        }
        operator uint04() const {…}
        size_t operator()() const
        {
            return cast<size_t>(hash());
        }
        size_t operator()() const {…}
    public:
        /**
        \brief Converts a number into a char string. For example 0 will become 'A' and 27 will become 'AA'
        \param[in] number The number to convert to a character representation.
        */
        NDEVR_BASE_API static String ConvertToCharString(uint04 number);
        /**
        Converts a single unicode character at advance into UTF8 and and returns it as a String
        \param[in] unicode The UTF16 string of chars to append to this string
        \param[in,out] advance the location in unicode to append, will be incremented based on number of
            UT16 characters consumed (1 or 2).
        */
        NDEVR_BASE_API static String UTF16toUTF8(const wchar* unicode, uint04& advance);
        /**
        \brief Checks whether a given character is a whitespace character or not.
        \param[in] s the character to check against.
        \returns true if the character is considered by the software to be whitespace, false if not.
        */
        NDEVR_BASE_API static bool IsWhiteSpace(char s);
        /**
        \brief Creates a string from a given number using the provided rules. 
        \warning If the value is Invalid, the resulting string will be \"NaN\".
        \param[in] value The value to convert to a string.
        \param[in] add_comma Adds comma seperators if number is large enough
        \param[in] min_decimals The minimum number of decimals the formatted number should have (will add 0's to end)
        \param[in] max_decimals The maximum number of decimals the formatted number should have (will remove more decimals)
        \param[in] min_digits The minimum number of digits the formatted number should have (will add 0's to the begining)
        \param[in] decimal The character to use as the decimal ('.')
        \param[in] comma The character to use as the comma (',')
        \returns A reference to this String.
        */
        NDEVR_BASE_API static String NumberString(fltp08 value, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, char decimal = '.', char comma = ',');
        /**
        \brief Converts a unicode null terminated string of chars into a UTF16 wchar and
            increments advance by the ammount of characters consumed to make the
            UTF16 character.
        \param[in] utf8 the UTF8 value to convert to UTF16.
        \param[in,out] advance The advance from the start of utf8 which will be incremented by
            this function.
        \returns A UTF16 unicode character. 
        */
        NDEVR_BASE_API static wchar UTF8toUTF16(const char* utf8, uint04& advance);
        /**
        \brief Converts the memory of the given object into a hexidecimal string.
        \param[in] value The value to convert to a hex form.
        \returns A string filled with the hex values representing the given object
        */
        NDEVR_BASE_API static String ToHex(uint01 value);
        /**
        \brief Converts the memory of the given object into a hexidecimal string.
        \param[in] value The value to convert to a hex form.
        \returns A string filled with the hex values representing the given object
        */
        NDEVR_BASE_API static String ToHex(char value);
        /**
        \brief Converts the memory of the given object into a hexidecimal string.
        \param[in] value The value to convert to a hex form.
        \returns A string filled with the hex values representing the given 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;
        }
        static typename std::enable_if<ObjectInfo<t_object>::Integer, String>::type ToHex(t_object value) {…}
        /**
        \brief Converts a buffer of objects into a hexidecimal string.
        \param[in] values The values to convert to a hex form.
        \returns A string filled with the hex values representing the given object
        */
        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 Buffer<t_object, t_allocator, t_buff>& values) {…}
        /**
        \brief Converts a string of any type of data (assumed to be binary) into a hex representation.
        \param[in] values Raw binary data in the form of a string.
        \returns A string filled with the hex values representing the given object
        */
        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;
        }
        static String ToHex(const String& values) {…}
        /**
        \brief Converts a vector into a hex representation.
        \param[in] values Raw binary data in the form of a string.
        \returns A string filled with the hex values representing the given object
        */
        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;
        }
        static String ToHex(const Vector<t_size, t_type>& values) {…}
        /**
        \brief Compares two strings given their alpha-numeric determined value.
        \returns True if left is LESS than right.
         */
        NDEVR_BASE_API static bool AlphaNumericCompare(const String& left, const String& right);
 
        /**
        \brief constexpr method to get the length of a null-terminated string at compile time
        \param[in] value A null terminated string.
        \returns the length of the string.
         */
        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 char* value) {…}
        /**
        \brief constexpr method to get the UTF8 length of a null-terminated string at compile time
        \warning This is not designed to get the length of the wchar* array, but rather the length
            of a char* array that represents this array.
        \param[in] value A null-terminated UTF16 wchar string.
        \returns the length of the String object that would be created from this object.
         */
        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;
        }
        static constexpr uint04 str_len(const wchar* value) {…}
#if _MSC_VER
#pragma warning( disable : 4307)
#endif
        /**
        \brief constexpr method to hash a value. Also provides the hashing method used throughout the
            API to hash strings.
        \returns A hash value.
        \warning This is not designed to get the length of the wchar* array, but rather the length
            of a char* array that represents this array.
         */
        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;
        }
        static constexpr uint08 hash(const char* value) {…}
    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);
    };
    class String : public Buffer<char, uint04, ObjectAllocator<true>, BufferAllocator<char, uint04, true>> {…};
    /**--------------------------------------------------------------------------------------------------
    \brief Iterates over a UTF8 encoded string and returns the values as UTF16
    **/
    struct NDEVR_BASE_API UTF8Iterator
    {
        UTF8Iterator(const String& string);
        wchar nextChar();
    protected:
        const String& string;
        uint04 m_position;
    };
    struct NDEVR_BASE_API UTF8Iterator {…};
 
    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 String& string_a, const String& string_b) {…}
    inline String operator+(String&& v1, const String& v2)
    {
        v1.addAll(v2);
        return std::move(v1);
    }
    inline String operator+(String&& v1, const String& v2) {…}
    inline String operator+(String&& v1, String&& v2)
    {
        v1.addAll(v2);
        return std::move(v1);
    }
    inline String operator+(String&& v1, String&& v2) {…}
 
    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) {…}
 
    inline String operator+(String&& v1, const char& v2)
    {
        v1.add(v2);
        return std::move(v1);
    }
    inline String operator+(String&& v1, const char& v2) {…}
 
    inline String operator+(const String& v1, const char& v2)
    {
        String s(v1);
        s.add(v2);
        return s;
    }
    inline String operator+(const String& v1, const char& v2) {…}
 
    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 String& v2) {…}
 
    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);
    }
    inline String operator+(String&& v1, const char(&v2)[t_size]) {…}
    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+(const String& v1, const char(&v2)[t_size]) {…}
    
    inline String& operator+=(String& string, const String& value)
    {
        string.addAll(value);
        return string;
    }
    inline String& operator+=(String& string, const String& value) {…}
    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)[t_size]) {…}
 
    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;
    }
    inline String operator+(const char(&v1)[t_size], const String& v2) {…}
    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)[t_size], const String& v2) {…}
    inline bool operator==(const char*& v1, const String& v2)
    {
        return v2 == v1;
    }
    inline bool operator==(const char*& v1, const String& v2) {…}
    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;
    }
    inline String operator+(const char(&v1)[t_size], String&& v2) {…}
    template<class t_to>
    constexpr t_to cast(const String& value)
    {
        return static_cast<t_to>(value.getAs<t_to>());
    }
    constexpr t_to cast(const String& value) {…}
    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;
    }
    constexpr bool IsInvalid(const String& value) {…}
};
 
 
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);
};