String.h

 
#ifndef ACTIVE_UTILITY_STRING
#define ACTIVE_UTILITY_STRING
 
#include "Active/Utility/DataFormat.h"
#include "Active/Utility/MathFunctions.h"
#include "Active/Utility/Memory.h"
 
#include <functional>
#include <locale>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace active::utility {
    
    class BufferIn;
    class BufferOut;
    
 
    class String {
    public:
 
        using enum TextEncoding;
 
        //MARK: - Types
        
        using Unique = std::unique_ptr<String>;
        using Shared = std::shared_ptr<String>;
        using Option = std::optional<String>;
        using size_type = std::string::size_type;
        using sizeOption = std::optional<size_type>;
        using Filter = std::function<bool(char32_t)>;
        using Function = std::function<std::optional<char32_t>(char32_t)>;
        
        //MARK: - Constants
        
        static constexpr size_type npos = std::string::npos;
        static const String lineTerminator;
        static const String allWhiteSpace;
        static const String allLineEnding;
        static const String allDigit;
        static const String allNumeric;
        static const String allFloat;
        
        //MARK: - Constructors
 
        String() {}
        String(const BufferIn&& source);
        String(const char* source, sizeOption howMany = std::nullopt, DataFormat format = DataFormat{});
#ifndef __CLR_VER
        String(const char8_t* source, sizeOption howMany = std::nullopt) : String{reinterpret_cast<const char*>(source), howMany, DataFormat{}} {}
#endif
        String(const char16_t* source, sizeOption howMany = std::nullopt, bool isBigEndian = Memory::defaultEndian) : String{reinterpret_cast<const char*>(source),
                howMany ? String::sizeOption(*howMany * sizeof(char16_t)) : std::nullopt, DataFormat{UTF16, isBigEndian}} {}
        String(const char32_t* source, sizeOption howMany = std::nullopt, bool isBigEndian = Memory::defaultEndian) : String{reinterpret_cast<const char*>(source),
                howMany ? String::sizeOption(*howMany * sizeof(char32_t)) : std::nullopt, DataFormat{UTF32, isBigEndian}} {}
        String(const std::string& source, sizeOption howMany = std::nullopt, DataFormat format = DataFormat{}) :
                String{source.data(), howMany, format} {}
#ifndef __CLR_VER
        String(const std::u8string& source, sizeOption howMany = std::nullopt) : String(source.data(), howMany) {}
#endif
        String(const std::u16string& source, sizeOption howMany = std::nullopt);
        String(const std::u32string& source, sizeOption howMany = std::nullopt);
        String(size_type newSize, const String& fillText);
        explicit String(char val) : m_string{val}   {}
        explicit String(int16_t val) { m_string = std::to_string(val); }
        explicit String(uint16_t val) { m_string = std::to_string(val); }
        explicit String(int32_t val) { m_string = std::to_string(val); }
        explicit String(uint32_t val) { m_string = std::to_string(val); }
        explicit String(int64_t val) { m_string = std::to_string(val); }
        explicit String(uint64_t val) { m_string = std::to_string(val); }
#if !defined(WINDOWS) && !defined(__linux__)
        explicit String(size_t val) { m_string = std::to_string(static_cast<uint64_t>(val)); }
#endif //WINDOWS
        explicit String(double val, double prec = math::eps, bool padZero = false);
        String(const String& source);
        String(String&& source) noexcept;
        ~String() {}
        
        //MARK: - Static functions
 
        static size_type getValidByteCount(const char* text, sizeOption howMany = std::nullopt, sizeOption charCount = std::nullopt, DataFormat format = DataFormat{});
        static sizeOption getCharacterByteCount(const char* text, sizeOption howMany = std::nullopt, DataFormat format = DataFormat{});
        static String::sizeOption getCharacterCount(const char* text, sizeOption howMany = std::nullopt, DataFormat format = DataFormat{});
        static std::pair<char32_t, size_type> getUnicodeChar(const char* text, sizeOption howMany = std::nullopt, DataFormat format = DataFormat{});
        static std::optional<std::u32string> toUnicode(const char*& text, String::sizeOption howMany = std::nullopt, bool isCountRequired = false);
        static std::optional<String> fromUnicode(const char32_t*& text, bool isBigEndian, String::sizeOption howMany = std::nullopt, bool isCountRequired = false);
        static std::optional<std::u32string> fromUTF16(const char16_t*& text, bool isBigEndian, String::sizeOption howMany = std::nullopt, bool isCountRequired = false);
        static std::optional<std::u16string> toUTF16(const char32_t*& text, String::sizeOption howMany = std::nullopt, bool isCountRequired = false);
        
        //MARK: - Conversion operators
        
        operator std::string() const { return m_string; }
#ifndef __CLR_VER
        operator std::u8string() const;
#endif
        operator std::u16string() const;
        operator std::u32string() const;
        explicit operator int16_t() const { return toInt16().value_or(0); }
        explicit operator int32_t() const { return toInt32().value_or(0); }
        explicit operator uint32_t() const { return toUInt32().value_or(0); }
        explicit operator int64_t() const { return toInt64().value_or(0); }
        explicit operator uint64_t() const { return toUInt64().value_or(0); }
        explicit operator float() const { return toFloat().value_or(0.0); }
        explicit operator double() const { return toDouble().value_or(0.0); }
 
        //MARK: - Operators
        
        char32_t operator[](size_type index) const;
        String& operator= (const String& source);
        String& operator= (String&& source) noexcept;
        String& operator= (const char* source);
        std::strong_ordering operator<=> (const String& ref) const { return compare(ref); }
        bool operator== (const String& ref) const { return m_string == ref.m_string; }
        bool operator!= (const String& ref) const { return !(*this == ref); }
        String& operator+=(const String& source) { return append(source); }
        String& operator+=(char source) { return append(source); }
 
        //MARK: - Functions (const)
 
        size_type capacity() const;
        size_type size() const;
        size_type length() const { return size(); }
        size_type dataSize(sizeOption howMany = std::nullopt) const;
        bool empty() const { return m_string.empty(); }
        const char* data() const { return m_string.data(); }
        std::string string() const { return m_string; }
        char32_t at(size_type index) const;
        void forEach(const Function& func) const;
        String substr(size_type startPos = 0, sizeOption howMany = std::nullopt) const;
        String uppercase() const;
        String lowercase() const;
        std::optional<int16_t> toInt16() const { try { return std::stoi(m_string); } catch(...) { return std::nullopt; } }
        std::optional<int32_t> toInt32() const { try { return std::stol(m_string); } catch(...) { return std::nullopt; } }
        std::optional<uint32_t> toUInt32() const { try { return std::stoul(m_string); } catch(...) { return std::nullopt; } }
        std::optional<int64_t> toInt64() const { try { return std::stoll(m_string); } catch(...) { return std::nullopt; } }
        std::optional<uint64_t> toUInt64() const { try { return std::stoull(m_string); } catch(...) { return std::nullopt; } }
        std::optional<float> toFloat() const { try { return std::stof(m_string); } catch(...) { return std::nullopt; } }
        std::optional<double> toDouble() const { try { return std::stod(m_string); } catch(...) { return std::nullopt; } }
        const BufferOut& writeTo(const BufferOut& buffer, DataFormat format = UTF8, bool isNullAdded = true,
                                 sizeOption howMany = std::nullopt, sizeOption maxLen = std::nullopt) const;
        const BufferOut& writeUTF8(const BufferOut& buffer, bool isNullAdded = true, sizeOption howMany = std::nullopt, sizeOption maxLen = std::nullopt) const;
        const BufferOut& writeUTF16(const BufferOut& buffer, bool isNullAdded = true, bool isBigEndian = DataFormat::defaultEndian,
                                    sizeOption howMany = std::nullopt, sizeOption maxLen = std::nullopt) const;
        const BufferOut& writeUTF32(const BufferOut& buffer, bool isNullAdded = true, bool isBigEndian = DataFormat::defaultEndian,
                                    sizeOption howMany = std::nullopt, sizeOption maxLen = std::nullopt) const;
        bool isAlphaNumeric(size_type startPos = 0, sizeOption howMany = std::nullopt) const;
        bool isAlpha(size_type startPos = 0, sizeOption howMany = std::nullopt) const;
        bool isNumeric(size_type startPos = 0, sizeOption howMany = std::nullopt) const;
        std::strong_ordering compare(const String& ref) const;
        sizeOption find(const String& toFind, size_type startPos = 0) const;
        sizeOption findIf(const Filter& filter) const;
        bool contains(const String& toFind) const { return find(toFind).has_value(); }
        bool startsWith(const String& toFind) const { return m_string.starts_with(toFind.m_string); }
        bool endsWith(const String& toFind) const { return m_string.ends_with(toFind.m_string); }
        sizeOption findFirstOf(const String& toFind, size_type startPos = 0) const;
        sizeOption findFirstNotOf(const String& toFind, size_type startPos = 0) const;
        sizeOption findLastOf(const String& toFind, sizeOption lastPos = std::nullopt) const;
        sizeOption findLastNotOf(const String& toFind, sizeOption lastPos = std::nullopt) const;
        sizeOption rfind(const String& toFind, sizeOption lastPos = std::nullopt) const;
 
        //MARK: - Functions (mutating)
 
        void reserve(size_type newSize);
        void resize(size_type newSize, const String& padding = "");
        void clear() { m_string.clear(); }
        void forEach(const Function& func);
        String& assign(const String& source);
        size_type assign(const char* source, sizeOption byteCount = std::nullopt, sizeOption charCount = std::nullopt, DataFormat format = DataFormat{});
        String& append(const String& source);
        String& append(char source) {
            if (auto uniChar = getUnicodeChar(&source, 1, ISO8859_1); uniChar.second > 0)
                append(uniChar.first);
            return *this;
        }
        String& append(char32_t source) {
            const char32_t* sourcePtr = &source;
            if (auto sourceStr = fromUnicode(sourcePtr, Memory::defaultEndian, 1); sourceStr)
                m_string += *sourceStr;
            return *this;
        }
        String& insert(size_type pos, const String& source, size_type start = 0, sizeOption howMany = std::nullopt);
        String& replace(sizeOption pos, sizeOption num, const String& source, size_type start = 0, sizeOption howMany = std::nullopt);
        String& replaceAll(const String& toFind, const String& replacement = String());
        String& replaceIf(const Filter& filter, const String& replacement = String());
        String& replaceAnyOf(const String& charsToFind, const String& replacement = String());
        String& erase(size_type pos = 0, sizeOption howMany = std::nullopt);
        void popBack();
        String& padRight(size_type length, const String& repeat = " ");
        String& padLeft(size_type length, const String& repeat = " ");
        
    private:
        std::string m_string;
    };
    
        
    inline String operator+(const String& str1, const String& str2) {
        return String{str1}.append(str2);
    }
    
    
    inline bool isWhiteSpace(char32_t uniChar) {
        switch (uniChar) {
        case U' ': case U'\t': case U'\r': case U'\n':
            return true;
        default:
            return false;
        }
    }
    
    
    inline bool isLineEnding(char32_t uniChar) {
        return ((uniChar == U'\r') || (uniChar == U'\n'));
    }
    
    
    inline bool isDigit(char32_t uniChar) {
        return ((uniChar <= U'9') && (uniChar >= U'0'));
    }
    
    
    inline bool isNumeric(char32_t uniChar) {
        return (isDigit(uniChar) || (uniChar == U'-'));
    }
    
    
    inline bool isFloat(char32_t uniChar) {
        return (isNumeric(uniChar) || (uniChar == U'.'));
    }
 
}
 
template <>
struct std::hash<active::utility::String> {
    std::size_t operator()(const active::utility::String& k) const {
        return hash<std::string>()(k);  //Just use the hashing provided by std::string
    }
};
 
#endif  //ACTIVE_UTILITY_STRING