stdx - Polyfill for the C++ standard library

// this header: atomic_cfg.hpp
#include <cstdint>

template <>
constexpr inline auto ::atomic::alignment_of<bool> = alignof(std::uint32_t);

static_assert(alignof(stdx::atomic<bool>) == alignof(std::uint32_t));

using A = stdx::bitset<8>;   // uses uint8_t
using B = stdx::bitset<16>;  // uses uint16_t
using C = stdx::bitset<32>;  // uses uint32_t
using D = stdx::bitset<64>;  // uses uint64_t

using namespace std::string_view_literals;
auto bs0 = stdx::atomic_bitset<8>{};
auto bs1 = stdx::atomic_bitset<8>{stdx::all_bits};            // 0b1111'1111
auto bs2 = stdx::atomic_bitset<8>{stdx::place_bits, 0, 1, 3}; // 0b1011
auto bs3 = stdx::atomic_bitset<8>{0b1011};
auto bs4 = stdx::atomic_bitset<8>{"1011"sv};

auto bs = stdx::atomic_bitset<11>{0b101}; // 11 bits, value 5
auto i = bs.to<std::uint64_t>();          // 5 (a std::uint64_t)
auto j = bs.to_natural();                 // 5 (a std::uint16_t)

enum struct Bits { ZERO, ONE, TWO, THREE, MAX };
auto bs = stdx::atomic_bitset<Bits::MAX>{stdx::all_bits}; // 4 bits, value 0b1111
bs.set(Bits::ZERO);
bs.reset(Bits::ZERO);
bs.flip(Bits::ZERO);
auto bit_zero = bs[Bits::ZERO];

constexpr auto bs = stdx::atomic_bitset<8>{0b1010ul};
auto copy = bs.load(); // a stdx::bitset<8>{0b1010ul};
bs.store(copy);

constexpr auto bs = stdx::atomic_bitset<8>{0b1010ul};
auto prev = bs.set(0);
// bs   == 1011
// prev == 1010 (stdx::bitset<8>)

template <std::size_t N, typename Element = void>
struct bitset;

using A = stdx::bitset<8>;   // uses uint8_t
using B = stdx::bitset<16>;  // uses uint16_t
using C = stdx::bitset<32>;  // uses uint32_t
using D = stdx::bitset<64>;  // uses uint64_t
using E = stdx::bitset<128>; // uses (array of) uint64_t
using F = stdx::bitset<128, std::uint8_t>; // uses (array of) uint8_t

auto bs = stdx::bitset<8>{0b1100}; // bits 2 and 3 set

auto bs = stdx::bitset<8>{stdx::place_bits, 2, 3}; // bits 2 and 3 set

using namespace std::string_view_literals;
auto bs1 = stdx::bitset<8>{"1100"sv};            // bits 2 and 3 set
auto bs2 = stdx::bitset<8>{"1100"sv, 0, 2};      // bits 0 and 1 set
auto bs3 = stdx::bitset<8>{"AABB"sv, 0, 2, 'A'}; // bits 0 and 1 set

auto bs = stdx::bitset<11>{0b101}; // 11 bits, value 5
auto i = bs.to<std::uint64_t>();   // 5 (a std::uint64_t)
auto j = bs.to_natural();          // 5 (a std::uint16_t)

enum struct Bits { ZERO, ONE, TWO, THREE, MAX };
auto bs = stdx::bitset<Bits::MAX>{stdx::all_bits}; // 4 bits, value 0b1111
bs.set(Bits::ZERO);
bs.reset(Bits::ZERO);
bs.flip(Bits::ZERO);
auto bit_zero = bs[Bits::ZERO];

auto bs = stdx::bitset<8>{0b1010'1010ul};
for_each([&](auto i) { /* i == 1, 3, 5, 7 */ }, bs);

auto bs = stdx::bitset<8>{0b11'0111ul};
auto i = bs.lowest_unset(); // i == 3

std::uint8_t const table[1024];

std::uint8_t value1 = *table;
std::uint16_t value2 = *reinterpret_cast<std::uint16_t const *>(&table[1]);
// etc...

std::uint8_t const table[1024];
auto i = stdx::byterator{std::begin(table)};

std::uint8_t const table[1024];
for (auto i = stdx::byterator{std::begin(table)}; i != std::end(table); ++i) {
  std::byte b = *i;
  // do something ...
}

std::uint8_t const table[1024];
auto i = stdx::byterator{std::begin(table)};
// read a std::uint16_t (and advance i by 2 bytes)
auto value = i.readu16();

auto v8 = i.peeku8();   // read value without advancing
v8 = i.readu8();        // read and advance
i.writeu8(v8);          // write and advance

auto v16 = i.peeku16(); // read value without advancing
v16 = i.readu16();      // read and advance
i.writeu16(v16);        // write and advance

auto v32 = i.peeku32(); // read value without advancing
v32 = i.readu32();      // read and advance
i.writeu32(v32);        // write and advance

// peek and read have identical arguments; read is shown

// read and return a std::uint16_t, advance 2 bytes
auto v1 = i.read<std::uint16_t>();

// read a std::uint8_t, advance 1 byte, but return the value as a std::uint16_t
auto v2 = i.read<std::uint8_t, std::uint16_t>();

// E is a std::uint32_t under the hood, but we might well have a 1-byte value in the table
enum struct E : std::uint32_t { A, B, C };
auto v3 = i.read<std::uint8_t, E>();

constexpr auto c = stdx::cached{[] { return expensive_computation(); }};

// check whether the value is present
auto b = c.has_value();

// or, automatic bool conversion (explicit)
if (c) {
  // do something
}

// use the value (computing where necessary)
auto value = *c;
auto alt_value = c.value();
auto value_member = c->member;

// reset the value
c.reset();

// immediate recomputation
c.refresh();

auto c = stdx::cached{[] { return expensive_computation(); }};
using V = stdx::cached_value_t<decltype(c)>;

template <typename T>
consteval auto type_as_string() -> std::string_view;

template <auto E>
consteval auto enum_as_string() -> std::string_view;

auto s = stdx::ct_format<"Hello {} {}">(42, 17);
// s is stdx::format_result{"Hello {} {}"_cts, stdx::tuple{42, 17}}

auto s = stdx::ct_format<"Hello {} {}">(CX_VALUE(42), 17);
// s is stdx::format_result{"Hello 42 {}"_cts, stdx::tuple{17}}

auto s = stdx::ct_format<"Hello {} {}">(CX_VALUE(42), CX_VALUE(17));
// s is "Hello 42 17"_cts

enum struct E { value };
auto s = stdx::ct_format<"Hello {} {}">(CX_VALUE(int), CX_VALUE(E::value));
// s is "Hello int value"_cts

auto s = stdx::ct_format<"{}", sc::string_constant>(CX_VALUE(42));
// s is sc::string_constant<char, '4', '2'>{}

constexpr static auto a = stdx::ct_format<"The answer is {}">(42);
// a is stdx::format_result{"The answer is {}", stdx::tuple{42}}

constexpr static auto q = stdx::ct_format<"{}. But what is the question?">(CX_VALUE(a));
// q is stdx::format_result{"The answer is {}. But what is the question?", stdx::tuple{42}}

template <ct_string S>
struct named_thing { ... };

auto my_thing = named_thing<"mine">{};

template <ct_string S>
struct named_thing {
  template <ct_string Other>
  auto f() {
    // here we can:
    constexpr std::size_t sz = S.size();  // ask for ct_string's size
    constexpr bool is_empty = S.empty();  // ask whether a ct_string is empty
    constexpr bool equal = S == Other;    // compare two ct_strings

    // we can also convert to/from cib string constants
    constexpr auto cib_sc_string = stdx::ct_string_to_type<S, sc::string_constant>();
    constexpr auto stdx_ct_string = stdx::ct_string_from_type(cib_sc_string);
    static_assert(S == stdx_ct_string);

    // we can make a ct_string with a UDL:
    using namespace stdx::ct_string_literals;
    constexpr auto s = "Hello"_cts;

    // we can concatenate two ct_strings:
    constexpr auto s1 = "abc"_cts;
    constexpr auto s2 = "def"_cts;
    constexpr auto s3 = s1 + s2; // abcdef

    // and we can split a ct_string at the first occurrence of a character,
    // optaining a pair of ct_strings
    constexpr auto p = stdx::split<S, '/'>();
    // if the character doesn't exist, p.first is equal to S and p.second is empty
    // otherwise p.first is everything up to (but not including) the character,
    // and p.second is everything after (also not including)

    // we can also iterate over a ct_string
    for (auto c : S) { ... }

    // a ct_string can also explicitly convert to a std::string_view
    constexpr auto sv = static_cast<std::string_view>(S);

    // when required, we can access the underlying array of chars,
    // which includes the null terminator
    const auto& char_array = S.value;
  }
};

template <typename Key,
          typename Value,
          std::size_t N>
class cx_map;

template <typename K, typename V, std::size_t N>
auto f(stdx::cx_map<K, V, N> m) {
    // here we can:
    std::size_t sz = m.size(); // ask for m's size
    constexpr std::size_t cap = m.capacity(); // ask for m's capacity (same as N)
    bool is_empty = m.empty(); // ask whether a cx_map is empty
    bool is_full = m.full(); // ask whether a cx_map is full
    m.clear() // clear a cx_map

    // we can use some of the usual functions
    m.insert_or_assign(K{}, V{});
    m.put(K{}, V{}); // same as insert_or_assign
    V& v = m.get(K{});
    bool c = m.contains(K{});
    m.erase(K{});

    // and use iterators:
    // begin and end
    // cbegin and cend
    // (therefore also range-for loops)

    // we can also pop an arbitrary element
    auto [k, v] = m.pop_back();
};

template <typename Key,
          typename Value,
          std::size_t KeyN,
          std::size_t ValueN = KeyN>
class cx_multimap;

template <typename K, typename V, std::size_t KN, std::size_t VN>
auto f(stdx::cx_map<K, V, KN, VN> m) {
    // here we can:
    std::size_t sz = m.size(); // ask for m's size
    constexpr std::size_t cap = m.capacity(); // ask for m's capacity (same as KN)
    bool is_empty = m.empty(); // ask whether a cx_multimap is empty
    m.clear() // clear a cx_multimap

    m.insert(K{}); // make sure a key exists
    m.insert(K{}, V{}); // associate a value with a key
    m.put(K{}); // same as insert
    m.put(K{}, V{}); // same as insert

    auto& v = m.get(K{}); // v is a cx_set<V, VN>
    bool c1 = m.contains(K{});
    bool c2 = m.contains(K{}, V{});
    m.erase(K{});
    m.erase(K{}, V{});

    // and use iterators:
    // begin and end
    // cbegin and cend
    // (therefore also range-for loops)
};

template <typename T, std::size_t N,
          typename OverflowPolicy = safe_overflow_policy>
class cx_queue;

template <typename T, std::size_t N, typename P>
auto f(stdx::cx_queue<T, N, P> q) {
    // here we can:
    std::size_t sz = q.size(); // ask for q's size
    constexpr std::size_t cap = q.capacity(); // ask for q's capacity (same as N)
    bool is_empty = q.empty(); // ask whether a cx_queue is empty
    bool is_full = q.full(); // ask whether a cx_queue is full
    q.clear(); // clear a cx_queue

    // we can use some of the usual queue functions
    q.push(T{});
    T& t1 = q.front();
    T& t2 = q.back();
    T t = q.pop();
  }
};

struct custom_overflow_policy {
    constexpr static auto check_push(std::size_t size, std::size_t capacity) -> void {
      // push is safe if size < capacity
      // otherwise, overflow panic
    }
    constexpr static auto check_pop(std::size_t size) -> void {
      // pop is safe if size > 0
      // otherwise, underflow panic
    }
};

template <typename Key, std::size_t N>
class cx_set;

template <typename K, std::size_t N>
auto f(stdx::cx_set<K, N> s) {
    // here we can:
    std::size_t sz = s.size(); // ask for s's size
    constexpr std::size_t cap = s.capacity(); // ask for s's capacity (same as N)
    bool is_empty = m.empty(); // ask whether a cx_set is empty
    m.clear() // clear a cx_set

    // we can use some of the usual functions
    s.insert(K{});
    bool c = s.contains(K{});
    s.erase(K{});

    // and use iterators:
    // begin and end
    // cbegin and cend
    // (therefore also range-for loops)

    // we can also pop an arbitrary element
    auto k = s.pop_back();

    // and merge two sets (assuming s has capacity)
    s.merge(cx_set{1, 2, 3});
};

// s is a cx_set<int, 3>
auto s = cx_set{1, 2, 3};

template <typename T,
          std::size_t N>
class cx_vector;

template <typename T, std::size_t N>
auto f(stdx::cx_vector<T, N> v) {
    // here we can:
    std::size_t sz = v.size(); // ask for v's size
    constexpr std::size_t cap = v.capacity(); // ask for v's capacity (same as N)
    bool is_empty = v.empty(); // ask whether a cx_vector is empty
    bool is_full = v.full(); // ask whether a cx_vector is full
    bool equal = v == v; // compare two cx_vectors (of the same type)
    v.clear() // clear a cx_vector

    // we can use some of the usual functions
    v.push_back(T{});
    T& t1 = v[0];
    T& t2 = v.back();
    T t = v.pop_back();

    // and use iterators:
    // begin and end
    // cbegin and cend
    // rbegin and rend
    // crbegin and crend
    // (therefore also range-for loops)

    // we can have compile-time access with get
    T& t3 = get<0>(v);

    // and we can use resize_and_overwrite for efficient initialization
    resize_and_overwrite(v,
      [] (T* data, std::size_t sz) -> std::size_t {
        // copy Ts to data and return the new size
        return 0;
      });
  }
};

// v is a cx_vector<int, 3>
auto v = cx_vector{1, 2, 3};

auto f(int x, int y) -> void { /* do something with x and y */ }
stdx::for_each_n_args(f, 1, 2, 3, 4); // this calls f(1, 2) and f(3, 4)

auto f(auto x, auto y) -> void { /* do something with x and y */ }
stdx::for_each_n_args<2>(f, 1, 2, 3, 4); // this calls f(1, 2) and f(3, 4)

auto g(int x, int y, int z = 42) -> void { /* do something with x, y and z */ }
stdx::for_each_n_args<2>(g, 1, 2, 3, 4); // this calls g(1, 2, 42) and g(3, 4, 42)

auto f1() -> void {}
using f1_return = stdx::return_t<decltype(f1)>;         // void
using f1_args = stdx::args_t<decltype(f1), std::tuple>; // std::tuple<>

auto f2(int) -> int { return 0; }
using f2_return = stdx::return_t<decltype(f2)>;         // int
using f2_args = stdx::args_t<decltype(f2), std::tuple>; // std::tuple<int>

auto l = [] (int) -> int { return 0; };
using l_return = stdx::return_t<decltype(l)>;         // int
using l_args = stdx::args_t<decltype(l), std::tuple>; // std::tuple<int>

auto f(int&, std::string&) -> void {}
using f_args = stdx::decayed_args_t<decltype(f), std::tuple>; // std::tuple<int, std::string>

auto f(int&, std::string&) -> void {}
using f_arity_t = stdx::arity_t<decltype(f)>; // std::integral_constant<std::size_t, 2>
constexpr auto f_arity_v = stdx::arity_v<decltype(f)>;

auto f(int&) -> void {}
using first_arg_t = stdx::nth_arg_t<decltype(f), 0>; // int&
using first_decayed_arg_t = stdx::decayed_nth_arg_t<decltype(f), 0>; // int

auto l = [](auto, auto) -> void {};
using f_arity_t = stdx::arity_t<decltype(l)>; // std::integral_constant<std::size_t, 2>
constexpr auto f_arity_v = stdx::arity_v<decltype(l)>;

// A node in an intrusive_list must have a next pointer
struct node {
  node *next{};
};

stdx::intrusive_forward_list<node> l;

node n1{};
l.push_front(&n1);

node n2{};
l.push_back(&n2);

node n3{};
l.push_back(&n3);

node* nf = l.pop_front();

l.clear();
bool b = l.empty();

// A node in an intrusive_list must have prev and next pointers
struct node {
  node *prev{};
  node *next{};
};

stdx::intrusive_list<node> l;

node n1{};
l.push_front(&n1);

node n2{};
l.push_back(&n2);

node n3{};
auto i = std::find_if(std::begin(l), std::end(l), /* some predicate */);
l.insert(i, &n3); // insertion into the middle is constant-time

l.remove(&n2); // removal from the middle is constant-time
node* nf = l.pop_front();
node* nb = l.pop_back();

l.clear();
bool b = l.empty();

auto const a = std::array{1, 2, 3, 4};
constexpr auto c = stdx::ct_capacity(a); // std::size_t{4}

enum struct S1 : std::uint8_t { /* ... values ... */ };
static_assert(sizeof(S1) == 1);
static_assert(sizeof(std::optional<S1> == 2);

enum struct S2 : std::uint16_t { /* ... values ... */ };
static_assert(sizeof(S2) == 2);
static_assert(sizeof(std::optional<S2>) == 4);

enum struct S3 : std::uint32_t { /* ... values ... */ };
static_assert(sizeof(S3) == 4);
static_assert(sizeof(std::optional<S3>) == 8);

enum struct S : std::uint8_t { /* ... values ... */ };

template <> struct stdx::tombstone_traits<S> {
    // "-1" is not a valid value
    constexpr auto operator()() const {
        return static_cast<S>(std::uint8_t{0xffu});
    }
};

static_assert(sizeof(S) == 1);
static_assert(sizeof(stdx::optional<S> == 1);

struct custom_panic_handler {
  static auto panic(auto&&... args) noexcept -> void {
    // log args and then...
    std::terminate();
  }

template <stdx::ct_string S>
  static auto panic(auto&&... args) noexcept -> void {
    // log args (including the compile-time string) and then...
    std::terminate();
  }
};

template <> inline auto stdx::panic_handler<> = custom_panic_handler{};

template </*some strong constraint*/ T>
auto f(T t, stdx::priority_t<2>) {
  // highest priority: call this function if possible
}

template </*some weaker/less preferred constraint*/ T>
auto f(T t, stdx::priority_t<1>) {
  // call this function if the highest-priority overload can't be called
}

template <typename /*no constraint*/ T>
auto f(T t, stdx::priority_t<0>) {
  // fallback to this function if both higher priority overloads don't fit
}

// at the call site, use the highest priority
auto result = f(t, stdx::priority<2>);

// explicit type
auto x = stdx::rollover_t<std::uint8_t>{};

// deduced type: must be unsigned
auto y = stdx::rollover_t{1u}; // rollover_t<unsigned int>

template <typename T>
constexpr auto f() {
  STATIC_ASSERT(std::is_integral<T>,
                "f() must take an integral type, received {}", CX_VALUE(T));
}

f<float>(); // produces compile-time error

main.cpp:14:27: error: no matching member function for call to 'emit'
...
include/stdx/static_assert.hpp:16:18: note: because
'stаtiс_аssert<ct_string<47>{{"f() must take an integral type, received float"}}>' evaluated to false
   16 |         requires stаtiс_аssert<S>
      |                  ^