String.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef MIMICPP_STRING_HPP
#define MIMICPP_STRING_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/utilities/Concepts.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <concepts>
    #include <functional>
    #include <ranges>
    #include <string>
    #include <string_view>
    #include <type_traits>
#endif
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{


    template <typename T>
    struct is_character
        : public std::false_type
    {
    };

    template <typename T>
    inline constexpr bool is_character_v{is_character<T>::value};

    template <>
    struct is_character<char>
        : public std::true_type
    {
    };

    template <>
    struct is_character<signed char>
        : public std::true_type
    {
    };

    template <>
    struct is_character<unsigned char>
        : public std::true_type
    {
    };

    template <>
    struct is_character<wchar_t>
        : public std::true_type
    {
    };

    template <>
    struct is_character<char8_t>
        : public std::true_type
    {
    };

    template <>
    struct is_character<char16_t>
        : public std::true_type
    {
    };

    template <>
    struct is_character<char32_t>
        : public std::true_type
    {
    };



    template <util::satisfies<is_character> Char>
    [[maybe_unused]]
    inline constexpr StringViewT string_literal_prefix{};

    template <>
    [[maybe_unused]]
    inline constexpr StringViewT string_literal_prefix<char>{};

    template <>
    [[maybe_unused]]
    inline constexpr StringViewT string_literal_prefix<wchar_t>{"L"};

    template <>
    [[maybe_unused]]
    inline constexpr StringViewT string_literal_prefix<char8_t>{"u8"};

    template <>
    [[maybe_unused]]
    inline constexpr StringViewT string_literal_prefix<char16_t>{"u"};

    template <>
    [[maybe_unused]]
    inline constexpr StringViewT string_literal_prefix<char32_t>{"U"};



    template <typename T>
    using string_view_t = decltype(string_traits<std::remove_cvref_t<T>>::view(std::declval<T&>()));

    template <typename T>
    using string_char_t = typename string_traits<std::remove_cvref_t<T>>::char_t;

    template <typename T>
        requires std::is_pointer_v<T>
              && is_character_v<std::remove_cv_t<std::remove_pointer_t<T>>>
    struct string_traits<T>
    {
        using char_t = std::remove_const_t<std::remove_pointer_t<T>>;
        using view_t = std::basic_string_view<char_t>;
 
        [[nodiscard]]
        static constexpr view_t view(const std::remove_pointer_t<T>* str) noexcept
        {
            return view_t{str};
        }
    };

    template <typename T>
        requires std::is_array_v<T>
    struct string_traits<T>
        : public string_traits<std::remove_extent_t<T>*>
    {
    };

    template <typename Char, typename Traits, typename Allocator>
    struct string_traits<std::basic_string<Char, Traits, Allocator>>
    {
        using char_t = Char;
        using string_t = std::basic_string<Char, Traits, Allocator>;
        using view_t = std::basic_string_view<Char, Traits>;
 
        [[nodiscard]]
        static constexpr view_t view(const string_t& str) noexcept
        {
            return view_t{str};
        }
    };

    template <typename Char, typename Traits>
    struct string_traits<std::basic_string_view<Char, Traits>>
    {
        using char_t = Char;
        using view_t = std::basic_string_view<Char, Traits>;
 
        [[nodiscard]]
        static constexpr view_t view(view_t str) noexcept
        {
            return str;
        }
    };


    template <typename T>
    concept string = requires {
        requires is_character_v<string_char_t<T>>;
        requires std::regular<string_char_t<T>>;
        requires std::ranges::contiguous_range<string_view_t<T>>;
        requires std::ranges::sized_range<string_view_t<T>>;
        requires std::ranges::borrowed_range<string_view_t<T>>;
        requires std::same_as<
            string_char_t<T>,
            std::ranges::range_value_t<string_view_t<T>>>;
    };


    template <util::satisfies<is_character> Char>
    struct string_case_fold_converter;

    template <typename String>
    concept case_foldable_string =
        string<String>
        && requires(const string_case_fold_converter<string_char_t<String>> converter, string_view_t<String> view) {
               { std::invoke(converter, std::move(view)) } -> std::ranges::forward_range;
           } && requires(std::invoke_result_t<string_case_fold_converter<string_char_t<String>>, string_view_t<String>> normalized) {
               requires std::same_as<
                   string_char_t<String>,
                   std::ranges::range_value_t<decltype(normalized)>>;
           };
}
 
namespace mimicpp::detail
{
    template <typename View, typename Char>
    concept compatible_string_view_with = is_character_v<Char>
                                       && std::ranges::borrowed_range<View>
                                       && std::ranges::contiguous_range<View>
                                       && std::ranges::sized_range<View>
                                       && std::same_as<Char, std::ranges::range_value_t<View>>;
}
 
#ifndef MIMICPP_CONFIG_EXPERIMENTAL_UNICODE_STR_MATCHER

template <>
struct mimicpp::string_case_fold_converter<char>
{
    template <detail::compatible_string_view_with<char> String>
    [[nodiscard]]
    constexpr auto operator()(String&& str) const
    {
        return std::views::all(std::forward<String>(str))
             | std::views::transform(
                   [](const char c) noexcept {
                       // see notes of https://en.cppreference.com/w/cpp/string/byte/toupper
                       // This approach will fail, if str actually contains an utf8-encoded string.
                       return static_cast<char>(
                           static_cast<unsigned char>(std::toupper(c)));
                   });
    }
};
 
#else
 
    #ifndef MIMICPP_DETAIL_IS_MODULE
        #if __has_include(<uni_algo/case.h>) \
            && __has_include(<uni_algo/conv.h>)
            #include <uni_algo/case.h>
            #include <uni_algo/conv.h>
        #else
            #error "Unable to find uni_algo includes."
        #endif
    #endif

template <>
struct mimicpp::string_case_fold_converter<char>
{
    template <detail::compatible_string_view_with<char> String>
    [[nodiscard]]
    constexpr auto operator()(String&& str) const
    {
        return una::cases::to_casefold_utf8(
            std::string_view{
                std::ranges::data(str),
                std::ranges::size(str)});
    }
};

template <>
struct mimicpp::string_case_fold_converter<wchar_t>
{
    template <detail::compatible_string_view_with<wchar_t> String>
    [[nodiscard]]
    constexpr auto operator()(String&& str) const
    {
        return una::cases::to_casefold_utf16(
            std::wstring_view{
                std::ranges::data(str),
                std::ranges::size(str)});
    }
};

template <>
struct mimicpp::string_case_fold_converter<char8_t>
{
    template <detail::compatible_string_view_with<char8_t> String>
    [[nodiscard]]
    constexpr auto operator()(String&& str) const
    {
        return una::cases::to_casefold_utf8(
            std::u8string_view{
                std::ranges::data(str),
                std::ranges::size(str)});
    }
};

template <>
struct mimicpp::string_case_fold_converter<char16_t>
{
    template <detail::compatible_string_view_with<char16_t> String>
    [[nodiscard]]
    constexpr auto operator()(String&& str) const
    {
        return una::cases::to_casefold_utf16(
            std::u16string_view{
                std::ranges::data(str),
                std::ranges::size(str)});
    }
};

template <>
struct mimicpp::string_case_fold_converter<char32_t>
{
    template <detail::compatible_string_view_with<char32_t> String>
    [[nodiscard]]
    constexpr auto operator()(String&& str) const
    {
        return una::utf8to32<char8_t, char32_t>(
            una::cases::to_casefold_utf8(
                una::utf32to8u(
                    std::u32string_view{
                        std::ranges::data(str),
                        std::ranges::size(str)})));
    }
};
 
#endif
 
#endif