libstdc++
typelist.h
Go to the documentation of this file.
1 // -*- C++ -*-
2 
3 // Copyright (C) 2005, 2006, 2008, 2009 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 typelist.h
37  * Contains typelist_chain definitions.
38  * Typelists are an idea by Andrei Alexandrescu.
39  */
40 
41 #ifndef _TYPELIST_H
42 #define _TYPELIST_H 1
43 
44 #include <ext/type_traits.h>
45 
46 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
47 
48 /** @namespace __gnu_cxx::typelist
49  * @brief GNU typelist extensions for public compile-time use.
50 */
51 namespace typelist
52 {
53  struct null_type { };
54 
55  template<typename Root>
56  struct node
57  {
58  typedef Root root;
59  };
60 
61  // Forward declarations of functors.
62  template<typename Hd, typename Typelist>
63  struct chain
64  {
65  typedef Hd head;
66  typedef Typelist tail;
67  };
68 
69  // Apply all typelist types to unary functor.
70  template<typename Fn, typename Typelist>
71  void
72  apply(Fn&, Typelist);
73 
74  /// Apply all typelist types to generator functor.
75  template<typename Gn, typename Typelist>
76  void
77  apply_generator(Gn&, Typelist);
78 
79  // Apply all typelist types and values to generator functor.
80  template<typename Gn, typename TypelistT, typename TypelistV>
81  void
82  apply_generator(Gn&, TypelistT, TypelistV);
83 
84  template<typename Typelist0, typename Typelist1>
85  struct append;
86 
87  template<typename Typelist_Typelist>
88  struct append_typelist;
89 
90  template<typename Typelist, typename T>
91  struct contains;
92 
93  template<typename Typelist, template<typename T> class Pred>
94  struct filter;
95 
96  template<typename Typelist, int i>
97  struct at_index;
98 
99  template<typename Typelist, template<typename T> class Transform>
100  struct transform;
101 
102  template<typename Typelist_Typelist>
103  struct flatten;
104 
105  template<typename Typelist>
106  struct from_first;
107 
108  template<typename T1>
109  struct create1;
110 
111  template<typename T1, typename T2>
112  struct create2;
113 
114  template<typename T1, typename T2, typename T3>
115  struct create3;
116 
117  template<typename T1, typename T2, typename T3, typename T4>
118  struct create4;
119 
120  template<typename T1, typename T2, typename T3, typename T4, typename T5>
121  struct create5;
122 
123  template<typename T1, typename T2, typename T3,
124  typename T4, typename T5, typename T6>
125  struct create6;
126 } // namespace typelist
127 
128 _GLIBCXX_END_NAMESPACE
129 
130 
131 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
132 
133 namespace typelist
134 {
135 namespace detail
136 {
137  template<typename Fn, typename Typelist_Chain>
138  struct apply_;
139 
140  template<typename Fn, typename Hd, typename Tl>
141  struct apply_<Fn, chain<Hd, Tl> >
142  {
143  void
144  operator()(Fn& f)
145  {
146  f.operator()(Hd());
147  apply_<Fn, Tl> next;
148  next(f);
149  }
150  };
151 
152  template<typename Fn>
153  struct apply_<Fn, null_type>
154  {
155  void
156  operator()(Fn&) { }
157  };
158 
159  template<typename Gn, typename Typelist_Chain>
160  struct apply_generator1_;
161 
162  template<typename Gn, typename Hd, typename Tl>
163  struct apply_generator1_<Gn, chain<Hd, Tl> >
164  {
165  void
166  operator()(Gn& g)
167  {
168  g.template operator()<Hd>();
169  apply_generator1_<Gn, Tl> next;
170  next(g);
171  }
172  };
173 
174  template<typename Gn>
175  struct apply_generator1_<Gn, null_type>
176  {
177  void
178  operator()(Gn&) { }
179  };
180 
181  template<typename Gn, typename TypelistT_Chain, typename TypelistV_Chain>
182  struct apply_generator2_;
183 
184  template<typename Gn, typename Hd1, typename TlT, typename Hd2, typename TlV>
185  struct apply_generator2_<Gn, chain<Hd1, TlT>, chain<Hd2, TlV> >
186  {
187  void
188  operator()(Gn& g)
189  {
190  g.template operator()<Hd1, Hd2>();
191  apply_generator2_<Gn, TlT, TlV> next;
192  next(g);
193  }
194  };
195 
196  template<typename Gn>
197  struct apply_generator2_<Gn, null_type, null_type>
198  {
199  void
200  operator()(Gn&) { }
201  };
202 
203  template<typename Typelist_Chain0, typename Typelist_Chain1>
204  struct append_;
205 
206  template<typename Hd, typename Tl, typename Typelist_Chain>
207  struct append_<chain<Hd, Tl>, Typelist_Chain>
208  {
209  private:
210  typedef append_<Tl, Typelist_Chain> append_type;
211 
212  public:
213  typedef chain<Hd, typename append_type::type> type;
214  };
215 
216  template<typename Typelist_Chain>
217  struct append_<null_type, Typelist_Chain>
218  {
219  typedef Typelist_Chain type;
220  };
221 
222  template<typename Typelist_Chain>
223  struct append_<Typelist_Chain, null_type>
224  {
225  typedef Typelist_Chain type;
226  };
227 
228  template<>
229  struct append_<null_type, null_type>
230  {
231  typedef null_type type;
232  };
233 
234  template<typename Typelist_Typelist_Chain>
235  struct append_typelist_;
236 
237  template<typename Hd>
238  struct append_typelist_<chain<Hd, null_type> >
239  {
240  typedef chain<Hd, null_type> type;
241  };
242 
243  template<typename Hd, typename Tl>
244  struct append_typelist_<chain< Hd, Tl> >
245  {
246  private:
247  typedef typename append_typelist_<Tl>::type rest_type;
248 
249  public:
250  typedef typename append<Hd, node<rest_type> >::type::root type;
251  };
252 
253  template<typename Typelist_Chain, typename T>
254  struct contains_;
255 
256  template<typename T>
257  struct contains_<null_type, T>
258  {
259  enum
260  {
261  value = false
262  };
263  };
264 
265  template<typename Hd, typename Tl, typename T>
266  struct contains_<chain<Hd, Tl>, T>
267  {
268  enum
269  {
270  value = contains_<Tl, T>::value
271  };
272  };
273 
274  template<typename Tl, typename T>
275  struct contains_<chain<T, Tl>, T>
276  {
277  enum
278  {
279  value = true
280  };
281  };
282 
283  template<typename Typelist_Chain, template<typename T> class Pred>
284  struct chain_filter_;
285 
286  template<template<typename T> class Pred>
287  struct chain_filter_<null_type, Pred>
288  {
289  typedef null_type type;
290  };
291 
292  template<typename Hd, typename Tl, template<typename T> class Pred>
293  struct chain_filter_<chain<Hd, Tl>, Pred>
294  {
295  private:
296  enum
297  {
298  include_hd = Pred<Hd>::value
299  };
300 
301  typedef typename chain_filter_<Tl, Pred>::type rest_type;
302  typedef chain<Hd, rest_type> chain_type;
303 
304  public:
305  typedef typename __conditional_type<include_hd, chain_type, rest_type>::__type type;
306  };
307 
308  template<typename Typelist_Chain, int i>
309  struct chain_at_index_;
310 
311  template<typename Hd, typename Tl>
312  struct chain_at_index_<chain<Hd, Tl>, 0>
313  {
314  typedef Hd type;
315  };
316 
317  template<typename Hd, typename Tl, int i>
318  struct chain_at_index_<chain<Hd, Tl>, i>
319  {
320  typedef typename chain_at_index_<Tl, i - 1>::type type;
321  };
322 
323  template<class Typelist_Chain, template<typename T> class Transform>
324  struct chain_transform_;
325 
326  template<template<typename T> class Transform>
327  struct chain_transform_<null_type, Transform>
328  {
329  typedef null_type type;
330  };
331 
332  template<class Hd, class Tl, template<typename T> class Transform>
333  struct chain_transform_<chain<Hd, Tl>, Transform>
334  {
335  private:
336  typedef typename chain_transform_<Tl, Transform>::type rest_type;
337  typedef typename Transform<Hd>::type transform_type;
338 
339  public:
340  typedef chain<transform_type, rest_type> type;
341  };
342 
343  template<typename Typelist_Typelist_Chain>
344  struct chain_flatten_;
345 
346  template<typename Hd_Tl>
347  struct chain_flatten_<chain<Hd_Tl, null_type> >
348  {
349  typedef typename Hd_Tl::root type;
350  };
351 
352  template<typename Hd_Typelist, class Tl_Typelist>
353  struct chain_flatten_<chain<Hd_Typelist, Tl_Typelist> >
354  {
355  private:
356  typedef typename chain_flatten_<Tl_Typelist>::type rest_type;
357  typedef append<Hd_Typelist, node<rest_type> > append_type;
358  public:
359  typedef typename append_type::type::root type;
360  };
361 } // namespace detail
362 } // namespace typelist
363 
364 _GLIBCXX_END_NAMESPACE
365 
366 #define _GLIBCXX_TYPELIST_CHAIN1(X0) __gnu_cxx::typelist::chain<X0, __gnu_cxx::typelist::null_type>
367 #define _GLIBCXX_TYPELIST_CHAIN2(X0, X1) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN1(X1) >
368 #define _GLIBCXX_TYPELIST_CHAIN3(X0, X1, X2) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN2(X1, X2) >
369 #define _GLIBCXX_TYPELIST_CHAIN4(X0, X1, X2, X3) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN3(X1, X2, X3) >
370 #define _GLIBCXX_TYPELIST_CHAIN5(X0, X1, X2, X3, X4) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN4(X1, X2, X3, X4) >
371 #define _GLIBCXX_TYPELIST_CHAIN6(X0, X1, X2, X3, X4, X5) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN5(X1, X2, X3, X4, X5) >
372 #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) >
373 #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) >
374 #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) >
375 #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) >
376 #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) >
377 #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) >
378 #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) >
379 #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) >
380 #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) >
381 
382 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
383 
384 namespace typelist
385 {
386  template<typename Fn, typename Typelist>
387  void
388  apply(Fn& fn, Typelist)
389  {
390  detail::apply_<Fn, typename Typelist::root> a;
391  a(fn);
392  }
393 
394  template<typename Fn, typename Typelist>
395  void
396  apply_generator(Fn& fn, Typelist)
397  {
398  detail::apply_generator1_<Fn, typename Typelist::root> a;
399  a(fn);
400  }
401 
402  template<typename Fn, typename TypelistT, typename TypelistV>
403  void
404  apply_generator(Fn& fn, TypelistT, TypelistV)
405  {
406  typedef typename TypelistT::root rootT;
407  typedef typename TypelistV::root rootV;
408  detail::apply_generator2_<Fn, rootT, rootV> a;
409  a(fn);
410  }
411 
412  template<typename Typelist0, typename Typelist1>
413  struct append
414  {
415  private:
416  typedef typename Typelist0::root root0_type;
417  typedef typename Typelist1::root root1_type;
418  typedef detail::append_<root0_type, root1_type> append_type;
419 
420  public:
421  typedef node<typename append_type::type> type;
422  };
423 
424  template<typename Typelist_Typelist>
425  struct append_typelist
426  {
427  private:
428  typedef typename Typelist_Typelist::root root_type;
429  typedef detail::append_typelist_<root_type> append_type;
430 
431  public:
432  typedef node<typename append_type::type> type;
433  };
434 
435  template<typename Typelist, typename T>
436  struct contains
437  {
438  private:
439  typedef typename Typelist::root root_type;
440 
441  public:
442  enum
443  {
444  value = detail::contains_<root_type, T>::value
445  };
446  };
447 
448  template<typename Typelist, template<typename T> class Pred>
449  struct filter
450  {
451  private:
452  typedef typename Typelist::root root_type;
453  typedef detail::chain_filter_<root_type, Pred> filter_type;
454 
455  public:
456  typedef node<typename filter_type::type> type;
457  };
458 
459  template<typename Typelist, int i>
460  struct at_index
461  {
462  private:
463  typedef typename Typelist::root root_type;
464  typedef detail::chain_at_index_<root_type, i> index_type;
465 
466  public:
467  typedef typename index_type::type type;
468  };
469 
470  template<typename Typelist, template<typename T> class Transform>
471  struct transform
472  {
473  private:
474  typedef typename Typelist::root root_type;
475  typedef detail::chain_transform_<root_type, Transform> transform_type;
476 
477  public:
478  typedef node<typename transform_type::type> type;
479  };
480 
481  template<typename Typelist_Typelist>
482  struct flatten
483  {
484  private:
485  typedef typename Typelist_Typelist::root root_type;
486  typedef typename detail::chain_flatten_<root_type>::type flatten_type;
487 
488  public:
489  typedef node<flatten_type> type;
490  };
491 
492  template<typename Typelist>
493  struct from_first
494  {
495  private:
496  typedef typename at_index<Typelist, 0>::type first_type;
497 
498  public:
499  typedef node<chain<first_type, null_type> > type;
500  };
501 
502  template<typename T1>
503  struct create1
504  {
505  typedef node<_GLIBCXX_TYPELIST_CHAIN1(T1)> type;
506  };
507 
508  template<typename T1, typename T2>
509  struct create2
510  {
511  typedef node<_GLIBCXX_TYPELIST_CHAIN2(T1,T2)> type;
512  };
513 
514  template<typename T1, typename T2, typename T3>
515  struct create3
516  {
517  typedef node<_GLIBCXX_TYPELIST_CHAIN3(T1,T2,T3)> type;
518  };
519 
520  template<typename T1, typename T2, typename T3, typename T4>
521  struct create4
522  {
523  typedef node<_GLIBCXX_TYPELIST_CHAIN4(T1,T2,T3,T4)> type;
524  };
525 
526  template<typename T1, typename T2, typename T3,
527  typename T4, typename T5>
528  struct create5
529  {
530  typedef node<_GLIBCXX_TYPELIST_CHAIN5(T1,T2,T3,T4,T5)> type;
531  };
532 
533  template<typename T1, typename T2, typename T3,
534  typename T4, typename T5, typename T6>
535  struct create6
536  {
537  typedef node<_GLIBCXX_TYPELIST_CHAIN6(T1,T2,T3,T4,T5,T6)> type;
538  };
539 } // namespace typelist
540 _GLIBCXX_END_NAMESPACE
541 
542 
543 #endif
544