1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
#pragma once
using uint8_t = unsigned char;
using uint16_t = unsigned short;
using uint32_t = unsigned int;
using uint64_t = unsigned long long;
using int8_t = signed char;
using int16_t = signed short;
using int32_t = signed int;
using int64_t = signed long long;
using size_t = uint64_t;
using uintptr_t = uint64_t;
static_assert(sizeof(size_t) == sizeof(void*), "size_t should be pointer size");
static_assert(sizeof(uintptr_t) == sizeof(void*), "size_t should be pointer size");
namespace std
{
template<typename T> concept integral = __is_integral(T);
template<typename T> concept signed_integral = integral<T> && __is_signed(T);
template<typename T> concept unsigned_integral = integral<T> && __is_unsigned(T);
template<typename T> constexpr bool is_trivially_destructible_v = __is_trivially_destructible(T);
template<typename T, typename... Args> constexpr bool is_constructible_v = __is_constructible(T, Args...);
template<typename T> constexpr bool is_trivially_copyable_v = __is_trivially_copyable(T);
template<typename U, typename V> constexpr bool _is_same_helper = false;
template<typename T> constexpr bool _is_same_helper<T, T> = true;
template<typename U, typename V> concept same_as = _is_same_helper<U, V> && _is_same_helper<V, U>;
template<typename T> struct make_void { using type = void; };
template<typename T> using void_t = make_void<T>::type;
template<typename T, typename = void> struct _add_reference_helper { using lvalue = T; using rvalue = T; };
template<typename T> struct _add_reference_helper<T, void_t<T&>> { using lvalue = T&; using rvalue = T&&; };
template<typename T> using add_lvalue_reference_t = _add_reference_helper<T>::lvalue;
template<typename T> using add_rvalue_reference_t = _add_reference_helper<T>::rvalue;
template<typename T> struct remove_reference { using type = T; };
template<typename T> struct remove_reference<T&> { using type = T; };
template<typename T> struct remove_reference<T&&> { using type = T; };
template<typename T> using remove_reference_t = remove_reference<T>::type;
template<typename T>
consteval add_rvalue_reference_t<T> declval()
{
static_assert(false, "Don't use declval outside of constant evaluation");
}
template<typename From, typename To>
concept convertible_to = __is_convertible(From, To) && requires { static_cast<To>(declval<From>()); };
template<typename T>
constexpr remove_reference_t<T>&& move(T&& r) noexcept
{
return static_cast<remove_reference_t<T>&&>(r);
}
template<typename T>
constexpr T&& forward(remove_reference_t<T>& r) noexcept
{
return static_cast<T&&>(r);
}
template<typename T>
constexpr T&& forward(remove_reference_t<T>&& r) noexcept // NOLINT
{
return static_cast<T&&>(r);
}
template<typename T, typename U>
constexpr T exchange(T& obj, U&& new_value)
{
T old_value = std::move(obj);
obj = std::forward<U>(new_value);
return old_value;
}
enum __attribute__((__may_alias__)) byte : uint8_t {};
static_assert(sizeof(byte) == 1, "");
template<typename To, typename From>
requires (sizeof(To) == sizeof(From)) && is_trivially_copyable_v<To> && is_trivially_copyable_v<From>
constexpr To bit_cast(const From& from) noexcept
{
return __builtin_bit_cast(To, from);
}
template<typename T>
class initializer_list
{
const T* m_begin = nullptr;
size_t m_size = 0;
public:
constexpr initializer_list() noexcept = default;
constexpr size_t size() const noexcept { return m_size; }
constexpr const T* begin() const noexcept { return m_begin; }
constexpr const T* end() const noexcept { return m_begin + m_size; }
};
} // namespace std
static_assert(std::same_as<int, int>, "");
static_assert(!std::same_as<int, void>, "");
static_assert(std::same_as<std::remove_reference_t<int>, int>, "");
static_assert(std::same_as<std::remove_reference_t<int&>, int>, "");
static_assert(std::same_as<std::remove_reference_t<int&&>, int>, "");
static_assert(std::same_as<std::add_lvalue_reference_t<int>, int&>, "");
static_assert(std::same_as<std::add_lvalue_reference_t<int&>, int&>, "");
static_assert(std::same_as<std::add_lvalue_reference_t<int&&>, int&>, "");
static_assert(std::same_as<std::add_lvalue_reference_t<void>, void>, "");
static_assert(std::same_as<std::add_rvalue_reference_t<int>, int&&>, "");
static_assert(std::same_as<std::add_rvalue_reference_t<int&>, int&>, "");
static_assert(std::same_as<std::add_rvalue_reference_t<int&&>, int&&>, "");
static_assert(std::same_as<std::add_rvalue_reference_t<void>, void>, "");
static_assert(std::convertible_to<int*, const int*>, "");
static_assert(!std::convertible_to<int*, float*>, "");
constexpr void* operator new(size_t, void* ptr)
{
return ptr;
}
|
