[thirdparty/gcc.git] / libstdc++-v3 / include / ext / typelist.h

// -*- C++ -*-

// Copyright (C) 2005, 2006, 2008 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 2, 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.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

// 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 typelist.h
 * Contains typelist_chain definitions.
 * Typelists are an idea by Andrei Alexandrescu.
 */

#ifndef _TYPELIST_H
#define _TYPELIST_H 1

#include <ext/type_traits.h>

_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)

/** @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


_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)

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

#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) >

_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)

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


#endif
Commit	Line	Data
fd1e1726 BK	1	// -- C++ --
fd1e1726 BK	2
d466a7e2	3	// Copyright (C) 2005, 2006, 2008 Free Software Foundation, Inc.
fd1e1726 BK	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
83f51799	18	// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
fd1e1726 BK	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
d7f245b1 BK	46	#ifndef _TYPELIST_H
d7f245b1 BK	47	#define _TYPELIST_H 1
cbe5ba46 BK	48
cbe5ba46 BK	49	#include <ext/type_traits.h>
fd1e1726	50
3cbc7af0 BK	51	_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
3cbc7af0 BK	52
939759fc BK	53	/** @namespace __gnu_cxx::typelist
	54	* @brief GNU typelist extensions for public compile-time use.
	55	*/
cad367a6 BK	56	namespace typelist
cad367a6 BK	57	{
fd1e1726 BK	58	struct null_type { };
	59
	60	template<typename Root>
cad367a6	61	struct node
fd1e1726 BK	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
d466a7e2 BK	74	// Apply all typelist types to unary functor.
d466a7e2 BK	75	template<typename Fn, typename Typelist>
d7f245b1 BK	76	void
	77	apply(Fn&, Typelist);
	78
d466a7e2 BK	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
fd1e1726 BK	89	template<typename Typelist0, typename Typelist1>
	90	struct append;
	91
	92	template<typename Typelist_Typelist>
cad367a6	93	struct append_typelist;
fd1e1726 BK	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
fd1e1726 BK	104	template<typename Typelist, template<typename T> class Transform>
fd1e1726 BK	105	struct transform;
d7f245b1 BK	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;
cad367a6	131	} // namespace typelist
fd1e1726	132
3cbc7af0 BK	133	_GLIBCXX_END_NAMESPACE
	134
	135
	136	_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
fd1e1726	137
cad367a6 BK	138	namespace typelist
cad367a6 BK	139	{
fd1e1726 BK	140	namespace detail
fd1e1726 BK	141	{
fd1e1726 BK	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
d466a7e2	149	operator()(Fn& f)
fd1e1726	150	{
3441f106	151	f.operator()(Hd());
fd1e1726 BK	152	apply_<Fn, Tl> next;
	153	next(f);
	154	}
d466a7e2	155	};
fd1e1726 BK	156
	157	template<typename Fn>
	158	struct apply_<Fn, null_type>
	159	{
	160	void
	161	operator()(Fn&) { }
d466a7e2 BK	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	};
fd1e1726	207
fd1e1726 BK	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	{
d7f245b1 BK	214	private:
	215	typedef append_<Tl, Typelist_Chain> append_type;
	216
	217	public:
	218	typedef chain<Hd, typename append_type::type> type;
fd1e1726 BK	219	};
	220
	221	template<typename Typelist_Chain>
	222	struct append_<null_type, Typelist_Chain>
d7f245b1 BK	223	{
	224	typedef Typelist_Chain type;
	225	};
	226
	227	template<typename Typelist_Chain>
	228	struct append_<Typelist_Chain, null_type>
fd1e1726 BK	229	{
	230	typedef Typelist_Chain type;
	231	};
	232
d7f245b1 BK	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
fd1e1726 BK	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
fd1e1726 BK	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	{
d7f245b1	294	typedef null_type type;
fd1e1726 BK	295	};
	296
	297	template<typename Hd, typename Tl, template<typename T> class Pred>
	298	struct chain_filter_<chain<Hd, Tl>, Pred>
	299	{
d7f245b1	300	private:
fd1e1726 BK	301	enum
	302	{
	303	include_hd = Pred<Hd>::value
	304	};
	305
d7f245b1 BK	306	typedef typename chain_filter_<Tl, Pred>::type rest_type;
	307	typedef chain<Hd, rest_type> chain_type;
	308
	309	public:
cbe5ba46	310	typedef typename __conditional_type<include_hd, chain_type, rest_type>::__type type;
fd1e1726 BK	311	};
fd1e1726 BK	312
fd1e1726 BK	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	{
d7f245b1	325	typedef typename chain_at_index_<Tl, i - 1>::type type;
fd1e1726 BK	326	};
fd1e1726 BK	327
fd1e1726 BK	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	{
d7f245b1	334	typedef null_type type;
fd1e1726 BK	335	};
	336
	337	template<class Hd, class Tl, template<typename T> class Transform>
	338	struct chain_transform_<chain<Hd, Tl>, Transform>
	339	{
d7f245b1 BK	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;
fd1e1726 BK	346	};
fd1e1726 BK	347
fd1e1726	348	template<typename Typelist_Typelist_Chain>
d7f245b1	349	struct chain_flatten_;
fd1e1726	350
d7f245b1	351	template<typename Hd_Tl>
d466a7e2 BK	352	struct chain_flatten_<chain<Hd_Tl, null_type> >
	353	{
	354	typedef typename Hd_Tl::root type;
	355	};
fd1e1726	356
d7f245b1	357	template<typename Hd_Typelist, class Tl_Typelist>
d466a7e2 BK	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	};
fd1e1726	366	} // namespace detail
cad367a6	367	} // namespace typelist
fd1e1726	368
3cbc7af0 BK	369	_GLIBCXX_END_NAMESPACE
3cbc7af0 BK	370
d7f245b1 BK	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) >
3cbc7af0 BK	386
3cbc7af0 BK	387	_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
fd1e1726	388
cad367a6 BK	389	namespace typelist
cad367a6 BK	390	{
d466a7e2	391	template<typename Fn, typename Typelist>
d7f245b1 BK	392	void
d7f245b1 BK	393	apply(Fn& fn, Typelist)
fd1e1726	394	{
d7f245b1 BK	395	detail::apply_<Fn, typename Typelist::root> a;
	396	a(fn);
	397	}
fd1e1726	398
d466a7e2 BK	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
fd1e1726 BK	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:
d7f245b1	426	typedef node<typename append_type::type> type;
fd1e1726 BK	427	};
	428
	429	template<typename Typelist_Typelist>
cad367a6	430	struct append_typelist
fd1e1726 BK	431	{
	432	private:
	433	typedef typename Typelist_Typelist::root root_type;
cad367a6	434	typedef detail::append_typelist_<root_type> append_type;
fd1e1726 BK	435
fd1e1726 BK	436	public:
d7f245b1	437	typedef node<typename append_type::type> type;
fd1e1726 BK	438	};
	439
	440	template<typename Typelist, typename T>
	441	struct contains
	442	{
d7f245b1	443	private:
fd1e1726 BK	444	typedef typename Typelist::root root_type;
fd1e1726 BK	445
d7f245b1	446	public:
fd1e1726 BK	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:
d7f245b1	461	typedef node<typename filter_type::type> type;
fd1e1726 BK	462	};
	463
	464	template<typename Typelist, int i>
	465	struct at_index
	466	{
d7f245b1	467	private:
fd1e1726 BK	468	typedef typename Typelist::root root_type;
	469	typedef detail::chain_at_index_<root_type, i> index_type;
	470
d7f245b1	471	public:
fd1e1726 BK	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:
cad367a6	483	typedef node<typename transform_type::type> type;
fd1e1726	484	};
d7f245b1 BK	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	};
cad367a6	544	} // namespace typelist
3cbc7af0	545	_GLIBCXX_END_NAMESPACE
fd1e1726 BK	546
fd1e1726 BK	547
fd1e1726 BK	548	#endif
fd1e1726 BK	549