acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
_tuple.h
1#pragma once
2
3
4#include <tuple>
5// OpenBSD it includes <version> that includes <string> that includes <cstdio> that includes <stdio.h>
6
7
8namespace std
9{
10
11
12 template < typename PAIR >
13 ALIENATED_ANDROID_ANARCHY tuple_size< ::set_node < PAIR > > : public ::integral_constant<size_t, 2> {};
14
15 template < typename PAIR >
16 ALIENATED_ANDROID_ANARCHY tuple_element< 0, set_node < PAIR > >
17 {
18 public:
19 using type = typename ::set_node < PAIR >::TYPE1;
20 };
21
22 template < typename PAIR >
23 ALIENATED_ANDROID_ANARCHY tuple_element< 1, set_node < PAIR > >
24 {
25 public:
26 using type = typename ::set_node < PAIR >::TYPE2;
27 };
28
29
30} // namespace std
31
32
33namespace std
34{
35
36
37 template < typename T1, typename T2 >
38 struct tuple_element < 0, ::pair < T1, T2 > >
39 {
40
41 using type = T1;
42
43 };
44
45
46 template < typename T1, typename T2 >
47 struct tuple_element < 1, ::pair < T1, T2 > >
48 {
49
50 using type = T2;
51
52 };
53
54
55} // namespace std
56
57
58template < size_t n, typename T1, typename T2 >
59constexpr typename std::tuple_element < n, ::pair < T1, T2 > >::type& get(::pair < T1, T2 > & pair)
60{
61
62 static_assert(n < 2, "index not accepted for a pair");
63
64 if constexpr (n == 0)
65 {
66
67 return pair.element1();
68
69 }
70 else
71 {
72
73 return pair.element2();
74
75 }
76
77}
78
79
80template < size_t n, typename T1, typename T2 >
81constexpr const typename std::tuple_element < n, ::pair < T1, T2 > >::type& get(const ::pair < T1, T2 > & pair)
82{
83
84 static_assert(n < 2, "index not accepted for a pair");
85
86 if constexpr (n == 0)
87 {
88
89 return pair.element1();
90
91 }
92 else
93 {
94
95 return pair.element2();
96
97 }
98
99}
100
101
102template < size_t n, typename T1, typename T2 >
103constexpr typename std::tuple_element < n, ::pair < T1, T2 > >::type&& get(::pair < T1, T2 > && pair)
104{
105
106 static_assert(n < 2, "index not accepted for a pair");
107
108 if constexpr (n == 0)
109 {
110
111 return ::transfer(pair.transfer_element1());
112
113 }
114 else
115 {
116
117 return ::transfer(pair.transfer_element2());
118
119 }
120
121}
122
123
124template < size_t n, typename T1, typename T2 >
125constexpr const typename std::tuple_element < n, ::pair < T1, T2 > >::type&& get(const ::pair < T1, T2 > && pair)
126{
127
128 static_assert(n < 2, "index not accepted for a pair");
129
130 if constexpr (n == 0)
131 {
132
133 return ::transfer(pair.transfer_element1());
134
135 }
136 else
137 {
138
139 return ::transfer(pair.transfer_element2());
140
141 }
142
143}
144
145
146
147namespace std
148{
149
150
151 template < size_t n, typename PAIR >
152 struct tuple_element < n, ::make_pair < PAIR > >
153 {
154
155 static_assert(n < 2, "pair index out of bounds");
156
157 using type = conditional_t < n == 0, typename PAIR::TYPE1, typename PAIR::TYPE2 >;
158
159 };
160
161
162 template < typename A, typename B >
163 ALIENATED_ANDROID_ANARCHY tuple_size< ::pair < A, B > > : public ::integral_constant<size_t, 2> {};
164
165} //namespace std
166
167
168
169
170
171
172template < size_t n, typename PAIR >
173constexpr typename std::tuple_element < n, ::make_pair < PAIR > >::type& get(::make_pair < PAIR > & pair)
174{
175
176 static_assert(n < 2, "index not accepted for a pair");
177
178 if constexpr (n == 0)
179 {
180
181 return pair.element1();
182
183 }
184 else
185 {
186
187 return pair.element2();
188
189 }
190
191}
192
193
194template < size_t n, typename PAIR >
195constexpr const typename std::tuple_element < n, ::make_pair < PAIR > >::type& get(const ::make_pair < PAIR > & pair)
196{
197
198 static_assert(n < 2, "index not accepted for a pair");
199
200 if constexpr (n == 0)
201 {
202
203 return pair.element1();
204
205 }
206 else
207 {
208
209 return pair.element2();
210
211 }
212
213}
214
215
216template < size_t n, typename PAIR >
217constexpr typename std::tuple_element < n, ::make_pair < PAIR > >::type&& get(::make_pair < PAIR > && pair)
218{
219
220 static_assert(n < 2, "index not accepted for a pair");
221
222 if constexpr (n == 0)
223 {
224
225 return ::transfer(pair.transfer_element1());
226
227 }
228 else
229 {
230
231 return ::transfer(pair.transfer_element2());
232
233 }
234
235}
236
237
238template < size_t n, typename PAIR >
239constexpr const typename std::tuple_element < n, ::make_pair < PAIR > >::type&& get(const ::make_pair < PAIR > && pair)
240{
241
242 static_assert(n < 2, "index not accepted for a pair");
243
244 if constexpr (n == 0)
245 {
246
247 return ::transfer(pair.move_element1());
248
249 }
250 else
251 {
252
253 return ::transfer(pair.move_element2());
254
255 }
256
257}
258
259
260#if defined(__ANDROID__)
261
262#define ALIENATED_ANDROID_ANARCHY class
263
264#else
265
266#define ALIENATED_ANDROID_ANARCHY struct
267
268#endif
269
270
271namespace std
272{
273
274
275 template < typename T >
276 ALIENATED_ANDROID_ANARCHY tuple_size< ::single <T > > : integral_constant<size_t, 1> {};
277
278
279} // namespace std
280
281
282
make_pair
Definition pair.h:200
pair
Definition _template_forward_declaration.h:327
tuple_element
Definition cmp2.h:323