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;

alignas(T) std::byte data[sizeof(T)]; // or: std::aligned_storage_t<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&& that) noexcept

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

{ }

final_action_success(final_action_success const&) = delete;

void operator= (final_action_success const&) = 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);

requires (std::is_convertible_v<T, std::string_view>

&& !std::is_convertible_v<T, const char*>)

{

return std::string{sv};

if (o.has_value()) {

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

}

return "(empty)";

{

if (v.valueless_by_exception()) return "(empty)";

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

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

return std::visit([](auto&& arg) -> std::string {

return cpp2::to_string(arg);

}, v);

{

if constexpr (sizeof...(Ts) == 0) {

return "()";

} else {

std::string out = "(" + cpp2::to_string(std::get<0>(t));

std::apply([&out](auto&&, auto&&... args) {

((out += ", " + cpp2::to_string(args)), ...);

}, t);

out += ")";

return out;

}

T t;

void (*dtor)(void*);

template<typename D>

c_raii( T t_, D d )

: t{ t_ }

, dtor{ [](void* x) { (void)(D)(x); } }

{ }

~c_raii() { if (dtor) dtor(t); }

operator T&() { return t; }

c_raii(c_raii const&) = delete;

auto operator=(c_raii const&) = delete;

c_raii(c_raii&& that) : t {std::move(that.t)}, dtor {that.dtor} { that.dtor = nullptr; }

auto operator=(c_raii&& that) { t = std::move(that.t); dtor = that.dtor; that.dtor = nullptr; }

auto x = std::fopen(filename, mode);

if (!x) {

throw std::make_error_condition(std::errc::no_such_file_or_directory);

}

return c_raii( x, &fclose );