#ifndef CPP2_UTIL_H

#define CPP2_UTIL_H

#include <version>

#if !defined(_MSC_VER) && !defined(__cpp_lib_source_location)

#undef CPP2_USE_SOURCE_LOCATION

#endif

#if defined(CPP2_IMPORT_STD) || defined(CPP2_INCLUDE_STD)

// If C++23 'import std;' was requested but isn't available, fall back

// to the 'include std' path

#if defined(CPP2_IMPORT_STD) && defined(__cpp_lib_modules)

import std.compat;

// If 'include std' was requested, include all standard headers.

// This list tracks the current draft standard, so as of this

// writing includes draft C++26 headers like <debugging>.

// Use a feature test #ifdef for each header that isn't supported

// by all of { VS 2022, g++-10, clang++-12 }

#else

#ifdef _MSC_VER

#include "intrin.h"

#endif

#include <algorithm>

#include <any>

#include <array>

#include <atomic>

#ifdef __cpp_lib_barrier

#include <barrier>

#endif

#include <bit>

#include <bitset>

#include <cassert>

#include <cctype>

#include <cerrno>

#include <cfenv>

#include <cfloat>

#include <charconv>

#include <chrono>

#include <cinttypes>

#include <climits>

#include <clocale>

#include <cmath>

#include <codecvt>

#include <compare>

#include <complex>

#include <concepts>

#include <condition_variable>

#ifdef __cpp_lib_coroutine

#include <coroutine>

#endif

#include <csetjmp>

#include <csignal>

#include <cstdarg>

#include <cstddef>

#include <cstdint>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#if __has_include(<cuchar>)

#include <cuchar>

#endif

#include <cwchar>

#include <cwctype>

#ifdef __cpp_lib_debugging

#include <debugging>

#endif

#include <deque>

#ifndef CPP2_NO_EXCEPTIONS

#include <exception>

#endif

// libstdc++ currently has a dependency on linking TBB if <execution> is

// included, and TBB seems to be not automatically installed and linkable

// on some GCC installations, so let's not pull in that little-used header

// in our -pure-cpp2 "import std;" simulation mode... if you need this,

// use mixed mode (not -pure-cpp2) and #include all the headers you need

// including this one

//

// #include <execution>

#ifdef __cpp_lib_expected

#include <expected>

#endif

#include <filesystem>

#if defined(__cpp_lib_format) || (defined(_MSC_VER) && _MSC_VER >= 1929)

#include <format>

#endif

#ifdef __cpp_lib_flat_map

#include <flat_map>

#endif

#ifdef __cpp_lib_flat_set

#include <flat_set>

#endif

#include <forward_list>

#include <fstream>

#include <functional>

#include <future>

#ifdef __cpp_lib_generator

#include <generator>

#endif

#ifdef __cpp_lib_hazard_pointer

#include <hazard_pointer>

#endif

#include <initializer_list>

#include <iomanip>

#include <ios>

#include <iosfwd>

#include <iostream>

#include <iso646.h>

#include <istream>

#include <iterator>

#ifdef __cpp_lib_latch

#include <latch>

#endif

#include <limits>

#ifdef __cpp_lib_linalg

#include <linalg>

#endif

#include <list>

#include <locale>

#include <map>

#ifdef __cpp_lib_mdspan

#include <mdspan>

#endif

#include <memory>

#ifdef __cpp_lib_memory_resource

#include <memory_resource>

#endif

#include <mutex>

#include <new>

#include <numbers>

#include <numeric>

#include <optional>

#include <ostream>

#ifdef __cpp_lib_print

#include <print>

#endif

#include <queue>

#include <random>

#include <ranges>

#include <ratio>

#ifdef __cpp_lib_rcu

#include <rcu>

#endif

#include <regex>

#include <scoped_allocator>

#ifdef __cpp_lib_semaphore

#include <semaphore>

#endif

#include <set>

#include <shared_mutex>

#ifdef __cpp_lib_source_location

#include <source_location>

#endif

#include <span>

#ifdef __cpp_lib_spanstream

#include <spanstream>

#endif

#include <sstream>

#include <stack>

#ifdef __cpp_lib_stacktrace

#include <stacktrace>

#endif

#ifdef __cpp_lib_stdatomic_h

#include <stdatomic.h>

#endif

#include <stdexcept>

#if __has_include(<stdfloat>)

#if !defined(_MSC_VER) || _HAS_CXX23

#include <stdfloat>

#endif

#endif

#ifdef __cpp_lib_jthread

#include <stop_token>

#endif

#include <streambuf>

#include <string>

#include <string_view>

#ifdef __cpp_lib_syncbuf

#include <syncstream>

#endif

#include <system_error>

#ifdef __cpp_lib_text_encoding

#include <text_encoding>

#endif

#include <thread>

#include <tuple>

#include <type_traits>

#include <typeindex>

#ifndef CPP2_NO_RTTI

#include <typeinfo>

#endif

#include <unordered_map>

#include <unordered_set>

#include <utility>

#include <valarray>

#include <variant>

#include <vector>

#endif

#else

#ifdef _MSC_VER

#include "intrin.h"

#endif

#include <algorithm>

#include <any>

#include <compare>

#include <concepts>

#include <cstddef>

#include <cstdint>

#include <cstdio>

#ifndef CPP2_NO_EXCEPTIONS

#include <exception>

#endif

#ifdef __cpp_lib_expected

#include <expected>

#endif

#if defined(__cpp_lib_format) || (defined(_MSC_VER) && _MSC_VER >= 1929)

#include <format>

#endif

#include <functional>

#include <iostream>

#include <iterator>

#include <limits>

#include <memory>

#include <new>

#include <random>

#include <optional>

#if defined(CPP2_USE_SOURCE_LOCATION)

#include <source_location>

#endif

#include <span>

#include <string>

#include <string_view>

#include <system_error>

#include <tuple>

#include <type_traits>

#ifndef CPP2_NO_RTTI

#include <typeinfo>

#endif

#include <utility>

#include <variant>

#include <vector>

#endif

#define CPP2_TYPEOF(x) std::remove_cvref_t<decltype(x)>

#if __cplusplus >= 202302L && \

( \

(defined(__clang_major__) && __clang_major__ >= 15) \

|| (defined(__GNUC__) && __GNUC__ >= 12) \

)

#define CPP2_COPY(x) auto(x)

#else

#define CPP2_COPY(x) CPP2_TYPEOF(x)(x)

#endif

#define CPP2_FORWARD(x) std::forward<decltype(x)>(x)

#define CPP2_PACK_EMPTY(x) (sizeof...(x) == 0)

#define CPP2_CONTINUE_BREAK(NAME) goto CONTINUE_##NAME; CONTINUE_##NAME: continue; goto BREAK_##NAME; BREAK_##NAME: break;

// these redundant goto's to avoid 'unused label' warnings

#if defined(_MSC_VER)

// MSVC can't handle 'inline constexpr' yet in all cases

#define CPP2_CONSTEXPR const

#else

#define CPP2_CONSTEXPR constexpr

#endif

namespace cpp2 {

using i8 = std::int8_t ;

using i16 = std::int16_t ;

using i32 = std::int32_t ;

using i64 = std::int64_t ;

using u8 = std::uint8_t ;

using u16 = std::uint16_t ;

using u32 = std::uint32_t ;

using u64 = std::uint64_t ;

using ushort = unsigned short;

using uint = unsigned int;

using ulong = unsigned long;

using longlong = long long;

using ulonglong = unsigned long long;

using longdouble = long double;

using _schar = signed char; // normally use i8 instead

using _uchar = unsigned char; // normally use u8 instead

template<typename Ret, typename Arg>

auto argument_of_helper(Ret(*) (Arg)) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg)) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg)&) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg)&&) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg) const) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg) const&) -> Arg;

template<typename Ret, typename F, typename Arg>

auto argument_of_helper(Ret(F::*) (Arg) const&&) -> Arg;

template <typename F>

auto argument_of_helper(F const&) -> CPP2_TYPEOF(argument_of_helper(&F::operator()));

template <typename T>

using argument_of_t = CPP2_TYPEOF(argument_of_helper(std::declval<T>()));

template <typename F>

auto argument_of_helper_op_is(F const&) -> CPP2_TYPEOF(argument_of_helper(&F::op_is));

template <typename T>

using argument_of_op_is_t = CPP2_TYPEOF(argument_of_helper_op_is(std::declval<T>()));

template <typename T>

using pointee_t = std::iter_value_t<T>;

template <template <typename...> class C, typename... Ts>

constexpr auto specialization_of_template_helper(C< Ts...> const& ) -> std::true_type {

return {};

}

template <template <typename, auto...> class C, typename T, auto... Ns>

requires (sizeof...(Ns) > 0)

constexpr auto specialization_of_template_helper(C< T, Ns... > const& ) -> std::true_type {

return {};

}

template <typename X, template<typename...> class C>

concept specialization_of_template = requires (X x) {

{ specialization_of_template_helper<C>(std::forward<X>(x)) } -> std::same_as<std::true_type>;

};

template <typename X, template<typename,auto...> class C>

concept specialization_of_template_type_and_nttp = requires (X x) {

{ specialization_of_template_helper<C>(std::forward<X>(x)) } -> std::same_as<std::true_type>;

};

template <typename X>

concept dereferencable = requires (X x) { *x; };

template <typename X>

concept default_constructible = std::is_default_constructible_v<std::remove_cvref_t<X>>;

template <typename X>

concept bounded_array = std::is_bounded_array_v<std::remove_cvref_t<X>>;

template <typename X>

concept pointer_like = dereferencable<X> && default_constructible<X> && std::equality_comparable<X>

&& !bounded_array<X>;

template< typename From, typename To >

concept brace_initializable_to = requires (From x) { To{x}; };

template< typename X, typename C >

concept same_type_as = std::same_as<std::remove_cvref_t<X>, std::remove_cvref_t<C>>;

template <typename X>

concept defined = requires { std::declval<X>(); };

template <typename X>

concept has_defined_argument = requires {

std::declval<argument_of_t<X>>();

};

template <typename X, typename F>

concept covertible_to_argument_of = same_type_as<X,argument_of_t<F>>

|| (pointer_like<argument_of_t<F>> && brace_initializable_to<X, pointee_t<argument_of_t<F>>>)

|| (!pointer_like<argument_of_t<F>> && brace_initializable_to<X, argument_of_t<F>>)

;

template <typename F, typename X>

concept valid_predicate = (std::predicate<F, X> && !has_defined_argument<F>)

|| (std::predicate<F, X> && has_defined_argument<F> && covertible_to_argument_of<X, F>);

template <typename X, typename O, auto mem_fun_ptr>

concept predicate_member_fun = requires (X x, O o) {

{ (o.*mem_fun_ptr)(x) } -> std::convertible_to<bool>;

};

template <typename F, typename X>

concept valid_custom_is_operator = predicate_member_fun<X, F, &F::op_is>

&& (

!defined<argument_of_op_is_t<F>>

|| brace_initializable_to<X, argument_of_op_is_t<F>>

);

template <typename T>

requires (std::is_copy_constructible_v<std::remove_cvref_t<T>>)

auto move(T&& t) -> decltype(auto) {

return std::move(t);

}

template <typename T>

requires (!std::is_copy_constructible_v<std::remove_cvref_t<T>>)

auto move(T&& t) -> decltype(auto) {

return std::forward<T>(t);

}

inline constexpr auto max(auto... values) {

return std::max( { values... } );

}

template <class T, class... Ts>

inline constexpr auto is_any = std::disjunction_v<std::is_same<T, Ts>...>;

template <std::size_t Len, std::size_t Align>

struct aligned_storage {

alignas(Align) unsigned char data[Len];

};

template <typename T>

requires requires { *std::declval<T&>(); }

using deref_t = decltype(*std::declval<T&>());

template <typename T>

auto pointer_eq(T const* a, T const* b) {

return std::compare_three_way{}(a, b) == std::strong_ordering::equal;

}

#ifdef CPP2_USE_SOURCE_LOCATION

#define CPP2_SOURCE_LOCATION_PARAM , std::source_location where

#define CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT , std::source_location where = std::source_location::current()

#define CPP2_SOURCE_LOCATION_PARAM_SOLO std::source_location where

#define CPP2_SOURCE_LOCATION_ARG , where

#else

#define CPP2_SOURCE_LOCATION_PARAM

#define CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT

#define CPP2_SOURCE_LOCATION_PARAM_SOLO

#define CPP2_SOURCE_LOCATION_ARG

#endif

#define CPP2_MESSAGE_PARAM char const*

#define CPP2_CONTRACT_MSG cpp2::message_to_cstr_adapter

inline auto message_to_cstr_adapter( CPP2_MESSAGE_PARAM msg ) -> CPP2_MESSAGE_PARAM { return msg ? msg : ""; }

inline auto message_to_cstr_adapter( std::string const& msg ) -> CPP2_MESSAGE_PARAM { return msg.c_str(); }

class contract_group {

};

[[noreturn]] inline auto report_and_terminate(std::string_view group, CPP2_MESSAGE_PARAM msg = "" CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) noexcept -> void {

}

auto inline cpp2_default = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Contract", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline bounds_safety = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Bounds safety", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline null_safety = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Null safety", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline type_safety = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Type safety", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline testing = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Testing", msg CPP2_SOURCE_LOCATION_ARG);

}

);

namespace impl {

template<typename T>

concept UniquePtr = std::is_same_v<T, std::unique_ptr<typename T::element_type, typename T::deleter_type>>;

template<typename T>

concept SharedPtr = std::is_same_v<T, std::shared_ptr<typename T::element_type>>;

template<typename T>

concept Optional = std::is_same_v<T, std::optional<typename T::value_type>>;

#ifdef __cpp_lib_expected

template<typename T>

concept Expected = std::is_same_v<T, std::expected<typename T::value_type, typename T::error_type>>;

#endif

auto assert_not_null(auto&& arg CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> decltype(auto)

}

#define CPP2_ASSERT_IN_BOUNDS_IMPL \

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

requires { std::size(x); std::ssize(x); x[arg]; std::begin(x) + 2; }) \

{ \

auto max = [&]() -> auto { \

if constexpr (std::is_signed_v<CPP2_TYPEOF(arg)>) { return std::ssize(x); } \

else { return std::size(x); } \

}; \

auto msg = "out of bounds access attempt detected - attempted access at index " + std::to_string(arg) + ", "; \

if (max() > 0 ) { \

msg += "[min,max] range is [0," + std::to_string(max()-1) + "]"; \

} \

else { \

msg += "but container is empty"; \

} \

if (!(0 <= arg && arg < max())) { \

bounds_safety.report_violation(msg.c_str() CPP2_SOURCE_LOCATION_ARG); \

} \

return CPP2_FORWARD(x) [ arg ]; \

}

template<auto arg>

auto assert_in_bounds(auto&& x CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> decltype(auto)

CPP2_ASSERT_IN_BOUNDS_IMPL

auto assert_in_bounds(auto&& x, auto&& arg CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> decltype(auto)

CPP2_ASSERT_IN_BOUNDS_IMPL

template<auto arg>

auto assert_in_bounds(auto&& x CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> decltype(auto)

{

return CPP2_FORWARD(x) [ arg ];

}

auto assert_in_bounds(auto&& x, auto&& arg CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> decltype(auto)

{

return CPP2_FORWARD(x) [ CPP2_FORWARD(arg) ];

}

#define CPP2_ASSERT_IN_BOUNDS(x,arg) (cpp2::impl::assert_in_bounds((x),(arg)))

#define CPP2_ASSERT_IN_BOUNDS_LITERAL(x,arg) (cpp2::impl::assert_in_bounds<(arg)>(x))

#ifdef CPP2_NO_RTTI

constexpr auto process_type_name(std::string_view name) -> std::string_view {

}

template<typename T>

constexpr auto type_name() -> std::string_view {

}

#endif

[[noreturn]] auto Throw(auto&& x, [[maybe_unused]] char const* msg) -> void {

}

inline auto Uncaught_exceptions() -> int {

}

template<typename T>

auto Dynamic_cast( [[maybe_unused]] auto&& x ) -> decltype(auto) {

}

template<typename T>

auto Typeid() -> decltype(auto) {

}

auto Typeid( [[maybe_unused]] auto&& x ) -> decltype(auto) {

}

} // impl

struct {

template<typename T>

[[nodiscard]] auto cpp2_new(auto&& ...args) const -> std::unique_ptr<T> {

}

} inline unique;

[[maybe_unused]] struct {

template<typename T>

[[nodiscard]] auto cpp2_new(auto&& ...args) const -> std::shared_ptr<T> {

}

} inline shared;

template<typename T>

[[nodiscard]] auto cpp2_new(auto&& ...args) -> std::unique_ptr<T> {

return unique.cpp2_new<T>(CPP2_FORWARD(args)...);

}

namespace impl {

template<typename T>

constexpr bool prefer_pass_by_value =

sizeof(T) <= 2*sizeof(void*)

&& std::is_trivially_copy_constructible_v<T>;

template<typename T>

requires std::is_class_v<T> || std::is_union_v<T> || std::is_array_v<T> || std::is_function_v<T>

constexpr bool prefer_pass_by_value<T> = false;

template<typename T>

requires (!std::is_void_v<T>)

using in =

std::conditional_t <

prefer_pass_by_value<T>,

T const,

T const&

>;

template<typename T>

class deferred_init {

};

template<typename T>

class out {