libstdc++
typelist.h
Go to the documentation of this file.
1 // -*- C++ -*-
2 
3 // Copyright (C) 2005-2020 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 
48 namespace __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 */
55 namespace 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 
131 namespace 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
__gnu_cxx
GNU extensions for public use.
__gnu_cxx::typelist::apply_generator
void apply_generator(Gn &, Typelist)
Apply all typelist types to generator functor.