l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.7/include/ext/typelist.h

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