String.hpp

Go to the documentation of this file.

// //          Copyright Dominic (DNKpp) Koepke 2024 - 2024.
// // 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++/Utility.hpp"
 
#include <concepts>
#include <functional>
#include <ranges>
#include <string>
#include <string_view>
#include <type_traits>
 
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 <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 <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
 
#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
 
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