#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_syncstream

#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

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<std::size_t N>

struct String

};

#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 Default = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Contract", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline Bounds = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Bounds safety", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline Null = contract_group(

[](CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM)noexcept {

report_and_terminate("Null safety", msg CPP2_SOURCE_LOCATION_ARG);

}

);

auto inline Type = 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);

}

);

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.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::assert_in_bounds((x),(arg)))

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

[[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) {

}

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)...);

}

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 {

};

#define CPP2_FORCE_INLINE_LAMBDA_CLANG /* empty */

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

#define CPP2_FORCE_INLINE __forceinline

#define CPP2_FORCE_INLINE_LAMBDA [[msvc::forceinline]]

#define CPP2_LAMBDA_NO_DISCARD

#else

#define CPP2_FORCE_INLINE __attribute__((always_inline))

#if defined(__clang__)

#define CPP2_FORCE_INLINE_LAMBDA /* empty */

#undef CPP2_FORCE_INLINE_LAMBDA_CLANG

#define CPP2_FORCE_INLINE_LAMBDA_CLANG __attribute__((always_inline))

#else

#define CPP2_FORCE_INLINE_LAMBDA __attribute__((always_inline))

#endif

#if defined(__clang_major__)

// Also check __cplusplus, only to satisfy Clang -pedantic-errors

#if __cplusplus >= 202302L && (__clang_major__ > 13 || (__clang_major__ == 13 && __clang_minor__ >= 2))

#define CPP2_LAMBDA_NO_DISCARD [[nodiscard]]

#else

#define CPP2_LAMBDA_NO_DISCARD

#endif

#elif defined(__GNUC__)

#if __GNUC__ >= 9

#define CPP2_LAMBDA_NO_DISCARD [[nodiscard]]

#else

#define CPP2_LAMBDA_NO_DISCARD

#endif

#if ((__GNUC__ * 100) + __GNUC_MINOR__) < 1003

// GCC 10.2 doesn't support this feature (10.3 is fine)

#undef CPP2_FORCE_INLINE_LAMBDA

#define CPP2_FORCE_INLINE_LAMBDA

#endif

#else

#define CPP2_LAMBDA_NO_DISCARD

#endif

#endif

#define CPP2_UFCS_IDENTITY(...) __VA_ARGS__

#define CPP2_UFCS_REMPARENS(...) __VA_ARGS__

#define CPP2_UFCS_IS_NOTHROW(MVFWD,QUALID,TEMPKW,...) \

requires { requires requires { std::declval<Obj>().CPP2_UFCS_REMPARENS QUALID TEMPKW __VA_ARGS__(std::declval<Params>()...); }; \

requires noexcept(std::declval<Obj>().CPP2_UFCS_REMPARENS QUALID TEMPKW __VA_ARGS__(std::declval<Params>()...)); } \

|| requires { requires !requires { std::declval<Obj>().CPP2_UFCS_REMPARENS QUALID TEMPKW __VA_ARGS__(std::declval<Params>()...); }; \

requires noexcept(MVFWD(CPP2_UFCS_REMPARENS QUALID __VA_ARGS__)(std::declval<Obj>(), std::declval<Params>()...)); }

#define CPP2_UFCS_IS_NOTHROW_PARAM(...) /*empty*/

#define CPP2_UFCS_IS_NOTHROW_ARG(MVFWD,QUALID,TEMPKW,...) CPP2_UFCS_IS_NOTHROW(MVFWD,QUALID,TEMPKW,__VA_ARGS__)

#if defined(__GNUC__) && !defined(__clang__)

#undef CPP2_UFCS_IS_NOTHROW_PARAM

#undef CPP2_UFCS_IS_NOTHROW_ARG

#define CPP2_UFCS_IS_NOTHROW_PARAM(MVFWD,QUALID,TEMPKW,...) , bool IsNothrow = CPP2_UFCS_IS_NOTHROW(MVFWD,QUALID,TEMPKW,__VA_ARGS__)

#define CPP2_UFCS_IS_NOTHROW_ARG(...) IsNothrow

#if __GNUC__ < 11

#undef CPP2_UFCS_IS_NOTHROW_PARAM

#undef CPP2_UFCS_IS_NOTHROW_ARG

#define CPP2_UFCS_IS_NOTHROW_PARAM(...) /*empty*/

#define CPP2_UFCS_IS_NOTHROW_ARG(...) false // GCC 10 UFCS is always potentially-throwing.

#endif

#endif

#define CPP2_UFCS_CONSTRAINT_PARAM(...) /*empty*/

#define CPP2_UFCS_CONSTRAINT_ARG(MVFWD,QUALID,TEMPKW,...) \

requires { CPP2_FORWARD(obj).CPP2_UFCS_REMPARENS QUALID TEMPKW __VA_ARGS__(CPP2_FORWARD(params)...); } \

|| requires { MVFWD(CPP2_UFCS_REMPARENS QUALID __VA_ARGS__)(CPP2_FORWARD(obj), CPP2_FORWARD(params)...); }

#if defined(_MSC_VER)

#undef CPP2_UFCS_CONSTRAINT_PARAM

#undef CPP2_UFCS_CONSTRAINT_ARG

#define CPP2_UFCS_CONSTRAINT_PARAM(MVFWD,QUALID,TEMPKW,...) , bool IsViable = \

requires { std::declval<Obj>().CPP2_UFCS_REMPARENS QUALID TEMPKW __VA_ARGS__(std::declval<Params>()...); } \

|| requires { MVFWD(CPP2_UFCS_REMPARENS QUALID __VA_ARGS__)(std::declval<Obj>(), std::declval<Params>()...); }

#define CPP2_UFCS_CONSTRAINT_ARG(...) IsViable

#endif

#define CPP2_UFCS_(LAMBDADEFCAPT,MVFWD,QUALID,TEMPKW,...) \

[LAMBDADEFCAPT]< \

typename Obj, typename... Params \

CPP2_UFCS_IS_NOTHROW_PARAM(MVFWD,QUALID,TEMPKW,__VA_ARGS__) \

CPP2_UFCS_CONSTRAINT_PARAM(MVFWD,QUALID,TEMPKW,__VA_ARGS__) \

> \

CPP2_LAMBDA_NO_DISCARD (Obj&& obj, Params&& ...params) CPP2_FORCE_INLINE_LAMBDA_CLANG \

noexcept(CPP2_UFCS_IS_NOTHROW_ARG(MVFWD,QUALID,TEMPKW,__VA_ARGS__)) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) \

requires CPP2_UFCS_CONSTRAINT_ARG(MVFWD,QUALID,TEMPKW,__VA_ARGS__) { \

if constexpr (requires{ CPP2_FORWARD(obj).CPP2_UFCS_REMPARENS QUALID TEMPKW __VA_ARGS__(CPP2_FORWARD(params)...); }) { \

return CPP2_FORWARD(obj).CPP2_UFCS_REMPARENS QUALID TEMPKW __VA_ARGS__(CPP2_FORWARD(params)...); \

} else { \

return MVFWD(CPP2_UFCS_REMPARENS QUALID __VA_ARGS__)(CPP2_FORWARD(obj), CPP2_FORWARD(params)...); \

} \

}

#define CPP2_UFCS(...) CPP2_UFCS_(&,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)

#define CPP2_UFCS_MOVE(...) CPP2_UFCS_(&,std::move,(),,__VA_ARGS__)

#define CPP2_UFCS_FORWARD(...) CPP2_UFCS_(&,CPP2_FORWARD,(),,__VA_ARGS__)

#define CPP2_UFCS_TEMPLATE(...) CPP2_UFCS_(&,CPP2_UFCS_IDENTITY,(),template,__VA_ARGS__)

#define CPP2_UFCS_QUALIFIED_TEMPLATE(QUALID,...) CPP2_UFCS_(&,CPP2_UFCS_IDENTITY,QUALID,template,__VA_ARGS__)

#define CPP2_UFCS_NONLOCAL(...) CPP2_UFCS_(,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)

#define CPP2_UFCS_TEMPLATE_NONLOCAL(...) CPP2_UFCS_(,CPP2_UFCS_IDENTITY,(),template,__VA_ARGS__)

#define CPP2_UFCS_QUALIFIED_TEMPLATE_NONLOCAL(QUALID,...) CPP2_UFCS_(,CPP2_UFCS_IDENTITY,QUALID,template,__VA_ARGS__)

struct nonesuch_ {

auto operator==(auto const&) -> bool { return false; }

};

constexpr inline nonesuch_ nonesuch;

inline auto to_string(...) -> std::string

{

return "(customize me - no cpp2::to_string overload exists for this type)";

}

inline auto to_string(nonesuch_) -> std::string

{

return "(invalid type)";

}

inline auto to_string(std::same_as<std::any> auto const&) -> std::string

{

return "std::any";

}

inline auto to_string(bool b) -> std::string

{

return b ? "true" : "false";

}

template<typename T>

inline auto to_string(T const& t) -> std::string

}

inline auto to_string(char const& t) -> std::string

{

return std::string{t};

}

inline auto to_string(char const* s) -> std::string

{

return std::string{s};

}