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