Compiler Explorer

Source code

#include <gsl/gsl-lite.hpp>
#include <compare>
#include <cstddef>
#include <cstdlib>
#include <format>
#include <ostream>
#include <ranges>
#include <string_view>

/**
 * @brief A compile-time fixed string
 *
 * @tparam CharT Character type to be used by the string
 * @tparam N The size of the string
 */
template<typename CharT, std::size_t N>
class basic_fixed_string {
public:
  CharT data_[N + 1] = {};  // exposition only

// types
  using value_type = CharT;
  using pointer = value_type*;
  using const_pointer = const value_type*;
  using reference = value_type&;
  using const_reference = const value_type&;
  using const_iterator = const value_type*;
  using iterator = const_iterator;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
  using reverse_iterator = const_reverse_iterator;
  using size_type = std::size_t;
  using difference_type = std::ptrdiff_t;

// construction and assignment
  template<std::convertible_to<CharT>... Chars>
    requires(sizeof...(Chars) == N) && (... && !std::is_pointer_v<Chars>)
  constexpr explicit basic_fixed_string(Chars... chars) noexcept : data_{chars..., CharT{}}
  {
  }

// NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
  consteval explicit(false) basic_fixed_string(const CharT (&txt)[N + 1]) noexcept
  {
    gsl_Expects(txt[N] == CharT{});
    for (std::size_t i = 0; i < N; ++i) data_[i] = txt[i];
  }

template<std::input_iterator It, std::sentinel_for<It> S>
    requires std::convertible_to<std::iter_value_t<It>, CharT>
  constexpr basic_fixed_string(It begin, S end)
  {
    gsl_Expects(std::distance(begin, end) == N);
    for (auto it = data_; begin != end; ++begin, ++it) *it = *begin;
  }

template<std::ranges::input_range R>
    requires std::convertible_to<std::ranges::range_reference_t<R>, CharT>
  constexpr basic_fixed_string(std::from_range_t, R&& r)
  {
    gsl_Expects(std::ranges::size(r) == N);
    for (auto it = data_; auto&& v : std::forward<R>(r)) *it++ = std::forward<decltype(v)>(v);
  }

constexpr basic_fixed_string(const basic_fixed_string&) noexcept = default;
  constexpr basic_fixed_string& operator=(const basic_fixed_string&) noexcept = default;

// iterator support
  [[nodiscard]] constexpr const_iterator begin() const noexcept { return data(); }
  [[nodiscard]] constexpr const_iterator end() const noexcept { return data() + size(); }
  [[nodiscard]] constexpr const_iterator cbegin() const noexcept { return begin(); }
  [[nodiscard]] constexpr const_iterator cend() const noexcept { return end(); }
  [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
  [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
  [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
  [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept { return rend(); }

// capacity
  static constexpr std::integral_constant<size_type, N> size{};
  static constexpr std::integral_constant<size_type, N> length{};
  static constexpr std::integral_constant<size_type, N> max_size{};
  static constexpr std::bool_constant<N == 0> empty{};

// element access
  [[nodiscard]] constexpr const_reference operator[](size_type pos) const
  {
    gsl_Expects(pos < N);
    return data()[pos];
  }

[[nodiscard]] constexpr const_reference at(size_type pos) const
  {
    if (pos >= size()) throw std::out_of_range("basic_fixed_string::at");
    return (*this)[pos];
  }
  [[nodiscard]] constexpr const_reference front() const
  {
    gsl_Expects(!empty());
    return (*this)[0];
  }
  [[nodiscard]] constexpr const_reference back() const
  {
    gsl_Expects(!empty());
    return (*this)[N - 1];
  }

// modifiers
  constexpr void swap(basic_fixed_string& s) noexcept { std::swap_ranges(begin(), end(), s.begin()); }

// string operations
  [[nodiscard]] constexpr const_pointer c_str() const noexcept { return data(); }
  [[nodiscard]] constexpr const_pointer data() const noexcept { return static_cast<const_pointer>(data_); }
  [[nodiscard]] constexpr std::basic_string_view<CharT> view() const noexcept
  {
    return std::basic_string_view<CharT>(cbegin(), cend());
  }
  // NOLINTNEXTLINE(*-explicit-conversions, google-explicit-constructor)
  [[nodiscard]] constexpr explicit(false) operator std::basic_string_view<CharT>() const noexcept
  {
    return view();
  }

template<std::size_t N2>
  [[nodiscard]] constexpr friend basic_fixed_string<CharT, N + N2> operator+(
    const basic_fixed_string& lhs, const basic_fixed_string<CharT, N2>& rhs) noexcept
  {
    CharT txt[N + N2];
    CharT* it = txt;
    for (CharT c : lhs) *it++ = c;
    for (CharT c : rhs) *it++ = c;
    return basic_fixed_string<CharT, N + N2>(txt, it);
  }

[[nodiscard]] constexpr friend basic_fixed_string<CharT, N + 1> operator+(const basic_fixed_string& lhs,
                                                                                    CharT rhs) noexcept
  {
    CharT txt[N + 1];
    CharT* it = txt;
    for (CharT c : lhs) *it++ = c;
    *it++ = rhs;
    return basic_fixed_string<CharT, N + 1>(txt, it);
  }

[[nodiscard]] constexpr friend basic_fixed_string<CharT, 1 + N> operator+(
    CharT lhs, const basic_fixed_string& rhs) noexcept
  {
    CharT txt[1 + N];
    CharT* it = txt;
    *it++ = lhs;
    for (CharT c : rhs) *it++ = c;
    return basic_fixed_string<CharT, 1 + N>(txt, it);
  }

template<std::size_t N2>
  [[nodiscard]] consteval friend basic_fixed_string<CharT, N + N2 - 1> operator+(
    const basic_fixed_string& lhs, const CharT (&rhs)[N2]) noexcept
  {
    gsl_Expects(rhs[N2 - 1] == CharT{});
    CharT txt[N + N2];
    CharT* it = txt;
    for (CharT c : lhs) *it++ = c;
    for (CharT c : rhs) *it++ = c;
    return txt;
  }

template<std::size_t N1>
  [[nodiscard]] consteval friend basic_fixed_string<CharT, N1 + N - 1> operator+(
    const CharT (&lhs)[N1], const basic_fixed_string& rhs) noexcept
  {
    gsl_Expects(lhs[N1 - 1] == CharT{});
    CharT txt[N1 + N];
    CharT* it = txt;
    for (size_t i = 0; i != N1 - 1; ++i) *it++ = lhs[i];
    for (CharT c : rhs) *it++ = c;
    *it++ = CharT();
    return txt;
  }

// non-member comparison functions
  template<size_t N2>
  [[nodiscard]] friend constexpr bool operator==(const basic_fixed_string& lhs,
                                                 const basic_fixed_string<CharT, N2>& rhs)
  {
    return lhs.view() == rhs.view();
  }
  template<size_t N2>
  [[nodiscard]] friend consteval bool operator==(const basic_fixed_string& lhs, const CharT (&rhs)[N2])
  {
    gsl_Expects(rhs[N2 - 1] == CharT{});
    return lhs.view() == std::basic_string_view<CharT>(rhs, rhs + N2 - 1);
  }

template<size_t N2>
  [[nodiscard]] friend constexpr auto operator<=>(const basic_fixed_string& lhs,
                                                  const basic_fixed_string<CharT, N2>& rhs)
  {
    return lhs.view() <=> rhs.view();
  }
  template<size_t N2>
  [[nodiscard]] friend consteval auto operator<=>(const basic_fixed_string& lhs, const CharT (&rhs)[N2])
  {
    gsl_Expects(rhs[N2 - 1] == CharT{});
    return lhs.view() <=> std::basic_string_view<CharT>(rhs, rhs + N2 - 1);
  }

// inserters and extractors
  friend std::basic_ostream<CharT>& operator<<(std::basic_ostream<CharT>& os,
                                                       const basic_fixed_string& str)
  {
    return os << str.c_str();
  }
};

// deduction guides
template<typename CharT, std::convertible_to<CharT>... Rest>
basic_fixed_string(CharT, Rest...) -> basic_fixed_string<CharT, 1 + sizeof...(Rest)>;

template<typename CharT, std::size_t N>
basic_fixed_string(const CharT (&str)[N]) -> basic_fixed_string<CharT, N - 1>;

template<typename CharT, std::size_t N>
basic_fixed_string(std::from_range_t, std::array<CharT, N>) -> basic_fixed_string<CharT, N>;

// specialized algorithms
template<class charT, size_t N>
constexpr void swap(basic_fixed_string<charT, N>& x, basic_fixed_string<charT, N>& y) noexcept
{
  x.swap(y);
}

// typedef-names
template<std::size_t N>
using fixed_string = basic_fixed_string<char, N>;
template<std::size_t N>
using fixed_u8string = basic_fixed_string<char8_t, N>;
template<std::size_t N>
using fixed_u16string = basic_fixed_string<char16_t, N>;
template<std::size_t N>
using fixed_u32string = basic_fixed_string<char32_t, N>;
template<std::size_t N>
using fixed_wstring = basic_fixed_string<wchar_t, N>;

// hash support
template<std::size_t N>
struct std::hash<fixed_string<N>> : std::hash<std::string_view> {};
template<std::size_t N>
struct std::hash<fixed_u8string<N>> : std::hash<std::u8string_view> {};
template<std::size_t N>
struct std::hash<fixed_u16string<N>> : std::hash<std::u16string_view> {};
template<std::size_t N>
struct std::hash<fixed_u32string<N>> : std::hash<std::u32string_view> {};
template<std::size_t N>
struct std::hash<fixed_wstring<N>> : std::hash<std::wstring_view> {};

// formatting support
template<typename CharT, std::size_t N>
struct std::formatter<basic_fixed_string<CharT, N>> : formatter<std::basic_string_view<CharT>> {
  template<typename FormatContext>
  auto format(const basic_fixed_string<CharT, N>& str, FormatContext& ctx) const -> decltype(ctx.out())
  {
    return formatter<std::basic_string_view<CharT>>::format(std::basic_string_view<CharT>(str), ctx);
  }
};
// NOLINTEND(*-avoid-c-arrays)

// ############## Unit tests ##############

constexpr std::array array = {'a', 'b', 'c'};

auto from_string = [] {
  std::string txt = "abc";
  return fixed_string<3>(std::from_range, txt);
};

auto from_string_iter = [] {
  std::string txt = "abc";
  return fixed_string<3>(txt.begin(), txt.end());
};

constexpr fixed_string<0> txt0;
constexpr basic_fixed_string txt1('a');
constexpr basic_fixed_string txt2('a', 'b', 'c');
constexpr basic_fixed_string txt3 = "abc";
constexpr fixed_string<3> txt4(array.begin(), array.end());
constexpr basic_fixed_string txt5(std::from_range, array);
constexpr basic_fixed_string txt6(from_string());
constexpr basic_fixed_string txt7(from_string_iter());

constexpr fixed_string<3> txt8(txt2.begin(), txt2.end());
constexpr fixed_string<3> txt9(txt2.rbegin(), txt2.rend());

static_assert(txt0.size() == 0);
static_assert(txt1.size() == 1);
static_assert(txt2.size() == 3);
static_assert(txt3.size() == 3);
static_assert(txt4.size() == 3);
static_assert(txt5.size() == 3);
static_assert(txt6.size() == 3);
static_assert(txt7.size() == 3);
static_assert(txt8.size() == 3);
static_assert(txt9.size() == 3);

static_assert(txt0.length() == 0);
static_assert(txt1.length() == 1);
static_assert(txt2.length() == 3);

static_assert(txt0.max_size() == 0);
static_assert(txt1.max_size() == 1);
static_assert(txt2.max_size() == 3);

static_assert(txt0.empty() == true);
static_assert(txt1.empty() == false);
static_assert(txt2.empty() == false);
static_assert(txt3.empty() == false);
static_assert(txt4.empty() == false);
static_assert(txt5.empty() == false);
static_assert(txt6.empty() == false);
static_assert(txt7.empty() == false);
static_assert(txt8.empty() == false);
static_assert(txt9.empty() == false);

static_assert(txt1[0] == 'a');
static_assert(txt2[0] == 'a');
static_assert(txt2[1] == 'b');
static_assert(txt2[2] == 'c');
static_assert(txt9[0] == 'c');
static_assert(txt9[1] == 'b');
static_assert(txt9[2] == 'a');

static_assert(txt1.at(0) == 'a');
static_assert(txt2.at(0) == 'a');
static_assert(txt2.at(1) == 'b');
static_assert(txt2.at(2) == 'c');
static_assert(txt9.at(0) == 'c');
static_assert(txt9.at(1) == 'b');
static_assert(txt9.at(2) == 'a');

static_assert(txt1.front() == 'a');
static_assert(txt1.back() == 'a');
static_assert(txt2.front() == 'a');
static_assert(txt2.back() == 'c');
static_assert(txt5.front() == 'a');
static_assert(txt5.back() == 'c');
static_assert(txt6.front() == 'a');
static_assert(txt6.back() == 'c');
static_assert(txt7.front() == 'a');
static_assert(txt7.back() == 'c');
static_assert(txt8.front() == 'a');
static_assert(txt8.back() == 'c');
static_assert(txt9.front() == 'c');
static_assert(txt9.back() == 'a');

static_assert(std::string_view(txt0.data()) == "");
static_assert(std::string_view(txt0.c_str()) == "");
static_assert(std::string_view(txt1.data()) == "a");
static_assert(std::string_view(txt1.c_str()) == "a");
static_assert(std::string_view(txt2.data()) == "abc");
static_assert(std::string_view(txt2.c_str()) == "abc");

static_assert(txt0 == "");
static_assert("a" == txt1);
static_assert(txt2 == "abc");
static_assert(txt3 == "abc");
static_assert(txt4 == "abc");
static_assert(txt5 == "abc");
static_assert(txt6 == "abc");
static_assert(txt7 == "abc");
static_assert(txt8 == "abc");
static_assert(txt9 == "cba");

static_assert(txt1 == basic_fixed_string("a"));
static_assert(txt1 != basic_fixed_string("b"));
static_assert(txt1 != basic_fixed_string("aa"));
static_assert(txt1 < basic_fixed_string("b"));
static_assert(txt1 < basic_fixed_string("aa"));
static_assert(txt1 == "a");
static_assert(txt1 != "b");
static_assert(txt1 != "aa");
static_assert(txt1 < "b");
static_assert(txt1 < "aa");

static_assert(txt1 + basic_fixed_string('b') == "ab");
static_assert(basic_fixed_string('b') + txt1 == "ba");
static_assert(txt1 + basic_fixed_string("bc") == "abc");
static_assert(basic_fixed_string("bc") + txt1 == "bca");
static_assert(txt1 + 'b' == "ab");
static_assert('b' + txt1 == "ba");
static_assert(txt1 + "bc" == "abc");
static_assert("bc" + txt1 == "bca");

static_assert(txt2 == basic_fixed_string("abc"));
static_assert(txt2 != basic_fixed_string("cba"));
static_assert(txt2 != basic_fixed_string("abcd"));
static_assert(txt2 < basic_fixed_string("b"));
static_assert(txt2 > basic_fixed_string("aa"));
static_assert(txt2 == "abc");
static_assert(txt2 != "cba");
static_assert(txt2 != "abcd");
static_assert(txt2 < "b");
static_assert(txt2 > "aa");

static_assert(txt2 + basic_fixed_string('d') == "abcd");
static_assert(basic_fixed_string('d') + txt2 == "dabc");
static_assert(txt2 + basic_fixed_string("def") == "abcdef");
static_assert(basic_fixed_string("def") + txt2 == "defabc");
static_assert(txt2 + 'd' == "abcd");
static_assert('d' + txt2 == "dabc");
static_assert(txt2 + "def" == "abcdef");
static_assert("def" + txt2 == "defabc");

static_assert(std::string_view(txt2) == "abc");
static_assert(txt2.view() == "abc");
static_assert(std::string_view(txt2).find('b') == 1);
static_assert(txt2.view().find('b') == 1);

#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_exception.hpp>

TEST_CASE("fixed_string::at", "[fixed_string]")
{
  basic_fixed_string txt = "abc";
  SECTION("in range")
  {
    CHECK(txt.at(0) == 'a');
    CHECK(txt.at(1) == 'b');
    CHECK(txt.at(2) == 'c');
  }
  SECTION("out of range")
  {
    REQUIRE_THROWS_MATCHES(txt.at(3), std::out_of_range, Catch::Matchers::Message("basic_fixed_string::at"));
    REQUIRE_THROWS_MATCHES(txt.at(1024), std::out_of_range, Catch::Matchers::Message("basic_fixed_string::at"));
  }
}

TEST_CASE("fixed_string text output", "[fixed_string][ostream][fmt]")
{
  basic_fixed_string txt = "units";
  SECTION("iostream")
  {
    std::ostringstream os;
    os << txt;
    CHECK(os.str() == "units");
  }
  SECTION("fmt") { CHECK(std::format("{}", txt) == "units"); }
}

TEST_CASE("fixed_string hash", "[fixed_string][hash]")
{
  basic_fixed_string txt = "units";
  CHECK(std::hash<fixed_string<5>>{}(txt) == std::hash<std::string_view>{}("units"));
}

#include <catch2/catch_session.hpp>

int main(int argc, char* argv[])
{
  return Catch::Session().run( argc, argv );
}