Alchemy  1.0
A framework to robustly process network messages and structured data
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
type_list.h
1 /// @file meta/type_list.h
2 ///
3 /// Defines the TypeList construct.
4 ///
5 /// The TypeList can be used to hold a collection of ordered types.
6 /// The template declaration syntax more closely resembles an array.
7 /// However, it is still a Typelist.
8 ///
9 /// The MIT License(MIT)
10 /// @copyright 2014 Paul M Watt
11 // ****************************************************************************
12 #ifndef TYPE_LIST_H_INCLUDED
13 #define TYPE_LIST_H_INCLUDED
14 // Includes *******************************************************************
15 #include <Pb/meta_fwd.h>
16 #include <Pb/type_node.h>
17 #include <Pb/meta_macros.h>
18 
19 namespace Hg
20 {
21 
22 // ****************************************************************************
23 /// A template-type list that is composed from a collection of types.
24 ///
25 /// A TypeList contains a collection of types that can be referenced
26 /// programmatically by their position in the container.
27 ///
28 /// ~~~{.cpp}
29 /// template < typename T0, typename T1, typename T2, typename T3,
30 /// typename T4, typename T5, typename T6, typename T7,
31 /// typename T8, typename T9, typename T10,typename T11,
32 /// typename T12,typename T13,typename T14,typename T15,
33 /// typename T16,typename T17,typename T18,typename T19,
34 /// typename T20,typename T21,typename T22,typename T23,
35 /// typename T24,typename T25,typename T26,typename T27,
36 /// typename T28,typename T29,typename T30,typename T31
37 /// >
38 /// struct TypeList
39 /// : container_trait
40 /// {
41 /// typedef TypeNode<T1,
42 /// TypeNode<T2,
43 /// TypeNode<T3,
44 /// TypeNode<T4,
45 /// TypeNode<T5,
46 /// TypeNode<T6,
47 /// TypeNode<T7,
48 /// TypeNode<T8,
49 /// TypeNode<T9,
50 /// TypeNode<T10,
51 /// TypeNode<T11,
52 /// TypeNode<T12,
53 /// TypeNode<T13,
54 /// TypeNode<T14,
55 /// TypeNode<T15,
56 /// TypeNode<T16,
57 /// TypeNode<T17,
58 /// TypeNode<T18,
59 /// TypeNode<T19,
60 /// TypeNode<T20,
61 /// TypeNode<T21,
62 /// TypeNode<T22,
63 /// TypeNode<T23,
64 /// TypeNode<T24,
65 /// TypeNode<T25,
66 /// TypeNode<T26,
67 /// TypeNode<T27,
68 /// TypeNode<T28,
69 /// TypeNode<T29,
70 /// TypeNode<T30,
71 /// TypeNode<T31,
72 /// TypeNode<T32, MT>
73 /// > > > > > > > > > > > > > > >
74 /// > > > > > > > > > > > > > > > > type;
75 /// };
76 /// ~~~
77 ///
78 template <typename T0, typename T1 = MT, typename T2 = MT, typename T3 = MT,
79  typename T4 = MT, typename T5 = MT, typename T6 = MT, typename T7 = MT,
80  typename T8 = MT, typename T9 = MT, typename T10 = MT, typename T11 = MT,
81  typename T12 = MT, typename T13 = MT, typename T14 = MT, typename T15 = MT,
82  typename T16 = MT, typename T17 = MT, typename T18 = MT, typename T19 = MT,
83  typename T20 = MT, typename T21 = MT, typename T22 = MT, typename T23 = MT,
84  typename T24 = MT, typename T25 = MT, typename T26 = MT, typename T27 = MT,
85  typename T28 = MT, typename T29 = MT, typename T30 = MT, typename T31 = MT
86 >
87 struct TypeList
88  : container_trait
89 {
90  // This typedef and MACRO declaration results in the definition
91  // listed in the comments for this type.
92 
93  // This typedef and MACRO declaration results in the definition
94  // listed in the comments for this type.
95  // The DECLARE_TYPE_LIST MACRO us an indirection because the generated
96  // code contains a comma.
97 #define DECLARE_TYPE_LIST TMP_ARRAY_32(TypeNode<T), MT TMP_REPEAT_32(>)
98  typedef DECLARE_TYPE_LIST type;
99 };
100 
101 // ***************************************************************************
102 /// Defines each Specialization TypeList object.
103 ///
104 /// This macro will generate a set of code for type definitions that looks like
105 /// the following, where 3 has been used for the input I.
106 ///
107 /// ~~~{.cpp}
108 /// tmp_ALCHEMY_TYPELIST_DEF(3);
109 ///
110 /// template< typename T0, typename T1, typename T2>
111 /// struct TypeList< T0, T1, T2>
112 /// : container_trait
113 /// {
114 /// typedef TypeNode<T1,
115 /// TypeNode<T2,
116 /// TypeNode<T3, MT>
117 /// > > type;
118 /// };
119 /// ~~~
120 ///
121 #define tmp_ALCHEMY_TYPELIST_DEF(S) \
122 template <TMP_ARRAY_##S(typename T)> \
123 struct TypeList<TMP_ARRAY_##S(T)> \
124  : container_trait \
125 { \
126 typedef TMP_ARRAY_##S(TypeNode<T), MT TMP_REPEAT_##S(>) type; \
127 }
128 
129 // Define specializations of this array from 1 to 31 elements *****************
130 tmp_ALCHEMY_TYPELIST_DEF(1);
131 tmp_ALCHEMY_TYPELIST_DEF(2);
132 tmp_ALCHEMY_TYPELIST_DEF(3);
133 tmp_ALCHEMY_TYPELIST_DEF(4);
134 tmp_ALCHEMY_TYPELIST_DEF(5);
135 tmp_ALCHEMY_TYPELIST_DEF(6);
136 tmp_ALCHEMY_TYPELIST_DEF(7);
137 tmp_ALCHEMY_TYPELIST_DEF(8);
138 tmp_ALCHEMY_TYPELIST_DEF(9);
139 tmp_ALCHEMY_TYPELIST_DEF(10);
140 tmp_ALCHEMY_TYPELIST_DEF(11);
141 tmp_ALCHEMY_TYPELIST_DEF(12);
142 tmp_ALCHEMY_TYPELIST_DEF(13);
143 tmp_ALCHEMY_TYPELIST_DEF(14);
144 tmp_ALCHEMY_TYPELIST_DEF(15);
145 tmp_ALCHEMY_TYPELIST_DEF(16);
146 tmp_ALCHEMY_TYPELIST_DEF(17);
147 tmp_ALCHEMY_TYPELIST_DEF(18);
148 tmp_ALCHEMY_TYPELIST_DEF(19);
149 tmp_ALCHEMY_TYPELIST_DEF(20);
150 tmp_ALCHEMY_TYPELIST_DEF(21);
151 tmp_ALCHEMY_TYPELIST_DEF(22);
152 tmp_ALCHEMY_TYPELIST_DEF(23);
153 tmp_ALCHEMY_TYPELIST_DEF(24);
154 tmp_ALCHEMY_TYPELIST_DEF(25);
155 tmp_ALCHEMY_TYPELIST_DEF(26);
156 tmp_ALCHEMY_TYPELIST_DEF(27);
157 tmp_ALCHEMY_TYPELIST_DEF(28);
158 tmp_ALCHEMY_TYPELIST_DEF(29);
159 tmp_ALCHEMY_TYPELIST_DEF(30);
160 tmp_ALCHEMY_TYPELIST_DEF(31);
161 
162 #undef tmp_ALCHEMY_TYPELIST_DEF
163 
164 } // namespace Hg
165 
166 
167 
168 #endif
Generated on Sat May 9 2015 21:25:05 for Alchemy by   doxygen 1.8.3.1