OSDN Git Service

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