libstdc++: typelist.h Source File

libstdc++

typelist.h
Go to the documentation of this file.
1// -*- C++ -*-
2
3// Copyright (C) 2005-2026 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
26
27// Permission to use, copy, modify, sell, and distribute this software
28// is hereby granted without fee, provided that the above copyright
29// notice appears in all copies, and that both that copyright notice and
30// this permission notice appear in supporting documentation. None of
31// the above authors, nor IBM Haifa Research Laboratories, make any
32// representation about the suitability of this software for any
33// purpose. It is provided "as is" without express or implied warranty.
34
35/**
36 * @file ext/typelist.h
37 * This file is a GNU extension to the Standard C++ Library.
38 *
39 * Contains typelist_chain definitions.
40 * Typelists are an idea by Andrei Alexandrescu.
41 */
42
43#ifndef _TYPELIST_H
44#define _TYPELIST_H 1
45
46#include <ext/type_traits.h>
47
48namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
49{
50_GLIBCXX_BEGIN_NAMESPACE_VERSION
51
52/** @namespace __gnu_cxx::typelist
53 * @brief GNU typelist extensions for public compile-time use.
54*/
55namespace typelist
56{
57 struct null_type { };
58
59 template<typename Root>
60 struct node
61 {
62 typedef Root root;
63 };
64
65 // Forward declarations of functors.
66 template<typename Hd, typename Typelist>
67 struct chain
68 {
69 typedef Hd head;
70 typedef Typelist tail;
71 };
72
73 // Apply all typelist types to unary functor.
74 template<typename Fn, typename Typelist>
75 void
76 apply(Fn&, Typelist);
77
78 /// Apply all typelist types to generator functor.
79 template<typename Gn, typename Typelist>
80 void
81 apply_generator(Gn&, Typelist);
82
83 // Apply all typelist types and values to generator functor.
84 template<typename Gn, typename TypelistT, typename TypelistV>
85 void
86 apply_generator(Gn&, TypelistT, TypelistV);
87
88 template<typename Typelist0, typename Typelist1>
89 struct append;
90
91 template<typename Typelist_Typelist>
92 struct append_typelist;
93
94 template<typename Typelist, typename T>
95 struct contains;
96
97 template<typename Typelist, template<typename T> class Pred>
98 struct filter;
99
100 template<typename Typelist, int i>
101 struct at_index;
102
103 template<typename Typelist, template<typename T> class Transform>
104 struct transform;
105
106 template<typename Typelist_Typelist>
107 struct flatten;
108
109 template<typename Typelist>
110 struct from_first;
111
112 template<typename T1>
113 struct create1;
114
115 template<typename T1, typename T2>
116 struct create2;
117
118 template<typename T1, typename T2, typename T3>
119 struct create3;
120
121 template<typename T1, typename T2, typename T3, typename T4>
122 struct create4;
123
124 template<typename T1, typename T2, typename T3, typename T4, typename T5>
125 struct create5;
126
127 template<typename T1, typename T2, typename T3,
128 typename T4, typename T5, typename T6>
129 struct create6;
130
131namespace detail
132{
133 template<typename Fn, typename Typelist_Chain>
134 struct apply_;
135
136 template<typename Fn, typename Hd, typename Tl>
137 struct apply_<Fn, chain<Hd, Tl> >
138 {
139 void
140 operator()(Fn& f)
141 {
142 f.operator()(Hd());
143 apply_<Fn, Tl> next;
144 next(f);
145 }
146 };
147
148 template<typename Fn>
149 struct apply_<Fn, null_type>
150 {
151 void
152 operator()(Fn&) { }
153 };
154
155 template<typename Gn, typename Typelist_Chain>
156 struct apply_generator1_;
157
158 template<typename Gn, typename Hd, typename Tl>
159 struct apply_generator1_<Gn, chain<Hd, Tl> >
160 {
161 void
162 operator()(Gn& g)
163 {
164 g.template operator()<Hd>();
165 apply_generator1_<Gn, Tl> next;
166 next(g);
167 }
168 };
169
170 template<typename Gn>
171 struct apply_generator1_<Gn, null_type>
172 {
173 void
174 operator()(Gn&) { }
175 };
176
177 template<typename Gn, typename TypelistT_Chain, typename TypelistV_Chain>
178 struct apply_generator2_;
179
180 template<typename Gn, typename Hd1, typename TlT, typename Hd2, typename TlV>
181 struct apply_generator2_<Gn, chain<Hd1, TlT>, chain<Hd2, TlV> >
182 {
183 void
184 operator()(Gn& g)
185 {
186 g.template operator()<Hd1, Hd2>();
187 apply_generator2_<Gn, TlT, TlV> next;
188 next(g);
189 }
190 };
191
192 template<typename Gn>
193 struct apply_generator2_<Gn, null_type, null_type>
194 {
195 void
196 operator()(Gn&) { }
197 };
198
199 template<typename Typelist_Chain0, typename Typelist_Chain1>
200 struct append_;
201
202 template<typename Hd, typename Tl, typename Typelist_Chain>
203 struct append_<chain<Hd, Tl>, Typelist_Chain>
204 {
205 private:
206 typedef append_<Tl, Typelist_Chain> append_type;
207
208 public:
209 typedef chain<Hd, typename append_type::type> type;
210 };
211
212 template<typename Typelist_Chain>
213 struct append_<null_type, Typelist_Chain>
214 {
215 typedef Typelist_Chain type;
216 };
217
218 template<typename Hd, typename Tl>
219 struct append_<chain<Hd, Tl>, null_type>
220 {
221 typedef chain<Hd, Tl> type;
222 };
223
224 template<>
225 struct append_<null_type, null_type>
226 {
227 typedef null_type type;
228 };
229
230 template<typename Typelist_Typelist_Chain>
231 struct append_typelist_;
232
233 template<typename Hd>
234 struct append_typelist_<chain<Hd, null_type> >
235 {
236 typedef chain<Hd, null_type> type;
237 };
238
239 template<typename Hd, typename Tl>
240 struct append_typelist_<chain< Hd, Tl> >
241 {
242 private:
243 typedef typename append_typelist_<Tl>::type rest_type;
244
245 public:
246 typedef typename append<Hd, node<rest_type> >::type::root type;
247 };
248
249 template<typename Typelist_Chain, typename T>
250 struct contains_;
251
252 template<typename T>
253 struct contains_<null_type, T>
254 {
255 enum
256 {
257 value = false
258 };
259 };
260
261 template<typename Hd, typename Tl, typename T>
262 struct contains_<chain<Hd, Tl>, T>
263 {
264 enum
265 {
266 value = contains_<Tl, T>::value
267 };
268 };
269
270 template<typename Tl, typename T>
271 struct contains_<chain<T, Tl>, T>
272 {
273 enum
274 {
275 value = true
276 };
277 };
278
279 template<typename Typelist_Chain, template<typename T> class Pred>
280 struct chain_filter_;
281
282 template<template<typename T> class Pred>
283 struct chain_filter_<null_type, Pred>
284 {
285 typedef null_type type;
286 };
287
288 template<typename Hd, typename Tl, template<typename T> class Pred>
289 struct chain_filter_<chain<Hd, Tl>, Pred>
290 {
291 private:
292 enum
293 {
294 include_hd = Pred<Hd>::value
295 };
296
297 typedef typename chain_filter_<Tl, Pred>::type rest_type;
298 typedef chain<Hd, rest_type> chain_type;
299
300 public:
301 typedef typename __conditional_type<include_hd, chain_type, rest_type>::__type type;
302 };
303
304 template<typename Typelist_Chain, int i>
305 struct chain_at_index_;
306
307 template<typename Hd, typename Tl>
308 struct chain_at_index_<chain<Hd, Tl>, 0>
309 {
310 typedef Hd type;
311 };
312
313 template<typename Hd, typename Tl, int i>
314 struct chain_at_index_<chain<Hd, Tl>, i>
315 {
316 typedef typename chain_at_index_<Tl, i - 1>::type type;
317 };
318
319 template<class Typelist_Chain, template<typename T> class Transform>
320 struct chain_transform_;
321
322 template<template<typename T> class Transform>
323 struct chain_transform_<null_type, Transform>
324 {
325 typedef null_type type;
326 };
327
328 template<class Hd, class Tl, template<typename T> class Transform>
329 struct chain_transform_<chain<Hd, Tl>, Transform>
330 {
331 private:
332 typedef typename chain_transform_<Tl, Transform>::type rest_type;
333 typedef typename Transform<Hd>::type transform_type;
334
335 public:
336 typedef chain<transform_type, rest_type> type;
337 };
338
339 template<typename Typelist_Typelist_Chain>
340 struct chain_flatten_;
341
342 template<typename Hd_Tl>
343 struct chain_flatten_<chain<Hd_Tl, null_type> >
344 {
345 typedef typename Hd_Tl::root type;
346 };
347
348 template<typename Hd_Typelist, class Tl_Typelist>
349 struct chain_flatten_<chain<Hd_Typelist, Tl_Typelist> >
350 {
351 private:
352 typedef typename chain_flatten_<Tl_Typelist>::type rest_type;
353 typedef append<Hd_Typelist, node<rest_type> > append_type;
354 public:
355 typedef typename append_type::type::root type;
356 };
357} // namespace detail
358
359#define _GLIBCXX_TYPELIST_CHAIN1(X0) __gnu_cxx::typelist::chain<X0, __gnu_cxx::typelist::null_type>
360#define _GLIBCXX_TYPELIST_CHAIN2(X0, X1) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN1(X1) >
361#define _GLIBCXX_TYPELIST_CHAIN3(X0, X1, X2) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN2(X1, X2) >
362#define _GLIBCXX_TYPELIST_CHAIN4(X0, X1, X2, X3) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN3(X1, X2, X3) >
363#define _GLIBCXX_TYPELIST_CHAIN5(X0, X1, X2, X3, X4) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN4(X1, X2, X3, X4) >
364#define _GLIBCXX_TYPELIST_CHAIN6(X0, X1, X2, X3, X4, X5) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN5(X1, X2, X3, X4, X5) >
365#define _GLIBCXX_TYPELIST_CHAIN7(X0, X1, X2, X3, X4, X5, X6) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN6(X1, X2, X3, X4, X5, X6) >
366#define _GLIBCXX_TYPELIST_CHAIN8(X0, X1, X2, X3, X4, X5, X6, X7) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN7(X1, X2, X3, X4, X5, X6, X7) >
367#define _GLIBCXX_TYPELIST_CHAIN9(X0, X1, X2, X3, X4, X5, X6, X7, X8) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN8(X1, X2, X3, X4, X5, X6, X7, X8) >
368#define _GLIBCXX_TYPELIST_CHAIN10(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN9(X1, X2, X3, X4, X5, X6, X7, X8, X9) >
369#define _GLIBCXX_TYPELIST_CHAIN11(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN10(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10) >
370#define _GLIBCXX_TYPELIST_CHAIN12(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN11(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11) >
371#define _GLIBCXX_TYPELIST_CHAIN13(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN12(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12) >
372#define _GLIBCXX_TYPELIST_CHAIN14(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN13(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) >
373#define _GLIBCXX_TYPELIST_CHAIN15(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN14(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) >
374#define _GLIBCXX_TYPELIST_CHAIN16(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN15(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15) >
375#define _GLIBCXX_TYPELIST_CHAIN17(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN16(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16) >
376#define _GLIBCXX_TYPELIST_CHAIN18(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN17(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17) >
377#define _GLIBCXX_TYPELIST_CHAIN19(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN18(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18) >
378#define _GLIBCXX_TYPELIST_CHAIN20(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN19(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19) >
379
380 template<typename Fn, typename Typelist>
381 void
382 apply(Fn& fn, Typelist)
383 {
384 detail::apply_<Fn, typename Typelist::root> a;
385 a(fn);
386 }
387
388 template<typename Fn, typename Typelist>
389 void
390 apply_generator(Fn& fn, Typelist)
391 {
392 detail::apply_generator1_<Fn, typename Typelist::root> a;
393 a(fn);
394 }
395
396 template<typename Fn, typename TypelistT, typename TypelistV>
397 void
398 apply_generator(Fn& fn, TypelistT, TypelistV)
399 {
400 typedef typename TypelistT::root rootT;
401 typedef typename TypelistV::root rootV;
402 detail::apply_generator2_<Fn, rootT, rootV> a;
403 a(fn);
404 }
405
406 template<typename Typelist0, typename Typelist1>
407 struct append
408 {
409 private:
410 typedef typename Typelist0::root root0_type;
411 typedef typename Typelist1::root root1_type;
412 typedef detail::append_<root0_type, root1_type> append_type;
413
414 public:
415 typedef node<typename append_type::type> type;
416 };
417
418 template<typename Typelist_Typelist>
419 struct append_typelist
420 {
421 private:
422 typedef typename Typelist_Typelist::root root_type;
423 typedef detail::append_typelist_<root_type> append_type;
424
425 public:
426 typedef node<typename append_type::type> type;
427 };
428
429 template<typename Typelist, typename T>
430 struct contains
431 {
432 private:
433 typedef typename Typelist::root root_type;
434
435 public:
436 enum
437 {
438 value = detail::contains_<root_type, T>::value
439 };
440 };
441
442 template<typename Typelist, template<typename T> class Pred>
443 struct filter
444 {
445 private:
446 typedef typename Typelist::root root_type;
447 typedef detail::chain_filter_<root_type, Pred> filter_type;
448
449 public:
450 typedef node<typename filter_type::type> type;
451 };
452
453 template<typename Typelist, int i>
454 struct at_index
455 {
456 private:
457 typedef typename Typelist::root root_type;
458 typedef detail::chain_at_index_<root_type, i> index_type;
459
460 public:
461 typedef typename index_type::type type;
462 };
463
464 template<typename Typelist, template<typename T> class Transform>
465 struct transform
466 {
467 private:
468 typedef typename Typelist::root root_type;
469 typedef detail::chain_transform_<root_type, Transform> transform_type;
470
471 public:
472 typedef node<typename transform_type::type> type;
473 };
474
475 template<typename Typelist_Typelist>
476 struct flatten
477 {
478 private:
479 typedef typename Typelist_Typelist::root root_type;
480 typedef typename detail::chain_flatten_<root_type>::type flatten_type;
481
482 public:
483 typedef node<flatten_type> type;
484 };
485
486 template<typename Typelist>
487 struct from_first
488 {
489 private:
490 typedef typename at_index<Typelist, 0>::type first_type;
491
492 public:
493 typedef node<chain<first_type, null_type> > type;
494 };
495
496 template<typename T1>
497 struct create1
498 {
499 typedef node<_GLIBCXX_TYPELIST_CHAIN1(T1)> type;
500 };
501
502 template<typename T1, typename T2>
503 struct create2
504 {
505 typedef node<_GLIBCXX_TYPELIST_CHAIN2(T1,T2)> type;
506 };
507
508 template<typename T1, typename T2, typename T3>
509 struct create3
510 {
511 typedef node<_GLIBCXX_TYPELIST_CHAIN3(T1,T2,T3)> type;
512 };
513
514 template<typename T1, typename T2, typename T3, typename T4>
515 struct create4
516 {
517 typedef node<_GLIBCXX_TYPELIST_CHAIN4(T1,T2,T3,T4)> type;
518 };
519
520 template<typename T1, typename T2, typename T3,
521 typename T4, typename T5>
522 struct create5
523 {
524 typedef node<_GLIBCXX_TYPELIST_CHAIN5(T1,T2,T3,T4,T5)> type;
525 };
526
527 template<typename T1, typename T2, typename T3,
528 typename T4, typename T5, typename T6>
529 struct create6
530 {
531 typedef node<_GLIBCXX_TYPELIST_CHAIN6(T1,T2,T3,T4,T5,T6)> type;
532 };
533} // namespace typelist
534_GLIBCXX_END_NAMESPACE_VERSION
535} // namespace
536
537
538#endif
type_traits.h
__gnu_cxx
GNU extensions for public use.
__gnu_cxx::typelist
GNU typelist extensions for public compile-time use.
__gnu_cxx::typelist::apply_generator
void apply_generator(Gn &, Typelist)
Apply all typelist types to generator functor.