URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [ext/] [typelist.h] - Blame information for rev 35

Details | Compare with Previous | View Log


// -*- C++ -*-
 
// Copyright (C) 2005, 2006, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
 
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
 
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.
 
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
 
// Permission to use, copy, modify, sell, and distribute this software
// is hereby granted without fee, provided that the above copyright
// notice appears in all copies, and that both that copyright notice and
// this permission notice appear in supporting documentation. None of
// the above authors, nor IBM Haifa Research Laboratories, make any
// representation about the suitability of this software for any
// purpose. It is provided "as is" without express or implied warranty.
 
/**
 *  @file ext/typelist.h
 *  This file is a GNU extension to the Standard C++ Library.
 *
 *  Contains typelist_chain definitions.
 *  Typelists are an idea by Andrei Alexandrescu.
 */
 
#ifndef _TYPELIST_H
#define _TYPELIST_H 1
 
#include <ext/type_traits.h>
 
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
/** @namespace __gnu_cxx::typelist
 *  @brief GNU typelist extensions for public compile-time use.
*/
namespace typelist
{
  struct null_type { };
 
  template<typename Root>
    struct node
    {
      typedef Root      root;
    };
 
  // Forward declarations of functors.
  template<typename Hd, typename Typelist>
    struct chain
    {
      typedef Hd        head;
      typedef Typelist  tail;
    };
 
  // Apply all typelist types to unary functor.
  template<typename Fn, typename Typelist>
    void
    apply(Fn&, Typelist);
 
  /// Apply all typelist types to generator functor.
  template<typename Gn, typename Typelist>
    void
    apply_generator(Gn&, Typelist);
 
  // Apply all typelist types and values to generator functor.
  template<typename Gn, typename TypelistT, typename TypelistV>
    void
    apply_generator(Gn&, TypelistT, TypelistV);
 
  template<typename Typelist0, typename Typelist1>
    struct append;
 
  template<typename Typelist_Typelist>
    struct append_typelist;
 
  template<typename Typelist, typename T>
    struct contains;
 
  template<typename Typelist, template<typename T> class Pred>
    struct filter;
 
  template<typename Typelist, int i>
    struct at_index;
 
  template<typename Typelist, template<typename T> class Transform>
    struct transform;
 
  template<typename Typelist_Typelist>
    struct flatten;
 
  template<typename Typelist>
    struct from_first;
 
  template<typename T1>
    struct create1;
 
  template<typename T1, typename T2>
    struct create2;
 
  template<typename T1, typename T2, typename T3>
    struct create3;
 
  template<typename T1, typename T2, typename T3, typename T4>
    struct create4;
 
  template<typename T1, typename T2, typename T3, typename T4, typename T5>
    struct create5;
 
  template<typename T1, typename T2, typename T3,
           typename T4, typename T5, typename T6>
    struct create6;
} // namespace typelist
 
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
 
 
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
namespace typelist
{
namespace detail
{
  template<typename Fn, typename Typelist_Chain>
    struct apply_;
 
  template<typename Fn, typename Hd, typename Tl>
    struct apply_<Fn, chain<Hd, Tl> >
    {
      void
      operator()(Fn& f)
      {
        f.operator()(Hd());
        apply_<Fn, Tl> next;
        next(f);
      }
    };
 
  template<typename Fn>
    struct apply_<Fn, null_type>
    {
      void
      operator()(Fn&) { }
    };
 
  template<typename Gn, typename Typelist_Chain>
    struct apply_generator1_;
 
  template<typename Gn, typename Hd, typename Tl>
    struct apply_generator1_<Gn, chain<Hd, Tl> >
    {
      void
      operator()(Gn& g)
      {
        g.template operator()<Hd>();
        apply_generator1_<Gn, Tl> next;
        next(g);
      }
    };
 
  template<typename Gn>
    struct apply_generator1_<Gn, null_type>
    {
      void
      operator()(Gn&) { }
    };
 
  template<typename Gn, typename TypelistT_Chain, typename TypelistV_Chain>
    struct apply_generator2_;
 
  template<typename Gn, typename Hd1, typename TlT, typename Hd2, typename TlV>
    struct apply_generator2_<Gn, chain<Hd1, TlT>, chain<Hd2, TlV> >
    {
      void
      operator()(Gn& g)
      {
        g.template operator()<Hd1, Hd2>();
        apply_generator2_<Gn, TlT, TlV> next;
        next(g);
      }
    };
 
  template<typename Gn>
    struct apply_generator2_<Gn, null_type, null_type>
    {
      void
      operator()(Gn&) { }
    };
 
  template<typename Typelist_Chain0, typename Typelist_Chain1>
    struct append_;
 
  template<typename Hd, typename Tl, typename Typelist_Chain>
    struct append_<chain<Hd, Tl>, Typelist_Chain>
    {
    private:
      typedef append_<Tl, Typelist_Chain>                       append_type;
 
    public:
      typedef chain<Hd, typename append_type::type>             type;
    };
 
  template<typename Typelist_Chain>
    struct append_<null_type, Typelist_Chain>
    {
      typedef Typelist_Chain                                    type;
    };
 
  template<typename Typelist_Chain>
    struct append_<Typelist_Chain, null_type>
    {
      typedef Typelist_Chain                                    type;
    };
 
  template<>
    struct append_<null_type, null_type>
    {
      typedef null_type                                         type;
    };
 
  template<typename Typelist_Typelist_Chain>
    struct append_typelist_;
 
  template<typename Hd>
    struct append_typelist_<chain<Hd, null_type> >
    {
      typedef chain<Hd, null_type>                              type;
    };
 
  template<typename Hd, typename Tl>
    struct append_typelist_<chain< Hd, Tl> >
    {
    private:
      typedef typename append_typelist_<Tl>::type               rest_type;
 
    public:
      typedef typename append<Hd, node<rest_type> >::type::root type;
    };
 
  template<typename Typelist_Chain, typename T>
    struct contains_;
 
  template<typename T>
    struct contains_<null_type, T>
    {
      enum
        {
          value = false
        };
    };
 
  template<typename Hd, typename Tl, typename T>
    struct contains_<chain<Hd, Tl>, T>
    {
      enum
        {
          value = contains_<Tl, T>::value
        };
    };
 
  template<typename Tl, typename T>
    struct contains_<chain<T, Tl>, T>
    {
      enum
        {
          value = true
        };
    };
 
  template<typename Typelist_Chain, template<typename T> class Pred>
    struct chain_filter_;
 
  template<template<typename T> class Pred>
    struct chain_filter_<null_type, Pred>
    {
      typedef null_type                                         type;
  };
 
  template<typename Hd, typename Tl, template<typename T> class Pred>
    struct chain_filter_<chain<Hd, Tl>, Pred>
    {
    private:
      enum
        {
          include_hd = Pred<Hd>::value
        };
 
      typedef typename chain_filter_<Tl, Pred>::type            rest_type;
      typedef chain<Hd, rest_type>                              chain_type;
 
    public:
      typedef typename __conditional_type<include_hd, chain_type, rest_type>::__type type;
  };
 
  template<typename Typelist_Chain, int i>
    struct chain_at_index_;
 
  template<typename Hd, typename Tl>
    struct chain_at_index_<chain<Hd, Tl>, 0>
    {
      typedef Hd                                                type;
    };
 
  template<typename Hd, typename Tl, int i>
    struct chain_at_index_<chain<Hd, Tl>, i>
    {
      typedef typename chain_at_index_<Tl, i - 1>::type         type;
    };
 
  template<class Typelist_Chain, template<typename T> class Transform>
    struct chain_transform_;
 
  template<template<typename T> class Transform>
    struct chain_transform_<null_type, Transform>
    {
      typedef null_type                                         type;
    };
 
  template<class Hd, class Tl, template<typename T> class Transform>
    struct chain_transform_<chain<Hd, Tl>, Transform>
    {
    private:
      typedef typename chain_transform_<Tl, Transform>::type    rest_type;
      typedef typename Transform<Hd>::type                      transform_type;
 
    public:
      typedef chain<transform_type, rest_type>                  type;
    };
 
  template<typename Typelist_Typelist_Chain>
    struct chain_flatten_;
 
  template<typename Hd_Tl>
    struct chain_flatten_<chain<Hd_Tl, null_type> >
    {
      typedef typename Hd_Tl::root                              type;
    };
 
  template<typename Hd_Typelist, class Tl_Typelist>
    struct chain_flatten_<chain<Hd_Typelist, Tl_Typelist> >
    {
    private:
      typedef typename chain_flatten_<Tl_Typelist>::type        rest_type;
      typedef append<Hd_Typelist, node<rest_type> >             append_type;
    public:
      typedef typename append_type::type::root                  type;
    };
} // namespace detail
} // namespace typelist
 
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
 
#define _GLIBCXX_TYPELIST_CHAIN1(X0) __gnu_cxx::typelist::chain<X0, __gnu_cxx::typelist::null_type>
#define _GLIBCXX_TYPELIST_CHAIN2(X0, X1) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN1(X1) >
#define _GLIBCXX_TYPELIST_CHAIN3(X0, X1, X2) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN2(X1, X2) >
#define _GLIBCXX_TYPELIST_CHAIN4(X0, X1, X2, X3) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN3(X1, X2, X3) >
#define _GLIBCXX_TYPELIST_CHAIN5(X0, X1, X2, X3, X4) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN4(X1, X2, X3, X4) >
#define _GLIBCXX_TYPELIST_CHAIN6(X0, X1, X2, X3, X4, X5) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN5(X1, X2, X3, X4, X5) >
#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) >
#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) >
#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) >
#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) >
#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) >
#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) >
#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) >
#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) >
#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) >
#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) >
#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) >
#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) >
#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) >
#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) >
 
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
namespace typelist
{
  template<typename Fn, typename Typelist>
    void
    apply(Fn& fn, Typelist)
    {
      detail::apply_<Fn, typename Typelist::root> a;
      a(fn);
    }
 
  template<typename Fn, typename Typelist>
    void
    apply_generator(Fn& fn, Typelist)
    {
      detail::apply_generator1_<Fn, typename Typelist::root> a;
      a(fn);
    }
 
  template<typename Fn, typename TypelistT, typename TypelistV>
    void
    apply_generator(Fn& fn, TypelistT, TypelistV)
    {
      typedef typename TypelistT::root rootT;
      typedef typename TypelistV::root rootV;
      detail::apply_generator2_<Fn, rootT, rootV> a;
      a(fn);
    }
 
  template<typename Typelist0, typename Typelist1>
    struct append
    {
    private:
      typedef typename Typelist0::root                          root0_type;
      typedef typename Typelist1::root                          root1_type;
      typedef detail::append_<root0_type, root1_type>           append_type;
 
    public:
      typedef node<typename append_type::type>                  type;
    };
 
  template<typename Typelist_Typelist>
    struct append_typelist
    {
    private:
      typedef typename Typelist_Typelist::root                  root_type;
      typedef detail::append_typelist_<root_type>               append_type;
 
    public:
      typedef node<typename append_type::type>                  type;
    };
 
  template<typename Typelist, typename T>
    struct contains
    {
    private:
      typedef typename Typelist::root                           root_type;
 
    public:
      enum
        {
          value = detail::contains_<root_type, T>::value
        };
    };
 
  template<typename Typelist, template<typename T> class Pred>
    struct filter
    {
    private:
      typedef typename Typelist::root                           root_type;
      typedef detail::chain_filter_<root_type, Pred>            filter_type;
 
    public:
      typedef node<typename filter_type::type>                  type;
    };
 
  template<typename Typelist, int i>
    struct at_index
    {
    private:
      typedef typename Typelist::root                           root_type;
      typedef detail::chain_at_index_<root_type, i>             index_type;
 
    public:
      typedef typename index_type::type                         type;
    };
 
  template<typename Typelist, template<typename T> class Transform>
    struct transform
    {
    private:
      typedef typename Typelist::root                           root_type;
      typedef detail::chain_transform_<root_type, Transform>    transform_type;
 
    public:
      typedef node<typename transform_type::type>               type;
    };
 
  template<typename Typelist_Typelist>
    struct flatten
    {
    private:
      typedef typename Typelist_Typelist::root                  root_type;
      typedef typename detail::chain_flatten_<root_type>::type  flatten_type;
 
    public:
      typedef node<flatten_type>                                type;
    };
 
  template<typename Typelist>
    struct from_first
    {
    private:
      typedef typename at_index<Typelist, 0>::type               first_type;
 
    public:
      typedef node<chain<first_type, null_type> >               type;
    };
 
  template<typename T1>
    struct create1
    {
      typedef node<_GLIBCXX_TYPELIST_CHAIN1(T1)>                type;
    };
 
  template<typename T1, typename T2>
    struct create2
    {
      typedef node<_GLIBCXX_TYPELIST_CHAIN2(T1,T2)>             type;
    };
 
  template<typename T1, typename T2, typename T3>
    struct create3
    {
      typedef node<_GLIBCXX_TYPELIST_CHAIN3(T1,T2,T3)>          type;
    };
 
  template<typename T1, typename T2, typename T3, typename T4>
    struct create4
    {
      typedef node<_GLIBCXX_TYPELIST_CHAIN4(T1,T2,T3,T4)>       type;
    };
 
  template<typename T1, typename T2, typename T3,
           typename T4, typename T5>
    struct create5
    {
      typedef node<_GLIBCXX_TYPELIST_CHAIN5(T1,T2,T3,T4,T5)>    type;
    };
 
  template<typename T1, typename T2, typename T3,
           typename T4, typename T5, typename T6>
    struct create6
    {
      typedef node<_GLIBCXX_TYPELIST_CHAIN6(T1,T2,T3,T4,T5,T6)> type;
    };
} // namespace typelist
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
 
 
#endif

Browse

Tools

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [ext/] [typelist.h] - Blame information for rev 35

Line No.	Rev	Author	Line
1	35	ultra_embe	`// -- 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`