String.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Allocator.hpp"
 
#include <iosfwd>
#include <string>
#include <string_view>
 
#if __has_include(<fmt/format.h>)
#define CE_HAS_FMT 1
#include <fmt/format.h>
#endif
 
namespace CeresEngine {
 
    template<typename T, typename CharTraits = std::char_traits<T>, typename RawAllocator = DefaultAllocator> class BasicString;
    template<typename T, typename CharTraits = std::char_traits<T>> class BasicStringView;
 
    template<typename Self, typename T, typename CharTraits>
    class BasicStringBase {
    private:
        using StringType = BasicString<T, CharTraits>;
        using StringViewType = BasicStringView<T, CharTraits>;
 
    public:
        [[nodiscard]] bool contains(const BasicStringView<T, CharTraits>& text) const;
 
    public:
        template<typename Func> void split(const StringViewType delimiter, Func&& func, bool skipEmpty = false) const;
        template<typename Func> void split(const T delimiter, Func&& func) const;
 
    public: // Parsing & formatting
        template<typename U, typename... Args> [[nodiscard]] U to(Args&&... args) const;
 
    private:
        StringViewType view() const { return StringViewType(self()); }
 
        const Self& self() const { return static_cast<const Self&>(*this); }
 
        Self& self() { return static_cast<Self&>(*this); }
    };
 
    template<typename T, typename CharTraits, typename RawAllocator>
    class BasicString : public std::basic_string<T, CharTraits, StdAllocator<T, RawAllocator>>, public BasicStringBase<BasicString<T, CharTraits, RawAllocator>, T, CharTraits> {
        using super = std::basic_string<T, CharTraits, StdAllocator<T, RawAllocator>>;
 
    public:
        CE_EXPLICIT(false) BasicString(const super& other) : super(other) {}
 
        CE_EXPLICIT(false) BasicString(super&& other) : super(std::move(other)) {}
 
        BasicString(const BasicString& str) = default;
        BasicString(BasicString&& str) noexcept = default;
 
        using super::super;
        using super::operator=;
 
        BasicString& operator=(const BasicString& str) = default;
        BasicString& operator=(BasicString&& str) = default;
 
#if defined(CE_HAS_FMT)
    public: // Formatting
        template<typename... Args> inline BasicString format(Args&&... args) {
            return fromString(this->get_allocator(), *this, std::forward<Args>(args)...);
        }
 
        template<typename S, typename... Args> requires(std::is_same_v<fmt::char_t<S>, T>)
        [[nodiscard]]static inline BasicString fromFormat(const S& format, Args&&... args) {
            BasicString string;
            string.reserve(fmt::formatted_size(fmt::detail::to_string_view(format), args...));
            fmt::format_to(std::back_inserter(string), fmt::detail::to_string_view(format), std::forward<Args>(args)...);
            return string;
        }
 
        template<typename S, typename... Args> requires(std::is_same_v<fmt::char_t<S>, T>)
        [[nodiscard]]static inline BasicString fromFormat(RawAllocator& allocator, const S& format, Args&&... args) {
            BasicString string(allocator);
            string.reserve(fmt::formatted_size(fmt::detail::to_string_view(format), args...));
            fmt::format_to(std::back_inserter(string), fmt::detail::to_string_view(format), std::forward<Args>(args)...);
            return string;
        }
#endif
 
    public: // Parsing & formatting
        template<typename U, typename... Args> [[nodiscard]] static decltype(auto) from(U value, Args&&... args);
 
    public:
        CE_EXPLICIT(false) operator const super&() const { return *this; }
 
        CE_EXPLICIT(false) operator super&() { return *this; }
    };
 
    template<typename T, typename CharTraits, typename RawAllocator>
    BasicString<T, CharTraits, RawAllocator> operator+(const BasicString<T, CharTraits, RawAllocator>& lhs, const T* rhs) {
        using super = std::basic_string<T, CharTraits, StdAllocator<T, RawAllocator>>;
        return BasicString<T, CharTraits, RawAllocator>(static_cast<const super&>(lhs) + rhs);
    }
 
    template<typename T, typename CharTraits, typename RawAllocator>
    BasicString<T, CharTraits, RawAllocator> operator+(const T* lhs, const BasicString<T, CharTraits, RawAllocator>& rhs) {
        using super = std::basic_string<T, CharTraits, StdAllocator<T, RawAllocator>>;
        return BasicString<T, CharTraits, RawAllocator>(lhs + static_cast<const super&>(rhs));
    }
 
    template<typename T, typename CharTraits = std::char_traits<T>> using TemporaryBasicString = BasicString<T, CharTraits, TemporaryAllocator>;
 
    //    template<typename T, typename CharTraits = std::char_traits<T>> using BasicStringView = std::basic_string_view<T, CharTraits>;
    template<typename T, typename CharTraits> class BasicStringView : public std::basic_string_view<T, CharTraits>, public BasicStringBase<BasicStringView<T, CharTraits>, T, CharTraits> {
        using super = std::basic_string_view<T, CharTraits>;
 
    public:
        template<typename RawAllocator> constexpr BasicStringView(const BasicString<T, CharTraits, RawAllocator>& string) : super(string) {}
 
        template<typename Allocator> CE_EXPLICIT(false) constexpr BasicStringView(const std::basic_string<T, CharTraits, Allocator>& other) : super(other) {}
 
        CE_EXPLICIT(false) constexpr BasicStringView(const super& other) : super(other) {}
 
        CE_EXPLICIT(false) constexpr BasicStringView(super&& other) : super(std::move(other)) {}
 
        using super::super;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename Self, typename T, typename CharTraits>
    bool BasicStringBase<Self, T, CharTraits>::contains(const BasicStringView<T, CharTraits>& text) const {
        return self().find(text) != Self::npos;
    }
 
    // ---------------------------------------------------------------------------------------------
 
    using String = BasicString<char>;
 
    using TemporaryString = TemporaryBasicString<char>;
 
    using WString = BasicString<wchar_t>;
 
    using TemporaryWString = TemporaryBasicString<wchar_t>;
 
    using U16String = BasicString<char16_t>;
 
    using TemporaryU16String = TemporaryBasicString<char16_t>;
 
    using U32String = BasicString<char32_t>;
 
    using TemporaryU32String = TemporaryBasicString<char32_t>;
 
    // ---------------------------------------------------------------------------------------------
 
    using StringView = BasicStringView<char>;
 
    using WStringView = BasicStringView<wchar_t>;
 
    using U16StringView = BasicStringView<char16_t>;
 
    using U32StringView = BasicStringView<char32_t>;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> struct CiCharTraits : public std::char_traits<T> {
        static bool eq(T c1, T c2) { return std::toupper(c1) == std::toupper(c2); }
        static bool ne(T c1, T c2) { return std::toupper(c1) != std::toupper(c2); }
        static bool lt(T c1, T c2) { return std::toupper(c1) < std::toupper(c2); }
 
        static int compare(const T* s1, const T* s2, size_t n) {
            while(n-- != 0) {
                if(std::toupper(*s1) < std::toupper(*s2)) {
                    return -1;
                }
 
                if(std::toupper(*s1) > std::toupper(*s2)) {
                    return 1;
                }
 
                ++s1;
                ++s2;
            }
            return 0;
        }
 
        static const T* find(const T* s, int n, T a) {
            const auto ua = std::toupper(a);
            while(n-- > 0) {
                if(std::toupper(*s) == ua) {
                    return s;
                }
                s++;
            }
            return nullptr;
        }
    };
 
    template<typename T, typename RawAllocator = DefaultAllocator> using CiBasicString = BasicString<T, CiCharTraits<T>, RawAllocator>;
 
    template<typename T> using TemporaryCiBasicString = BasicString<T, CiCharTraits<T>, TemporaryAllocator>;
 
    template<typename T> using CiBasicStringView = BasicStringView<T, CiCharTraits<T>>;
 
    // ---------------------------------------------------------------------------------------------
 
    using CiString = CiBasicString<char>;
 
    using TemporaryCiString = TemporaryCiBasicString<char>;
 
    using CiWString = CiBasicString<wchar_t>;
 
    using TemporaryCiWString = TemporaryCiBasicString<wchar_t>;
 
    using CiU16String = CiBasicString<char16_t>;
 
    using TemporaryCiU16String = TemporaryCiBasicString<char16_t>;
 
    using CiU32String = CiBasicString<char32_t>;
 
    using TemporaryCiU32String = TemporaryCiBasicString<char32_t>;
 
    // ---------------------------------------------------------------------------------------------
 
    using CiStringView = CiBasicStringView<char>;
 
    using CiWStringView = CiBasicStringView<wchar_t>;
 
    using CiU16StringView = CiBasicStringView<char16_t>;
 
    using CiU32StringView = CiBasicStringView<char32_t>;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T, typename RawAllocator> CiBasicStringView<T> toCaseInsensitive(const BasicString<T, RawAllocator>& view) {
        return CiBasicStringView<T>(view.data(), view.length());
    }
    template<typename T, typename RawAllocator> CiBasicStringView<T> toCaseInsensitive(const CiBasicString<T, RawAllocator>& view) {
        return CiBasicStringView<T>(view.data(), view.length());
    }
    template<typename T> CiBasicStringView<T> toCaseInsensitive(BasicStringView<T> view) { return CiBasicStringView<T>(view.data(), view.length()); }
    template<typename T> CiBasicStringView<T> toCaseInsensitive(CiBasicStringView<T> view) { return view; }
 
    template<typename T, typename RawAllocator> BasicStringView<T> toCaseSensitive(const CiBasicString<T, RawAllocator>& view) {
        return BasicStringView<T>(view.data(), view.length());
    }
    template<typename T, typename CharTraits, typename RawAllocator> BasicStringView<T> toCaseSensitive(const BasicString<T, CharTraits, RawAllocator>& view) {
        return BasicStringView<T>(view.data(), view.length());
    }
    template<typename T> BasicStringView<T> toCaseSensitive(CiBasicStringView<T> view) { return BasicStringView<T>(view.data(), view.length()); }
    template<typename T> BasicStringView<T> toCaseSensitive(BasicStringView<T> view) { return view; }
 
    // ---------------------------------------------------------------------------------------------
 
    template<size_t N> struct StringLiteral {
        char value[N];
        size_t length = N;
        constexpr StringLiteral(const char (&str)[N]) { std::copy_n(str, N, value); }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    using namespace std::string_literals;
    using namespace std::string_view_literals;
 
    inline String operator"" _s(const char* str, const size_t length) { return String(str, length); }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> struct StringConversion;
 
    template<> struct StringConversion<bool> {
        static String toString(bool value);
        static bool fromString(StringView string, bool defaultValue = false);
    };
 
#define CE_STRING_CONVERSION_DECL(T)                                              \
    template<> struct StringConversion<T> {                                       \
        static String toString(T val, unsigned short width = 0, char fill = ' '); \
        static T fromString(StringView string, T defaultValue = 0);               \
    }
    CE_STRING_CONVERSION_DECL(Int8);
    CE_STRING_CONVERSION_DECL(UInt8);
    CE_STRING_CONVERSION_DECL(Int16);
    CE_STRING_CONVERSION_DECL(UInt16);
    CE_STRING_CONVERSION_DECL(Int32);
    CE_STRING_CONVERSION_DECL(UInt32);
    CE_STRING_CONVERSION_DECL(Int64);
    CE_STRING_CONVERSION_DECL(UInt64);
    CE_STRING_CONVERSION_DECL(float);
    CE_STRING_CONVERSION_DECL(double);
#if !CE_COMPILER_GNUC
    CE_STRING_CONVERSION_DECL(unsigned long);
#endif
#undef CE_STRING_CONVERSION_DECL
 
    template<typename C, typename RawAllocator> struct StringConversion<BasicString<C, RawAllocator>> {
        using T = BasicString<C, RawAllocator>;
 
        static String toString(const T& value) { return String(value); }
        static T fromString(StringView string, const T& defaultValue = false) { return T(string); }
    };
 
    namespace impl {
        template<typename T, typename U> concept CSame = std::is_same_v<T, U>;
 
        template<typename T> concept ToStringMemberCallable = requires(const T& value) { value.toString(); };
    } // namespace impl
 
    template<impl::ToStringMemberCallable T> struct StringConversion<T> {
        static decltype(auto) toString(const T& value) { return value.toString(); }
    };
 
    template<typename T> concept ConvertibleToString = requires(T value) { StringConversion<T>::toString(value); };
 
    template<typename T, typename CharTraits, typename RawAllocator>
    template<typename U, typename... Args>
    [[nodiscard]] decltype(auto) BasicString<T, CharTraits, RawAllocator>::from(U value, Args&&... args) {
        return StringConversion<U>::toString(value, std::forward<Args>(args)...);
    }
 
    template<typename T>
    concept ConvertibleFromString = requires(StringView string) {
                                        { StringConversion<T>::fromString(string) } -> impl::CSame<T>;
                                    };
 
    template<typename Self, typename T, typename CharTraits>
    template<typename U, typename... Args>
    [[nodiscard]] U BasicStringBase<Self, T, CharTraits>::to(Args&&... args) const {
        return StringConversion<U>::fromString(view(), std::forward<Args>(args)...);
    }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename Self, typename T, typename CharTraits>
    template<typename Func>
    void BasicStringBase<Self, T, CharTraits>::split(const StringViewType delimiter, Func&& func, bool skipEmpty) const {
        using SizeT = typename Self::size_type;
        StringViewType view = self();
 
        SizeT indexCommaToLeftOfColumn = 0;
        SizeT indexCommaToRightOfColumn = -1;
 
        for(SizeT i = 0; i < view.size(); i++) {
            if(view.substr(i, delimiter.size()) == delimiter) {
                indexCommaToLeftOfColumn = indexCommaToRightOfColumn;
                indexCommaToRightOfColumn = i;
 
                const SizeT index = indexCommaToLeftOfColumn + 1;
                const SizeT length = indexCommaToRightOfColumn - index;
                if(skipEmpty && length == 0) {
                    continue;
                }
 
                func(view.substr(index, length));
                i += delimiter.size() - 1;
            }
        }
 
        const SizeT index = indexCommaToLeftOfColumn + 1;
        const SizeT length = view.size() - indexCommaToRightOfColumn - 1;
 
        if(skipEmpty && length == 0) {
            return;
        }
 
        func(view.substr(index, length));
    }
 
    template<typename Self, typename T, typename CharTraits>
    template<typename Func>
    void BasicStringBase<Self, T, CharTraits>::split(T delimiter, Func&& func) const {
        using SizeT = typename Self::size_type;
        StringViewType view = self();
 
        SizeT indexCommaToLeftOfColumn = SizeT(0);
        SizeT indexCommaToRightOfColumn = SizeT(-1);
 
        for(SizeT i = 0; i < view.size(); i++) {
            if(view.at(i) == delimiter) {
                indexCommaToLeftOfColumn = indexCommaToRightOfColumn;
                indexCommaToRightOfColumn = i;
 
                const SizeT index = indexCommaToLeftOfColumn + 1;
                const SizeT length = indexCommaToRightOfColumn - index;
 
                func(view.substr(index, length));
            }
        }
 
        func(view.substr(indexCommaToRightOfColumn + 1, view.size() - indexCommaToRightOfColumn - 1));
    }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T, typename RawAllocator> inline BasicString<T, RawAllocator> operator+(const BasicString<T, RawAllocator>& lhs, BasicStringView<T> rhs) {
        BasicString<T, RawAllocator> string(lhs);
        string.append(rhs);
        return string;
    }
 
    template<typename T, typename RawAllocator> inline BasicString<T, RawAllocator> operator+(BasicString<T, RawAllocator>&& lhs, BasicStringView<T> rhs) {
        return std::move(lhs.append(rhs));
    }
 
} // namespace Cere