string.hpp

/**
 * \file string.hpp
 * Consteval String Library
 * \version 0.1.0
 * \copyright Copyright (c) 2026 Justin Singh-Mohudpur.
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE.md or copy at https://www.boost.org/LICENSE_1_0.txt)
 */
#pragma once

#include <cstddef>
#include <tuple>

namespace jsm {

/**
 * compile-time (consteval) string
 *
 * \note The underlying buffer is null-terminated.
 * \tparam N Length of the string, not including the null-terminator.
 */
template<std::size_t N>
struct string
{
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using value_type = char;
    using reference = value_type&;
    using const_reference = const value_type&;
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using iterator = pointer;
    using const_iterator = const_pointer;

    static constexpr size_type npos = static_cast<size_type>(-1);

    consteval string() noexcept = default;

    /// Construct a string from a string literal.
    consteval string(const char (&s)[N + 1]) noexcept
    {
        for (size_type i = 0; i < N + 1; ++i) {
            storage[i] = s[i];
        }
    }

    /// The size (or length) of the string.
    consteval size_type size() const noexcept
    {
        return N;
    }

    /// The size (or length) of the string.
    consteval size_type length() const noexcept
    {
        return N;
    }

    /// Get a pointer to the start of the string buffer.
    consteval pointer data() noexcept
    {
        return storage;
    }

    /// Get a const pointer to the start of the string buffer.
    consteval const_pointer data() const noexcept
    {
        return storage;
    }

    consteval reference operator[](size_type n) noexcept
    {
        return storage[n];
    }

    consteval const_reference operator[](size_type n) const noexcept
    {
        return storage[n];
    }

    consteval reference front() noexcept
    {
        return operator[](0);
    }

    consteval const_reference front() const noexcept
    {
        return operator[](0);
    }

    consteval reference back() noexcept
    {
        return operator[](size() - 1);
    }

    consteval const_reference back() const noexcept
    {
        return operator[](size() - 1);
    }

    consteval iterator begin() noexcept
    {
        return storage;
    }

    consteval const_iterator begin() const noexcept
    {
        return storage;
    }

    consteval const_iterator cbegin() const noexcept
    {
        return storage;
    }

    consteval iterator end() noexcept
    {
        return storage + size();
    }

    consteval const_iterator end() const noexcept
    {
        return storage + size();
    }

    consteval const_iterator cend() const noexcept
    {
        return storage + size();
    }
    
    consteval bool starts_with(char c) const noexcept
    {
        return front() == c;
    }

    template<std::size_t M>
    consteval bool starts_with(string<M> s) const noexcept
    {
        if constexpr (M > N) {
            return false;
        }

        for (std::size_t i = 0; i < M; ++i) {
            if (storage[i] != s[i]) {
                return false;
            }
        }
        return true;
    }

    consteval bool ends_with(char c) const noexcept
    {
        return back() == c;
    }

    template<std::size_t M>
    consteval bool ends_with(string<M> s) const noexcept
    {
        if constexpr (M > N) {
            return false;
        }

        constexpr auto K = N - M;
        for (std::size_t i = 0; i < M; ++i) {
            if (storage[i + K] != s[i]) {
                return false;
            }
        }
        return true;
    }

    consteval string<N + 1> append(char c) const noexcept
    {
        string<N + 1> result{};
        auto it = result.begin();
        for (auto s : *this) {
            *it = s;
            it++;
        }

        *it = c;
        return result;
    }

    template<size_t M>
    consteval string<N + M> append(string<M> s) const noexcept
    {
        string<N + M> result{};
        auto it = result.begin();
        for (auto c : *this) {
            *it = c;
            it++;
        }

        for (auto c : s) {
            *it = c;
            it++;
        }

        return result;
    }

    template<size_type M>
    consteval auto operator+(string<M> s) const noexcept
    {
        return append(s);
    }

    consteval auto operator+(char c) const noexcept
    {
        return append(c);
    }

    template<size_t M>
    consteval bool operator==(string<M> s) const noexcept
    {
        if constexpr (N != M) {
            return false;
        }

        for (size_type i = 0; i < N; ++i) {
            if (storage[i] != s[i]) {
                return false;
            }
        }

        return true;
    }

    template<size_t M>
    consteval bool operator==(const char (&s)[M]) const noexcept
    {
        if constexpr (M != (N + 1)) {
            return false;
        }

        for (size_type i = 0; i < N + 1; ++i) {
            if (storage[i] != s[i]) {
                return false;
            }
        }

        return true;
    }

    value_type storage[N + 1]{};
};

template<size_t N>
using consteval_string = string<N>;

template<size_t N>
string(const char (&)[N]) -> string<N - 1>;

inline constexpr string empty = "";

/// Apply an operation over every character in \p S.
/// \param op A map operation that takes a char.
template<string S, typename F>
    requires (std::is_invocable_r_v<char, F, char>)
consteval decltype(S) map(F&& op) noexcept(noexcept(op))
{
    auto new_str = S;
    for (auto& c : new_str) {
        c = op(c);
    }
    return new_str;
}

/// Apply a left-fold operation to \p S.
/// \param init The initial value.
/// \param op A fold operation that takes an init value and a char.
template<string S, typename T, typename F>
    requires (std::is_invocable_r_v<T, F, T, char>)
consteval T fold(T&& init, F&& op) noexcept(noexcept(op))
{
    decltype(auto) result = std::forward<T>(init);
    for (auto c : S) {
        result = op(std::forward<T>(result), c);
    }
    return result;
}

/// Slice \p S into the range [\p InclusiveBegin, \p ExclusiveEnd).
template<string S, std::size_t InclusiveBegin, std::size_t ExclusiveEnd>
    requires (ExclusiveEnd <= S.size() && ExclusiveEnd >= InclusiveBegin)
consteval string<ExclusiveEnd - InclusiveBegin> slice() noexcept
{
    if constexpr (ExclusiveEnd == InclusiveBegin) {
        return string<0>{ "" };
    } else {
        string<ExclusiveEnd - InclusiveBegin> result{};
        for (size_t i = InclusiveBegin; i < ExclusiveEnd; ++i) {
            result[i - InclusiveBegin] = S[i];
        }
        return result;
    }
}

/// Substring \p S with length \p Length starting with \p Begin.
///
/// \note If \p Begin + \p Length is larger than \p S, then \p Length is bounded to \p S.size().
template<string S, std::size_t Begin = 0, std::size_t Length = S.size()>
    requires (Begin < S.size())
consteval auto substr() noexcept
{
    constexpr auto MaybeEnd = Begin + Length;
    constexpr auto End = MaybeEnd > S.size() ? S.size() : MaybeEnd;
    return slice<S, Begin, End>();
}

/// Concat all of \p S.
template<string... S>
consteval auto concat() noexcept
{
    return (... + S);
}

/// Find the first instance of \p C in \p S.
template<string S, char C>
consteval std::size_t find() noexcept
{
    constexpr auto N = S.length();
    for (size_t i = 0; i < N; ++i) {
        if (S[i] == C) {
            return i;
        }
    }
    return string<N>::npos;
}

/// Find the first instance of \p T in \p S.
template<string S, string T>
consteval std::size_t find() noexcept
{
    constexpr auto N = S.length();
    constexpr auto M = T.length();
    
    for (std::size_t n = 0; n < N; ++n) {
        for (std::size_t m = 0; m <= M; ++m) {
            if (m == M) {
                return n;
            }

            if (n + m >= N) {
                n = N;
                break;
            }

            if (S[n + m] != T[m]) {
                n += m;
                break;
            }
        }
    }

    return string<N>::npos;
}

/// Count the number of occurrences of \p C in \p S.
template<string S, char C>
consteval std::size_t count() noexcept
{
    return fold<S>(static_cast<std::size_t>(0), [](auto acc, char s) { return acc + (s == C); });
}

/// Split \p S by the first character \p C.
template<string S, char C>
consteval auto split_once() noexcept
{
    constexpr auto pos = find<S, C>();

    if constexpr (pos == decltype(S)::npos) {
        return std::make_tuple(S);
    } else if constexpr (pos == S.size()) {
        return std::make_tuple(slice<0, pos>(S), empty);
    } else if constexpr (pos == 0) {
        return std::make_tuple(empty, slice<S, 1, S.size()>());
    } else {
        return std::make_tuple(slice<S, 0, pos>(), slice<S, pos + 1, S.size()>());
    }
}

/// Split \p S by the first instance of \p T.
template<string S, string T>
consteval auto split_once() noexcept
{
    constexpr auto pos = find<S, T>();

    if constexpr (pos == decltype(S)::npos) {
        return std::make_tuple(S);
    } else if constexpr (pos == (S.size() - T.size())) {
        return std::make_tuple(slice<S, 0, pos>(), empty);
    } else if constexpr (pos == 0) {
        return std::make_tuple(empty, slice<S, T.size(), S.size()>());
    } else {
        return std::make_tuple(slice<S, 0, pos>(), slice<S, pos + T.size(), S.size()>());
    }
}

/// Split \p S by all instances of \p C.
template<string S, char C>
consteval auto split() noexcept
{
    constexpr auto s = split_once<S, C>();
    if constexpr (std::tuple_size_v<decltype(s)> == 1) {
        return s;
    } else {
        constexpr auto left = std::make_tuple(std::get<0>(s));
        constexpr auto right = split<std::get<1>(s), C>();
        return std::tuple_cat(left, right);
    }
}

/// Split \p S by all instances of \p T.
template<string S, string T>
consteval auto split() noexcept
{
    constexpr auto s = split_once<S, T>();
    if constexpr (std::tuple_size_v<decltype(s)> == 1) {
        return s;
    } else {
        constexpr auto left = std::make_tuple(std::get<0>(s));
        constexpr auto right = split<std::get<1>(s), T>();
        return std::tuple_cat(left, right);
    }
}

/// Replace all instances of \p From with \p To in \p S.
template<string S, char From, char To>
consteval decltype(S) replace() noexcept
{
    return map<S>([](char s) { return s == From ? To : s; });
}

/// Replace all instances of \p From with \p To in \p S.
template<string S, string From, string To>
consteval auto replace() noexcept
{
    constexpr auto s = split_once<S, From>();
    if constexpr (std::tuple_size_v<decltype(s)> == 1) {
        return S;
    } else {
        constexpr auto left = std::get<0>(s).append(To);
        constexpr auto right = replace<std::get<1>(s), From, To>();
        return concat<left, right>();
    }
}

/// Remove all instances of \p C from \p S.
template<string S, char C>
consteval auto remove() noexcept
{
    constexpr auto N = S.size();
    constexpr auto M = count<S, C>();
    if constexpr (M == 0) {
        return S;
    }

    string<N - M> result{};
    auto* out = result.data();
    for (auto it = S.begin(); it != S.end() && out != result.end(); ++it) {
        if (*it == C) {
            continue;
        }
        *out = *it;
        ++out;
    }

    return result;
}

/// Remove all instances of \p T from \p S.
template<string S, string T>
consteval auto remove() noexcept
{
    if constexpr (T == empty) {
        return S;
    } else {
        return replace<S, T, "">();
    }
}

/// Reverse the characters of \p S.
template<string S>
consteval decltype(S) reverse() noexcept
{
    constexpr auto N = S.size();
    string<N> r{};
    for (std::size_t i = 0; i < N; ++i) {
        r[i] = S[N - (i + 1)];
    }
    return r;
}

constexpr char toupper(char c) noexcept
{
    return (c < 'a' || c > 'z') ? c : c - 32;
}

constexpr char tolower(char c) noexcept
{
    return (c < 'A' || c > 'Z' ? c : c + 32);
}

} // namespace jsm