using handler = void (*)(CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM);

constexpr contract_group (handler h = nullptr) : reporter(h) { }

constexpr auto set_handler(handler h) -> handler;

constexpr auto get_handler() const -> handler { return reporter; }

constexpr auto expects (bool b, CPP2_MESSAGE_PARAM msg = "" CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT)

-> void { if (!b) reporter(msg CPP2_SOURCE_LOCATION_ARG); }

handler reporter;

std::cerr

#ifdef CPP2_USE_SOURCE_LOCATION

<< where.file_name() << "("

<< where.line() << ") "

<< where.function_name() << ": "

#endif

<< group << " violation";

if (msg[0] != '\0') {

std::cerr << ": " << msg;

}

std::cerr << "\n";

std::terminate();

Default.expects(h);

auto old = reporter;

reporter = h;

return old;

{

// NOTE: This "!= T{}" test may or may not work for STL iterators. The standard

// doesn't guarantee that using == and != will reliably report whether an

// STL iterator has the default-constructed value

Null.expects(p != CPP2_TYPEOF(p){}, "dynamic null dereference attempt detected" CPP2_SOURCE_LOCATION_ARG);

return std::forward<decltype(p)>(p);

requires (std::is_integral_v<CPP2_TYPEOF(arg)> &&

requires { std::ssize(x); x[arg]; })

{

Bounds.expects(0 <= arg && arg < std::ssize(x), "out of bounds access attempt detected" CPP2_SOURCE_LOCATION_ARG);

return std::forward<decltype(x)>(x) [ std::forward<decltype(arg)>(arg) ];

requires (!(std::is_integral_v<CPP2_TYPEOF(arg)> &&

requires { std::ssize(x); x[arg]; }))

{

return std::forward<decltype(x)>(x) [ std::forward<decltype(arg)>(arg) ];

bool init = false;

std::aligned_storage<sizeof(T), alignof(T)> data;

auto t() -> T& { return *std::launder(reinterpret_cast<T*>(&data)); }

template<typename U>

friend class out;

deferred_init() noexcept { }

~deferred_init() noexcept { if (init) t().~T(); }

auto value() noexcept -> T& { Default.expects(init); return t(); }

auto construct (auto&& ...args) -> void { Default.expects(!init); new (&data) T(std::forward<decltype(args)>(args)...); init = true; }

auto construct_list(auto&& ...args) -> void { Default.expects(!init); new (&data) T{std::forward<decltype(args)>(args)...}; init = true; }

// Not going to bother with std::variant here

union {

T* t;

deferred_init<T>* dt;

};

int uncaught_count = std::uncaught_exceptions();

bool has_t;

bool called_construct = false;

out(T* t) noexcept : t{t}, has_t{true} { }

out(deferred_init<T>* dt) noexcept : dt{dt}, has_t{false} { }

// In the case of an exception, if the parameter was uninitialized

// then leave it in the same state on exit (strong guarantee)

~out() {

if (called_construct && uncaught_count != std::uncaught_exceptions()) {

Default.expects(!has_t);

dt->value().~T();

}

}

auto construct (auto ...args) -> void {

if (has_t) {

*t = T(args...);

}

else if (dt->init) {

dt->value() = T(args...);

}

else {

dt->construct(args...);

called_construct = true;

}

}

auto construct_list(auto ...args) -> void {

if (has_t) {

*t = T{args...};

}

else if (dt->init) {

dt->value() = T{args...};

}

else {

dt->construct_list(args...);

called_construct = true;

}

}

requires (!std::is_same_v<C, X> && requires { C{x}; })

{

return C{x};

if constexpr (I < std::variant_size_v<std::variant<Ts...>>) {

return std::get<I>( x );

}

else {

return nonesuch;

}

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<0>(x)), T >) if (x.index() == 0) return true;

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<1>(x)), T >) if (x.index() == 1) return true;

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<2>(x)), T >) if (x.index() == 2) return true;

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<3>(x)), T >) if (x.index() == 3) return true;

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<4>(x)), T >) if (x.index() == 4) return true;

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<5>(x)), T >) if (x.index() == 5) return true;

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<6>(x)), T >) if (x.index() == 6) return true;

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<7>(x)), T >) if (x.index() == 7) return true;

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<8>(x)), T >) if (x.index() == 8) return true;

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<9>(x)), T >) if (x.index() == 9) return true;

if constexpr (std::is_same_v< T, empty > ) {

if (x.valueless_by_exception()) return true;

// Need to guard this with is_any otherwise the get_if is illegal

if constexpr (is_any<std::monostate, Ts...>) return std::get_if<std::monostate>(&x) != nullptr;

}

return false;

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<0>(x)), T >) if (x.index() == 0) return operator_as<0>(x);

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<1>(x)), T >) if (x.index() == 1) return operator_as<1>(x);

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<2>(x)), T >) if (x.index() == 2) return operator_as<2>(x);

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<3>(x)), T >) if (x.index() == 3) return operator_as<3>(x);

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<4>(x)), T >) if (x.index() == 4) return operator_as<4>(x);

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<5>(x)), T >) if (x.index() == 5) return operator_as<5>(x);

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<6>(x)), T >) if (x.index() == 6) return operator_as<6>(x);

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<7>(x)), T >) if (x.index() == 7) return operator_as<7>(x);

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<8>(x)), T >) if (x.index() == 8) return operator_as<8>(x);

if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<9>(x)), T >) if (x.index() == 9) return operator_as<9>(x);

throw std::bad_variant_access();

{

explicit final_action_success(const F& ff) noexcept : f{ff} { }

explicit final_action_success(F&& ff) noexcept : f{std::move(ff)} { }

~final_action_success() noexcept

{

if (invoke && ecount == std::uncaught_exceptions()) {

f();

}

}

final_action_success(final_action_success&& other) noexcept

: f(std::move(other.f)), invoke(std::exchange(other.invoke, false))

{ }

final_action_success(const final_action_success&) = delete;

void operator=(const final_action_success&) = delete;

void operator=(final_action_success&&) = delete;

F f;

int ecount = std::uncaught_exceptions();

bool invoke = true;

requires requires { std::to_string(t); }

{

return std::to_string(t);

if (o.has_value()) {

return std::to_string(o.value());

}

return "(empty)";