string.hpp

#pragma once
 
#include "fly/concepts/concepts.hpp"
#include "fly/types/string/concepts.hpp"
#include "fly/types/string/detail/classifier.hpp"
#include "fly/types/string/detail/converter.hpp"
#include "fly/types/string/detail/format_context.hpp"
#include "fly/types/string/detail/format_parameters.hpp"
#include "fly/types/string/detail/format_parse_context.hpp"
#include "fly/types/string/detail/format_specifier.hpp"
#include "fly/types/string/detail/format_string.hpp"
#include "fly/types/string/detail/traits.hpp"
#include "fly/types/string/detail/unicode.hpp"
#include "fly/types/string/formatters.hpp"
#include "fly/types/string/literals.hpp"
 
#include <algorithm>
#include <array>
#include <cctype>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <ios>
#include <iterator>
#include <optional>
#include <random>
#include <string>
#include <type_traits>
#include <vector>
 
namespace fly {
 
template <StandardCharacter CharType>
class BasicString;
 
using String = BasicString<char>;
using WString = BasicString<wchar_t>;
using String8 = BasicString<char8_t>;
using String16 = BasicString<char16_t>;
using String32 = BasicString<char32_t>;
 
template <StandardCharacter CharType>
class BasicString
{
    using traits = detail::BasicStringTraits<CharType>;
    using unicode = detail::BasicUnicode<CharType>;
 
public:
    using string_type = typename traits::string_type;
    using size_type = typename traits::size_type;
    using char_type = typename traits::char_type;
    using view_type = typename traits::view_type;
    using int_type = typename traits::int_type;
    using codepoint_type = typename traits::codepoint_type;
 
    template <typename... ParameterTypes>
    using FormatString =
        detail::BasicFormatString<char_type, std::type_identity_t<ParameterTypes>...>;
 
    template <StandardStringLike T>
    static constexpr size_type size(T &&value);
 
    static constexpr bool is_alpha(char_type ch);
 
    static constexpr bool is_upper(char_type ch);
 
    static constexpr bool is_lower(char_type ch);
 
    static constexpr char_type to_upper(char_type ch);
 
    static constexpr char_type to_lower(char_type ch);
 
    static constexpr bool is_digit(char_type ch);
 
    static constexpr bool is_x_digit(char_type ch);
 
    static constexpr bool is_space(char_type ch);
 
    static std::vector<string_type> split(view_type input, char_type delimiter);
 
    static std::vector<string_type> split(view_type input, char_type delimiter, size_type count);
 
    static void trim(string_type &target);
 
    static void replace_all(string_type &target, view_type search, char_type replace);
 
    static void replace_all(string_type &target, view_type search, view_type replace);
 
    static void remove_all(string_type &target, view_type search);
 
    static bool wildcard_match(view_type source, view_type search);
 
    static bool validate(view_type value);
 
    template <typename IteratorType>
    static std::optional<codepoint_type>
    decode_codepoint(IteratorType &it, const IteratorType &end);
 
    static std::optional<string_type> encode_codepoint(codepoint_type codepoint);
 
    template <char UnicodePrefix = 'U'>
    requires fly::UnicodePrefixCharacter<UnicodePrefix>
    static std::optional<string_type> escape_all_codepoints(view_type value);
 
    template <char UnicodePrefix = 'U', typename IteratorType>
    requires fly::UnicodePrefixCharacter<UnicodePrefix>
    static std::optional<string_type> escape_codepoint(IteratorType &it, const IteratorType &end);
 
    static std::optional<string_type> unescape_all_codepoints(view_type value);
 
    template <typename IteratorType>
    static std::optional<string_type> unescape_codepoint(IteratorType &it, const IteratorType &end);
 
    static string_type generate_random_string(size_type length);
 
    template <typename... ParameterTypes>
    static string_type
    format(FormatString<ParameterTypes...> &&fmt, ParameterTypes &&...parameters);
 
    template <typename OutputIterator, typename... ParameterTypes>
    static void format_to(
        OutputIterator output,
        FormatString<ParameterTypes...> &&fmt,
        ParameterTypes &&...parameters);
 
    template <typename... Args>
    static string_type join(char_type separator, Args &&...args);
 
    template <typename T>
    static std::optional<T> convert(const string_type &value);
 
private:
    template <typename T, typename... Args>
    static void join_internal(string_type &result, char_type separator, T &&value, Args &&...args);
 
    template <typename T>
    static void join_internal(string_type &result, char_type separator, T &&value);
 
    static constexpr const char_type *s_alpha_num =
        FLY_STR(char_type, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
 
    static constexpr size_type s_alpha_num_length =
        std::char_traits<char_type>::length(s_alpha_num);
 
    static constexpr const auto s_left_brace = FLY_CHR(char_type, '{');
    static constexpr const auto s_right_brace = FLY_CHR(char_type, '}');
};
 
//==================================================================================================
template <StandardCharacter CharType>
template <StandardStringLike T>
constexpr auto BasicString<CharType>::size(T &&value) -> size_type
{
    return detail::BasicClassifier<char_type>::size(std::forward<T>(value));
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr bool BasicString<CharType>::is_alpha(char_type ch)
{
    return detail::BasicClassifier<char_type>::is_alpha(ch);
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr bool BasicString<CharType>::is_upper(char_type ch)
{
    return detail::BasicClassifier<char_type>::is_upper(ch);
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr bool BasicString<CharType>::is_lower(char_type ch)
{
    return detail::BasicClassifier<char_type>::is_lower(ch);
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr bool BasicString<CharType>::is_digit(char_type ch)
{
    return detail::BasicClassifier<char_type>::is_digit(ch);
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr auto BasicString<CharType>::to_upper(char_type ch) -> char_type
{
    return detail::BasicClassifier<char_type>::to_upper(ch);
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr auto BasicString<CharType>::to_lower(char_type ch) -> char_type
{
    return detail::BasicClassifier<char_type>::to_lower(ch);
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr bool BasicString<CharType>::is_x_digit(char_type ch)
{
    return detail::BasicClassifier<char_type>::is_x_digit(ch);
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr bool BasicString<CharType>::is_space(char_type ch)
{
    return detail::BasicClassifier<char_type>::is_space(ch);
}
 
//==================================================================================================
template <StandardCharacter CharType>
auto BasicString<CharType>::split(view_type input, char_type delimiter) -> std::vector<string_type>
{
    return split(input, delimiter, 0);
}
 
//==================================================================================================
template <StandardCharacter CharType>
auto BasicString<CharType>::split(view_type input, char_type delimiter, size_type count)
    -> std::vector<string_type>
{
    std::vector<string_type> elements;
    string_type item;
 
    size_type start = 0;
    size_type end = input.find(delimiter);
 
    auto push_item = [&elements, &count, &delimiter](view_type str) {
        if (!str.empty())
        {
            if ((count > 0) && (elements.size() == count))
            {
                elements.back() += delimiter;
                elements.back() += str;
            }
            else
            {
                elements.push_back(string_type(str));
            }
        }
    };
 
    while (end != string_type::npos)
    {
        item = input.substr(start, end - start);
        push_item(item);
 
        start = end + 1;
        end = input.find(delimiter, start);
    }
 
    item = input.substr(start, end);
    push_item(item);
 
    return elements;
}
 
//==================================================================================================
template <StandardCharacter CharType>
void BasicString<CharType>::trim(string_type &target)
{
    auto is_non_space = [](auto ch) {
        return !is_space(ch);
    };
 
    // Remove leading whitespace.
    target.erase(target.begin(), std::find_if(target.begin(), target.end(), is_non_space));
 
    // Remove trailing whitespace.
    target.erase(std::find_if(target.rbegin(), target.rend(), is_non_space).base(), target.end());
}
 
//==================================================================================================
template <StandardCharacter CharType>
void BasicString<CharType>::replace_all(string_type &target, view_type search, char_type replace)
{
    size_type index = target.find(search);
 
    while (!search.empty() && (index != string_type::npos))
    {
        target.replace(index, search.size(), 1, replace);
        index = target.find(search);
    }
}
 
//==================================================================================================
template <StandardCharacter CharType>
void BasicString<CharType>::replace_all(string_type &target, view_type search, view_type replace)
{
    size_type index = target.find(search);
 
    while (!search.empty() && (index != string_type::npos))
    {
        target.replace(index, search.size(), replace);
        index = target.find(search);
    }
}
 
//==================================================================================================
template <StandardCharacter CharType>
void BasicString<CharType>::remove_all(string_type &target, view_type search)
{
    replace_all(target, search, view_type {});
}
 
//==================================================================================================
template <StandardCharacter CharType>
bool BasicString<CharType>::wildcard_match(view_type source, view_type search)
{
    static constexpr char_type s_wildcard = '*';
    bool result = !search.empty();
 
    const std::vector<string_type> segments = split(search, s_wildcard);
    size_type index = 0;
 
    if (!segments.empty())
    {
        if (result && (search.front() != s_wildcard))
        {
            result = source.starts_with(segments.front());
        }
        if (result && (search.back() != s_wildcard))
        {
            result = source.ends_with(segments.back());
        }
 
        for (auto it = segments.begin(); result && (it != segments.end()); ++it)
        {
            index = source.find(*it, index);
 
            if (index == string_type::npos)
            {
                result = false;
            }
        }
    }
 
    return result;
}
 
//==================================================================================================
template <StandardCharacter CharType>
inline bool BasicString<CharType>::validate(view_type value)
{
    auto it = value.cbegin();
    const auto end = value.cend();
 
    return unicode::validate_encoding(it, end);
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <typename IteratorType>
inline auto BasicString<CharType>::decode_codepoint(IteratorType &it, const IteratorType &end)
    -> std::optional<codepoint_type>
{
    return unicode::decode_codepoint(it, end);
}
 
//==================================================================================================
template <StandardCharacter CharType>
inline auto BasicString<CharType>::encode_codepoint(codepoint_type codepoint)
    -> std::optional<string_type>
{
    return unicode::encode_codepoint(codepoint);
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <char UnicodePrefix>
requires fly::UnicodePrefixCharacter<UnicodePrefix>
auto BasicString<CharType>::escape_all_codepoints(view_type value) -> std::optional<string_type>
{
    string_type result;
    result.reserve(value.size());
 
    const auto end = value.cend();
 
    for (auto it = value.cbegin(); it != end;)
    {
        if (auto escaped = escape_codepoint<UnicodePrefix>(it, end); escaped)
        {
            result += *std::move(escaped);
        }
        else
        {
            return std::nullopt;
        }
    }
 
    return result;
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <char UnicodePrefix, typename IteratorType>
requires fly::UnicodePrefixCharacter<UnicodePrefix>
inline auto BasicString<CharType>::escape_codepoint(IteratorType &it, const IteratorType &end)
    -> std::optional<string_type>
{
    return unicode::template escape_codepoint<UnicodePrefix>(it, end);
}
 
//==================================================================================================
template <StandardCharacter CharType>
auto BasicString<CharType>::unescape_all_codepoints(view_type value) -> std::optional<string_type>
{
    string_type result;
    result.reserve(value.size());
 
    const auto end = value.cend();
 
    for (auto it = value.cbegin(); it != end;)
    {
        if ((*it == '\\') && ((it + 1) != end))
        {
            switch (*(it + 1))
            {
                case FLY_CHR(char_type, 'u'):
                case FLY_CHR(char_type, 'U'):
                {
                    if (auto unescaped = unescape_codepoint(it, end); unescaped)
                    {
                        result += *std::move(unescaped);
                    }
                    else
                    {
                        return std::nullopt;
                    }
 
                    break;
                }
 
                default:
                    result += *(it++);
                    break;
            }
        }
        else
        {
            result += *(it++);
        }
    }
 
    return result;
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <typename IteratorType>
inline auto BasicString<CharType>::unescape_codepoint(IteratorType &it, const IteratorType &end)
    -> std::optional<string_type>
{
    return unicode::unescape_codepoint(it, end);
}
 
//==================================================================================================
template <StandardCharacter CharType>
auto BasicString<CharType>::generate_random_string(size_type length) -> string_type
{
    using short_distribution = std::uniform_int_distribution<short>;
 
    constexpr auto limit = static_cast<short_distribution::result_type>(s_alpha_num_length - 1);
    static_assert(limit > 0);
 
    static thread_local const auto s_now = std::chrono::system_clock::now().time_since_epoch();
    static thread_local const auto s_seed = static_cast<std::mt19937::result_type>(s_now.count());
 
    static thread_local std::mt19937 s_engine(s_seed);
    short_distribution distribution(0, limit);
 
    string_type result;
    result.reserve(length);
 
    while (length-- != 0)
    {
        result.push_back(s_alpha_num[distribution(s_engine)]);
    }
 
    return result;
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <typename... ParameterTypes>
inline auto
BasicString<CharType>::format(FormatString<ParameterTypes...> &&fmt, ParameterTypes &&...parameters)
    -> string_type
{
    string_type formatted;
    formatted.reserve(fmt.context().view().size() * 2);
 
    format_to(
        std::back_inserter(formatted),
        std::move(fmt),
        std::forward<ParameterTypes>(parameters)...);
 
    return formatted;
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <typename OutputIterator, typename... ParameterTypes>
void BasicString<CharType>::format_to(
    OutputIterator output,
    FormatString<ParameterTypes...> &&fmt,
    ParameterTypes &&...parameters)
{
    using FormatContext = detail::BasicFormatContext<OutputIterator, char_type>;
    using FormatParseContext = detail::BasicFormatParseContext<char_type>;
 
    FormatParseContext &parse_context = fmt.context();
    const view_type view = parse_context.view();
 
    if (parse_context.has_error())
    {
        format_to(
            output,
            FLY_ARR(char_type, "Ignored invalid formatter: {}"),
            parse_context.error());
 
        return;
    }
 
    auto params =
        detail::make_format_parameters<FormatContext>(std::forward<ParameterTypes>(parameters)...);
    FormatContext context(output, params);
 
    for (std::size_t pos = 0; pos < view.size();)
    {
        switch (const auto &ch = view[pos])
        {
            case s_left_brace:
                if (view[pos + 1] == s_left_brace)
                {
                    *context.out()++ = ch;
                    pos += 2;
                }
                else
                {
                    auto specifier = *std::move(fmt.next_specifier());
                    pos += specifier.m_size;
 
                    const auto parameter = context.arg(specifier.m_position);
                    parameter.format(parse_context, context, std::move(specifier));
                }
                break;
 
            case s_right_brace:
                *context.out()++ = ch;
                pos += 2;
                break;
 
            default:
                *context.out()++ = ch;
                ++pos;
                break;
        }
    }
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <typename... Args>
inline auto BasicString<CharType>::join(char_type separator, Args &&...args) -> string_type
{
    string_type result;
    join_internal(result, separator, std::forward<Args>(args)...);
 
    return result;
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <typename T, typename... Args>
inline void BasicString<CharType>::join_internal(
    string_type &result,
    char_type separator,
    T &&value,
    Args &&...args)
{
    result += format(FLY_ARR(char_type, "{}{}"), std::forward<T>(value), separator);
    join_internal(result, separator, std::forward<Args>(args)...);
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <typename T>
inline void BasicString<CharType>::join_internal(string_type &result, char_type, T &&value)
{
    result += format(FLY_ARR(char_type, "{}"), std::forward<T>(value));
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <typename T>
std::optional<T> BasicString<CharType>::convert(const string_type &value)
{
    if constexpr (StandardString<T>)
    {
        return unicode::template convert_encoding<T>(value);
    }
    else if constexpr (fly::SameAs<char_type, char>)
    {
        return detail::Converter<T>::convert(value);
    }
    else
    {
        if (auto result = unicode::template convert_encoding<std::string>(value); result)
        {
            return detail::Converter<T>::convert(*result);
        }
 
        return std::nullopt;
    }
}
 
} // namespace fly