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 <bit>
#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 <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::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, str actually contains an utf8-encoded string.
                        return static_cast<char>(
                            static_cast<unsigned char>(std::toupper(c)));
                    });
    }
};
 
#else
 
// is missing from the unicodelib headers
#include <cstdint>
 
#include <unicodelib.h>
#include <unicodelib_encodings.h>
 
template <>
struct mimicpp::string_case_fold_converter<char>
{
    template <detail::compatible_string_view_with<char> String>
    [[nodiscard]]
    constexpr auto operator ()(String&& str) const
    {
        return unicode::utf8::encode(
            unicode::to_case_fold(
                unicode::utf8::decode(
                    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 unicode::to_wstring(
            unicode::to_case_fold(
                unicode::to_utf32(
                    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
    {
        const std::string caseFolded = std::invoke(
            mimicpp::string_case_fold_converter<char>{},
            std::string_view{
                std::bit_cast<const char*>(std::ranges::data(str)),
                std::ranges::size(str)
            });
 
        return std::u8string{
            caseFolded.cbegin(),
            caseFolded.cend()
        };
    }
};
 
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 unicode::utf16::encode(
            unicode::to_case_fold(
                unicode::utf16::decode(
                    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 unicode::to_case_fold(
            std::u32string_view{
                std::ranges::data(str),
                std::ranges::size(str)
            });
    }
};
 
#endif
 
#endif