conststr.hpp

Go to the documentation of this file.

/* MIT License
 *
 * Copyright (c) 2024 Nichts Hsu
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
 
#ifndef CONSTSTR_HPP
#define CONSTSTR_HPP
 
#include <algorithm>
#include <concepts>
#include <cstddef>
#include <iostream>
#include <iterator>
#include <string_view>
#include <tuple>
#include <type_traits>
 
namespace conststr {
 
namespace meta {
template <typename... Ts>
using first_t = std::tuple_element_t<0, std::tuple<Ts...>>;
 
template <auto... Vs>
using first_t_of =
    std::remove_cvref_t<std::tuple_element_t<0, decltype(std::tuple{Vs...})>>;
 
template <auto... Vs>
constexpr auto first_v = [](auto first, auto...) { return first; }(Vs...);
 
template <typename... Ts>
using last_t = std::tuple_element_t<sizeof...(Ts) - 1, std::tuple<Ts...>>;
 
template <auto... Vs>
using last_t_of = std::remove_cvref_t<
    std::tuple_element_t<sizeof...(Vs) - 1, decltype(std::tuple{Vs...})>>;
 
template <auto... Vs>
constexpr auto last_v = (Vs, ...);
 
template <typename... Ts>
concept all_same = (std::same_as<first_t<Ts...>, Ts> && ...);
template <auto... Vs>
concept all_same_of = all_same<std::remove_cvref_t<decltype(Vs)>...>;
 
template <typename T>
concept hashable = requires(std::hash<std::remove_cvref_t<T>> hash,
                            const std::remove_cvref_t<T> &obj) { hash(obj); };
 
template <typename T, typename Elem, typename SizeT = std::size_t>
concept viewer =
    std::constructible_from<T, const Elem *, SizeT> && requires(const T &t) {
        t.begin();
        t.end();
        t.rbegin();
        t.rend();
        t.size();
        t[SizeT{}];
    };
}  // namespace meta
 
namespace charutils {
template <typename T>
concept char_like = std::is_trivial_v<T> && std::equality_comparable<T> &&
                    std::three_way_comparable<T> &&
                    requires { T('\0') + T('\x20') - T('\x20'); };
 
template <char_like T>
constexpr bool islower(T ch) {
    return ch >= T('a') && ch <= T('z');
}
 
template <char_like T>
constexpr bool issuper(T ch) {
    return ch >= T('A') && ch <= T('Z');
}
 
template <char_like T>
constexpr bool isdigit(T ch) {
    return ch >= T('0') && ch <= T('9');
}
 
template <char_like T>
constexpr bool isalpha(T ch) {
    return islower(ch) || issuper(ch);
}
 
template <char_like T>
constexpr bool isalnum(T ch) {
    return isalpha(ch) || isdigit(ch);
}
 
template <char_like T>
constexpr bool isxdigit(T ch) {
    return isdigit(ch) || (ch >= T('a') && ch <= T('f')) ||
           (ch >= T('A') && ch <= T('F'));
}
 
template <char_like T>
constexpr bool iscntrl(T ch) {
    return (ch >= T('\0') && ch <= T('\x1F')) || ch == T('\x7F');
}
 
template <char_like T>
constexpr bool ispunct(T ch) {
    return (ch >= T('!') && ch <= T('/')) || (ch >= T(':') && ch <= T('@')) ||
           (ch >= T('[') && ch <= T('`')) || (ch >= T('{') && ch <= T('~'));
}
 
template <char_like T>
constexpr bool isblank(T ch) {
    return ch == T(' ') || ch == T('\t');
}
 
template <char_like T>
constexpr bool isspace(T ch) {
    return isblank(ch) || ch == T('\f') || ch == T('\n') || ch == T('\r') ||
           ch == T('\v');
}
 
template <char_like T>
constexpr bool isgraph(T ch) {
    return isalnum(ch) || ispunct(ch);
}
 
template <char_like T>
constexpr bool isprint(T ch) {
    return isgraph(ch) || ch == T(' ');
}
 
template <char_like T>
constexpr char toupper(T ch) {
    return ch >= T('a') && ch <= T('z') ? ch - T('\x20') : ch;
}
 
template <char_like T>
constexpr char tolower(T ch) {
    return ch >= T('A') && ch <= T('Z') ? ch + T('\x20') : ch;
}
 
template <char_like T>
constexpr char invert(T ch) {
    return ch >= T('a') && ch <= T('z')   ? ch - T('\x20')
           : ch >= T('A') && ch <= T('Z') ? ch + T('\x20')
                                          : ch;
}
 
template <char_like auto... Chs>
constexpr bool is(meta::first_t_of<Chs...> ch)
    requires meta::all_same_of<Chs...> && (sizeof...(Chs) > 1)
{
    return ((Chs == ch) || ...);
}
 
template <char_like auto Ch>
constexpr decltype(Ch) just([[maybe_unused]] decltype(Ch) ignored) {
    return Ch;
}
 
template <char_like To>
constexpr auto cast =
    [](char_like auto from) -> To { return static_cast<To>(from); };
 
template <char_like auto... Chs>
constexpr meta::last_t_of<Chs...> replace(meta::last_t_of<Chs...> ch)
    requires meta::all_same_of<Chs...> && (sizeof...(Chs) > 1)
{
    return is<Chs...>(ch) ? meta::last_v<Chs...> : ch;
}
 
template <char_like auto... Chs>
constexpr meta::last_t_of<Chs...> remain(meta::last_t_of<Chs...> ch)
    requires meta::all_same_of<Chs...> && (sizeof...(Chs) > 1)
{
    return is<Chs...>(ch) ? ch : meta::last_v<Chs...>;
}
}  // namespace charutils
 
template <std::size_t N, charutils::char_like T, typename view>
    requires meta::viewer<view, T>
struct cstr;
 
template <typename T>
concept can_construct_cstr_from = requires(const T &t) { cstr{t}; };
 
template <typename T, typename CharT>
concept can_construct_cstr_t_from =
    std::same_as<typename decltype(cstr(std::declval<T>()))::value_type, CharT>;
 
template <typename T, typename CharT, std::size_t Len>
concept can_construct_cstr_t_n_from =
    std::same_as<typename decltype(cstr(std::declval<T>()))::value_type,
                 CharT> &&
    (decltype(cstr(std::declval<T>()))::size() == Len);
 
template <typename T>
struct sv_selector {};
 
template <typename T>
constexpr auto sv = sv_selector<T>{};
 
template <std::size_t N, charutils::char_like T = char,
          typename view = std::basic_string_view<T>>
    requires meta::viewer<view, T>
struct cstr {
    using value_type = T;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type &;
    using const_reference = const value_type &;
    using rreference = value_type &&;
    using const_rreference = const value_type &&;
    using pointer = value_type *;
    using const_pointer = const value_type *;
    using iterator = value_type *;
    using const_iterator = const value_type *;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    using view_type = view;
 
    template <typename UnaryOperation>
    using operation_result =
        std::remove_cvref_t<std::invoke_result_t<UnaryOperation, value_type>>;
 
    static constexpr value_type nul = value_type('\0');
 
    static constexpr size_type npos = N;
 
    constexpr cstr(
        [[maybe_unused]] const sv_selector<view_type> &svs = {}) noexcept
        : _str{nul} {}
 
    constexpr cstr(
        const value_type (&str)[N + 1],
        [[maybe_unused]] const sv_selector<view_type> &svs = {}) noexcept {
        for (size_type i = 0; i < N; ++i) _str[i] = str[i];
        _str[N] = nul;
    }
 
    constexpr cstr(
        const value_type &ch,
        [[maybe_unused]] const sv_selector<view_type> &svs = {}) noexcept {
        fill(ch);
    }
 
    constexpr cstr(std::convertible_to<value_type> auto... vs)
        : _str{vs..., nul} {}
 
    constexpr cstr(const cstr &) = default;
 
    template <typename V2>
    constexpr cstr(const cstr<N, value_type, V2> &other) {
        std::copy_n(other.begin(), size(), begin());
        _str[N] = nul;
    };
 
    constexpr ~cstr() = default;
 
    template <can_construct_cstr_t_n_from<value_type, N> Str>
    constexpr cstr &operator=(const Str &str) {
        auto other = cstr(str);
        std::copy_n(other.begin(), size(), begin());
        return *this;
    };
 
    constexpr void fill(const value_type &ch) noexcept {
        std::fill_n(begin(), size(), ch);
        _str[N] = nul;
    }
 
    template <typename V2>
    constexpr void swap(cstr<N, value_type, V2> &other) noexcept {
        std::swap_ranges(begin(), end(), other.begin());
    }
 
    static constexpr size_type size() noexcept { return N; }
 
    static constexpr size_type length() noexcept { return size(); }
 
    static constexpr size_type max_size() noexcept { return size(); }
 
    static constexpr bool empty() noexcept { return size() == 0; }
 
    constexpr pointer data() noexcept { return _str; }
 
    constexpr const_pointer data() const noexcept { return _str; }
 
    constexpr const_pointer c_str() const noexcept { return data(); }
 
    constexpr iterator begin() noexcept { return data(); }
 
    constexpr const_iterator begin() const noexcept { return data(); }
 
    constexpr iterator end() noexcept { return data() + size(); }
 
    constexpr const_iterator end() const noexcept { return data() + size(); }
 
    constexpr const_iterator cbegin() const noexcept { return data(); }
 
    constexpr const_iterator cend() const noexcept { return data() + size(); }
 
    constexpr reverse_iterator rbegin() noexcept {
        return reverse_iterator(end());
    }
 
    constexpr const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator(end());
    }
 
    constexpr reverse_iterator rend() noexcept {
        return reverse_iterator(begin());
    }
 
    constexpr const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator(begin());
    }
 
    constexpr const_reverse_iterator crbegin() const noexcept {
        return const_reverse_iterator(end());
    }
 
    constexpr const_reverse_iterator crend() const noexcept {
        return const_reverse_iterator(begin());
    }
 
    constexpr reference operator[](size_type pos) noexcept { return _str[pos]; }
 
    constexpr const_reference operator[](size_type pos) const noexcept {
        return _str[pos];
    }
 
    template <size_type Idx>
    constexpr reference get() & noexcept
        requires(N > Idx)
    {
        return _str[Idx];
    }
 
    template <size_type Idx>
    constexpr const_reference get() const & noexcept
        requires(N > Idx)
    {
        return _str[Idx];
    }
 
    template <size_type Idx>
    constexpr rreference get() && noexcept
        requires(N > Idx)
    {
        return std::move(_str[Idx]);
    }
 
    template <size_type Idx>
    constexpr const_rreference get() const && noexcept
        requires(N > Idx)
    {
        return std::move(_str[Idx]);
    }
 
    constexpr reference front() noexcept { return *begin(); }
 
    constexpr const_reference front() const noexcept { return *cbegin(); }
 
    constexpr reference back() noexcept {
        if constexpr (N > 0)
            return *(end() - 1);
        else
            return *end();
    }
 
    constexpr const_reference back() const noexcept {
        if constexpr (N > 0)
            return *(cend() - 1);
        else
            return *cend();
    }
 
    template <can_construct_cstr_t_from<value_type> Str>
    constexpr auto operator+(const Str &str) const noexcept {
        return append(str);
    }
 
    template <std::size_t N2, typename V2>
    constexpr bool operator==(
        const cstr<N2, value_type, V2> &other) const noexcept {
        return false;
    }
 
    template <typename V2>
    constexpr bool operator==(
        const cstr<N, value_type, V2> &other) const noexcept {
        if constexpr (std::equality_comparable<view_type>)
            return this->operator view_type() == other.operator view_type();
        else
            return std::equal(cbegin(), cend(), other.cbegin(), other.cend());
    }
 
    constexpr bool operator==(const view_type &other) const noexcept {
        if constexpr (std::equality_comparable<view_type>)
            return this->operator view_type() == other;
        else
            return std::equal(cbegin(), cend(), other.begin(), other.end());
    }
 
    template <std::size_t N2, typename V2>
    constexpr auto operator<=>(const cstr<N2, value_type, V2> &other) noexcept {
        if constexpr (std::three_way_comparable<view_type>)
            return this->operator view_type() <=> other.operator view_type();
        else
            return std::lexicographical_compare_three_way(
                cbegin(), cend(), other.cbegin(), other.cend());
    }
 
    constexpr auto operator<=>(const view_type &other) const noexcept {
        if constexpr (std::three_way_comparable<view_type>)
            return this->operator view_type() <=> other;
        else
            return std::lexicographical_compare_three_way(
                cbegin(), cend(), other.begin(), other.end());
    }
 
    constexpr operator view_type() const noexcept {
        return view_type(data(), size());
    }
 
    template <meta::viewer<value_type, size_type> V2>
    constexpr auto with_view() const noexcept -> cstr<N, value_type, V2> {
        return cstr<N, value_type, V2>{*this};
    }
 
    template <size_type Start, size_type Len = N>
        requires(N >= Start)
    constexpr auto substr() const noexcept {
        constexpr size_type size = std::min(Start + Len, N) - Start;
        cstr<size, value_type, view_type> ret{};
        for (size_type i = 0; i < size; ++i) ret[i] = _str[Start + i];
        return ret;
    };
 
    template <size_type Len>
    constexpr auto cut() const noexcept -> cstr<Len, value_type, view_type> {
        return substr<0, Len>();
    }
 
    template <size_type Len>
    constexpr auto remove_prefix() const noexcept {
        return substr<Len>();
    }
 
    template <size_type Len>
    constexpr auto remove_suffix() const noexcept {
        return substr<0, N - Len>();
    }
 
    template <size_type Count = 1>
    constexpr auto insert(size_type pos, const value_type &ch) const noexcept
        -> cstr<N + Count, value_type, view_type> {
        if (pos > N) pos = N;
        if constexpr (Count == 0)
            return *this;
        else {
            cstr<N + Count, value_type, view_type> ret{};
            for (size_type i = 0; i < pos; ++i) ret[i] = _str[i];
            for (size_type i = pos; i < pos + Count; ++i) ret[i] = ch;
            for (size_type i = pos; i < N; ++i) ret[i + Count] = _str[i];
            return ret;
        }
    };
 
    template <size_type Count = 1>
    constexpr auto insert(const_iterator iter,
                          const value_type &ch) const noexcept
        -> cstr<N + Count, value_type, view_type> {
        size_type pos = to_pos(iter);
        if constexpr (Count == 0)
            return *this;
        else {
            cstr<N + Count, value_type, view_type> ret{};
            for (size_type i = 0; i < pos; ++i) ret[i] = _str[i];
            for (size_type i = pos; i < pos + Count; ++i) ret[i] = ch;
            for (size_type i = pos; i < N; ++i) ret[i + Count] = _str[i];
            return ret;
        }
    };
 
    template <can_construct_cstr_t_from<value_type> Str>
    constexpr auto insert(size_type pos, const Str &str) const noexcept {
        if (pos > N) pos = N;
 
        auto other = conststr::cstr(str);
        constexpr size_type N2 = decltype(other)::size();
        cstr<N + N2, value_type, view_type> ret{};
        for (size_type i = 0; i < pos; ++i) ret[i] = _str[i];
        for (size_type i = 0; i < N2; ++i) ret[i + pos] = other[i];
        for (size_type i = pos; i < N; ++i) ret[i + N2] = _str[i];
        return ret;
    }
 
    template <can_construct_cstr_t_from<value_type> Str>
    constexpr auto insert(const_iterator iter, const Str &str) const noexcept {
        size_type pos = to_pos(iter);
        auto other = conststr::cstr(str);
        constexpr size_type N2 = decltype(other)::size();
        cstr<N + N2, value_type, view_type> ret{};
        for (size_type i = 0; i < pos; ++i) ret[i] = _str[i];
        for (size_type i = 0; i < N2; ++i) ret[i + pos] = other[i];
        for (size_type i = pos; i < N; ++i) ret[i + N2] = _str[i];
        return ret;
    }
 
    template <size_type Count = 1>
    constexpr auto append(const value_type &ch) const noexcept
        -> cstr<N + Count, value_type, view_type> {
        if constexpr (Count == 0)
            return *this;
        else {
            cstr<N + Count, value_type, view_type> ret{};
            for (size_type i = 0; i < N; ++i) ret[i] = _str[i];
            for (size_type i = N; i < N + Count; ++i) ret[i] = ch;
            return ret;
        }
    }
 
    template <can_construct_cstr_t_from<value_type> Str>
    constexpr auto append(const Str &str) const noexcept {
        return flatten(str);
    }
 
    template <size_type... Sizes>
    constexpr auto flatten(
        const cstr<Sizes, value_type, view_type> &...strs) const noexcept {
        if constexpr (sizeof...(Sizes) == 0)
            return *this;
        else {
            constexpr size_type COUNT = sizeof...(strs) + 1;
            constexpr size_type LENGTHS[COUNT] = {N, Sizes...};
            constexpr size_type FLAT_LENGTH = N + (Sizes + ...);
 
            cstr<FLAT_LENGTH, value_type, view_type> flat{};
            const_pointer datas[COUNT] = {data(), strs.data()...};
            size_type index = 0;
            for (size_type i = 0; i < COUNT; i++)
                for (size_type j = 0; j < LENGTHS[i]; j++)
                    flat[index++] = datas[i][j];
 
            return flat;
        }
    }
 
    template <can_construct_cstr_t_from<value_type>... Strs>
    constexpr auto flatten(const Strs &...strs) const noexcept {
        return flatten(conststr::cstr(strs)...);
    }
 
    constexpr auto replace(size_type pos, const value_type &ch,
                           size_type count = 1) const noexcept
        -> cstr<N, value_type, view_type> {
        if (pos > N) pos = N;
        cstr<N, value_type, view_type> ret = *this;
        size_type end = std::min(pos + count, N);
        for (size_type i = pos; i < end; ++i) ret[i] = ch;
        return ret;
    }
 
    constexpr auto replace(const_iterator first, const_iterator last,
                           const value_type &ch) const noexcept
        -> cstr<N, value_type, view_type> {
        auto [pos, count] = to_pos_len(first, last);
        cstr<N, value_type, view_type> ret = *this;
        size_type end = std::min(pos + count, N);
        for (size_type i = pos; i < end; ++i) ret[i] = ch;
        return ret;
    }
 
    constexpr auto replace(size_type pos, const view_type &str,
                           size_type count = 1) const noexcept
        -> cstr<N, value_type, view_type> {
        if (pos > N) pos = N;
        cstr<N, value_type, view_type> ret = *this;
        size_type end = std::min(pos + count * str.size(), N);
        for (size_type i = 0; i < end - pos; ++i) ret[i] = str[i % str.size()];
        return ret;
    }
 
    constexpr auto replace(const_iterator first, const_iterator last,
                           const view_type &str) const noexcept
        -> cstr<N, value_type, view_type> {
        auto [pos, count] = to_pos_len(first, last);
        return replace(pos, str, count);
    }
 
    template <value_type... Chs>
    constexpr auto replace(size_type pos = 0, size_type len = N) const noexcept
        -> cstr<N, value_type, view_type>
        requires(sizeof...(Chs) > 0)
    {
        return transform(charutils::replace<Chs...>, pos, len);
    }
 
    template <value_type... Chs>
    constexpr auto replace(const_iterator first,
                           const_iterator last) const noexcept
        -> cstr<N, value_type, view_type>
        requires(sizeof...(Chs) > 0)
    {
        return transform(charutils::replace<Chs...>, first, last);
    }
 
    constexpr auto erase(size_type pos) const noexcept
        -> cstr<N - 1, value_type, view_type> {
        if (pos >= N) return pop();
        cstr<N - 1, value_type, view_type> ret{};
        for (size_type i = 0; i < pos; ++i) ret[i] = _str[i];
        for (size_type i = pos; i < N - 1; ++i) ret[i] = _str[i + 1];
        return ret;
    }
 
    constexpr auto erase(const_iterator iter) const noexcept
        -> cstr<N - 1, value_type, view_type> {
        size_type pos = to_pos(iter);
        cstr<N - 1, value_type, view_type> ret{};
        for (size_type i = 0; i < pos; ++i) ret[i] = _str[i];
        for (size_type i = pos; i < N - 1; ++i) ret[i] = _str[i + 1];
        return ret;
    }
 
    constexpr auto push(const value_type &ch) const noexcept
        -> cstr<N + 1, value_type> {
        return append(ch);
    }
 
    constexpr auto pop() const noexcept -> cstr<N - 1, value_type, view_type> {
        return cut<N - 1>();
    }
 
    template <typename UnaryOperation, typename V2 = void>
    constexpr auto transform(
        UnaryOperation op, size_type pos = 0, size_type len = N,
        [[maybe_unused]] const sv_selector<V2> &svs = {}) const noexcept
        requires(meta::viewer<V2, operation_result<UnaryOperation>> ||
                 (std::is_void_v<V2>))
    {
        using result_t = operation_result<UnaryOperation>;
        using view_t = std::conditional_t<
            std::is_void_v<V2>,
            std::conditional_t<std::is_same_v<value_type, result_t>, view_type,
                               std::basic_string_view<result_t>>,
            V2>;
        if (pos > N) pos = N;
        cstr<N, result_t, view_t> ret{};
        auto begin = cbegin() + pos;
        auto end = cbegin() + std::min(pos + len, N);
        auto begin2 = ret.begin() + pos;
        std::transform(begin, end, begin2, op);
        return ret;
    }
 
    template <typename UnaryOperation, typename V2 = void>
    constexpr auto transform(
        UnaryOperation op, const_iterator first, const_iterator last,
        [[maybe_unused]] const sv_selector<V2> &svs = {}) const noexcept
        requires(meta::viewer<V2, operation_result<UnaryOperation>> ||
                 (std::is_void_v<V2>))
    {
        using result_t = operation_result<UnaryOperation>;
        using view_t = std::conditional_t<
            std::is_void_v<V2>,
            std::conditional_t<std::is_same_v<value_type, result_t>, view_type,
                               std::basic_string_view<result_t>>,
            V2>;
        first = std::max(first, cbegin());
        last = std::min(last, cend());
        cstr<N, result_t, view_t> ret{};
        auto first2 = ret.begin() + (first - cbegin());
        std::transform(first, last, first2, op);
        return ret;
    }
 
    template <charutils::char_like T2, typename V2 = void>
    constexpr auto cast(
        [[maybe_unused]] const sv_selector<V2> &svs = {}) const noexcept
        requires(meta::viewer<V2, T2> || (std::is_void_v<V2>))
    {
        return transform(charutils::cast<T2>, 0, N, sv<V2>);
    }
 
    constexpr auto uppercase() const noexcept
        -> cstr<N, value_type, view_type> {
        return transform(charutils::toupper<value_type>);
    }
 
    constexpr auto lowercase() const noexcept
        -> cstr<N, value_type, view_type> {
        return transform(charutils::tolower<value_type>);
    }
 
    constexpr size_type find(const value_type &ch,
                             size_type pos = 0) const noexcept {
        if (pos >= npos) return npos;
        return to_pos(std::find(cbegin() + pos, cend(), ch));
    }
 
    constexpr size_type find(const view_type &str,
                             size_type pos = 0) const noexcept {
        if (pos >= npos) return npos;
        return to_pos(
            std::search(cbegin() + pos, cend(), str.cbegin(), str.cend()));
    }
 
    constexpr size_type rfind(const value_type &ch,
                              size_type pos = npos) const noexcept {
        auto beg =
            pos >= npos ? crbegin() : const_reverse_iterator(cbegin() + pos);
        auto iter = std::find(beg, crend(), ch);
        return iter == crend() ? npos : to_pos(iter.base() - 1);
    }
 
    constexpr size_type rfind(const view_type &str,
                              size_type pos = npos) const noexcept {
        auto beg =
            pos >= npos ? crbegin() : const_reverse_iterator(cbegin() + pos);
        auto iter = std::search(beg, crend(), str.crbegin(), str.crend());
        return iter == crend() ? npos : to_pos(iter.base() - str.size());
    }
 
    template <typename UnaryPredicate>
    constexpr size_type find_if(UnaryPredicate p,
                                size_type pos = 0) const noexcept {
        if (pos >= npos) return npos;
        return to_pos(std::find_if(cbegin() + pos, cend(), p));
    }
 
    template <typename UnaryPredicate>
    constexpr size_type rfind_if(UnaryPredicate p,
                                 size_type pos = npos) const noexcept {
        auto beg =
            pos >= npos ? crbegin() : const_reverse_iterator(begin() + pos);
        auto iter = std::find_if(beg, crend(), p);
        return iter == crend() ? npos : to_pos(iter.base() - 1);
    }
 
    constexpr bool starts_with(const value_type &ch) const noexcept {
        if constexpr (N == 0)
            return false;
        else
            return front() == ch;
    }
 
    constexpr bool starts_with(const view_type &str) const noexcept {
        if constexpr (requires { this->operator view_type().starts_with(str); })
            return this->operator view_type().starts_with(str);
        else if constexpr (std::equality_comparable<view_type>)
            return size() > str.size() && view_type(begin(), str.size()) == str;
        else
            return size() > str.size() &&
                   std::equal(str.begin(), str.end(), begin());
    }
 
    constexpr bool ends_with(const value_type &ch) const noexcept {
        if constexpr (N == 0)
            return false;
        else
            return back() == ch;
    }
 
    constexpr bool ends_with(const view_type &str) const noexcept {
        if constexpr (requires { this->operator view_type().ends_with(str); })
            return this->operator view_type().ends_with(str);
        else if constexpr (std::equality_comparable<view_type>)
            return size() > str.size() &&
                   view_type(end() - str.size(), str.size()) == str;
        else
            return size() > str.size() &&
                   std::equal(str.begin(), str.end(), end() - str.size());
    }
 
    constexpr bool contains(const value_type &ch) const noexcept {
        return find(ch) != npos;
    }
 
    constexpr bool contains(const view_type &str) const noexcept {
        return find(str) != npos;
    }
 
    value_type _str[N + 1];
 
   private:
    inline constexpr size_t to_pos(const_iterator iter) const noexcept {
        return std::min(size_t(std::max(iter, cbegin()) - cbegin()), N);
    }
 
    inline constexpr std::tuple<size_t, size_t> to_pos_len(
        const_iterator first, const_iterator last) const noexcept {
        size_t first_pos = to_pos(first);
        size_t last_pos = to_pos(last);
        return {first_pos, std::max(first_pos, last_pos) - first_pos};
    }
};
 
template <charutils::char_like T, std::size_t N>
cstr(const T (&)[N]) -> cstr<N - 1, T, std::basic_string_view<T>>;
 
template <charutils::char_like T, std::size_t N, meta::viewer<T> V>
cstr(const T (&)[N], const sv_selector<V> &) -> cstr<N - 1, T, V>;
 
template <charutils::char_like T>
cstr(const T &ch) -> cstr<1, T, std::basic_string_view<T>>;
 
template <charutils::char_like T, meta::viewer<T> V>
cstr(const T &ch, const sv_selector<V> &) -> cstr<1, T, V>;
 
template <std::size_t Idx, charutils::char_like T, typename U, std::size_t N>
typename cstr<N, T, U>::reference get(cstr<N, T, U> &str) noexcept {
    return str.template get<Idx>();
}
 
template <std::size_t Idx, charutils::char_like T, typename U, std::size_t N>
typename cstr<N, T, U>::const_reference get(const cstr<N, T, U> &str) noexcept {
    return str.template get<Idx>();
}
 
template <std::size_t Idx, charutils::char_like T, typename U, std::size_t N>
typename cstr<N, T, U>::rreference get(cstr<N, T, U> &&str) noexcept {
    return str.template get<Idx>();
}
 
template <std::size_t Idx, charutils::char_like T, typename U, std::size_t N>
const typename cstr<N, T, U>::const_rreference get(
    const cstr<N, T, U> &&str) noexcept {
    return str.template get<Idx>();
}
 
template <charutils::char_like T, typename V1, typename V2, std::size_t N>
constexpr void swap(cstr<N, T, V1> &lhs, cstr<N, T, V2> &rhs) {
    lhs.swap(rhs);
}
 
template <can_construct_cstr_from First, can_construct_cstr_from... Str>
constexpr auto flatten(const First &first, const Str &...strs)
    requires meta::all_same<
        typename decltype(cstr(std::declval<First>()))::value_type,
        typename decltype(cstr(std::declval<Str>()))::value_type...>
{
    return cstr(first).flatten(strs...);
}
 
template <charutils::char_like T, typename U, std::size_t N>
std::ostream &operator<<(std::ostream &os, const cstr<N, T, U> &str) {
    os << static_cast<typename cstr<N, T, U>::view_type>(str);
    return os;
}
 
namespace literal {
consteval auto operator""_cs(char ch) { return cstr<1, char>(ch); }
 
consteval auto operator""_cs(char8_t ch) { return cstr<1, char8_t>(ch); }
 
consteval auto operator""_cs(char16_t ch) { return cstr<1, char16_t>(ch); }
 
consteval auto operator""_cs(char32_t ch) { return cstr<1, char32_t>(ch); }
 
consteval auto operator""_cs(wchar_t ch) { return cstr<1, wchar_t>(ch); }
 
template <cstr str>
consteval auto operator""_cs() {
    return str;
}
}  // namespace literal
 
}  // namespace conststr
 
template <conststr::charutils::char_like T, typename U, std::size_t N>
struct std::tuple_size<conststr::cstr<N, T, U>>
    : public std::integral_constant<std::size_t, N> {};
 
template <std::size_t Idx, conststr::charutils::char_like T, typename U,
          std::size_t N>
struct std::tuple_element<Idx, conststr::cstr<N, T, U>> {
    static_assert(N > Idx);
    using type = T;
};
 
template <conststr::charutils::char_like T, typename U, std::size_t N>
    requires conststr::meta::hashable<
        typename conststr::cstr<N, T, U>::view_type>
struct std::hash<conststr::cstr<N, T, U>> {
    std::size_t operator()(const conststr::cstr<N, T, U> &str) const noexcept {
        using view = typename conststr::cstr<N, T, U>::view_type;
        return std::hash<view>{}(static_cast<view>(str));
    }
};
 
#endif