Lumiera 0.pre.04~rc.1
»edit your freedom«
Loading...
Searching...
No Matches
typelist-manip-test.cpp
Go to the documentation of this file.
1/*
2 TypeListManip(Test) - appending, mixing and filtering typelists
3
4 Copyright (C)
5 2008, Hermann Vosseler <Ichthyostega@web.de>
6
7  **Lumiera** is free software; you can redistribute it and/or modify it
8  under the terms of the GNU General Public License as published by the
9  Free Software Foundation; either version 2 of the License, or (at your
10  option) any later version. See the file COPYING for further details.
11
12* *****************************************************************/
13
14
32#include "lib/test/run.hpp"
33#include "lib/meta/generator.hpp"
34#include "lib/meta/typelist-manip.hpp"
35#include "meta/typelist-diagnostics.hpp"
36
37#include <type_traits>
38
39using std::is_same;
40
41
42namespace lib {
43namespace meta {
44namespace test {
45
46 namespace { // type-lists to test with
47
48 using List1 = Types< Num<1>
49 , Num<2>
50 , Num<3>
51 >::List;
52 using List2 = Types< Num<5>
53 , Num<6>
54 , Num<7>
55 >::List;
56
57
58 // see also the CountDown template in typelist-diagnostics.hpp...
59
60 } // (End) test data
61
62
63
64
65
66
67 /*********************************************************************/
78 class TypeListManip_test : public Test
79 {
80 virtual void
95
96
98 void
99 demonstrate_diagnostics ()
100 {
101 // Explanation: the DISPLAY macro results in the following definition....
102 typedef InstantiateChained<List1::List, Printer, NullP > Contents_List1;
103 cout << "List1" << "\t:" << Contents_List1::show() << endl;
104
105 // That is: we instantiate the "Printer" template for each of the types in List1,
106 // forming an inheritance chain. I.e. the defined Type "Contents_List1" inherits
107 // from each instantiation (single inheritance).
108 // The print() function is defined to create a string showing each.
109
110 DISPLAY (List2);
111
112 // Furthermore, we use verification against lib::test::ExpectString,
113 // which can be given as literal "some text"_expect, to document and
114 // verify that the rendered type structure is indeed as expected
115 CHECK (showType<List1>() == "-<1>-<2>-<3>-"_expect);
116
117 EXPECT (List2, "-<5>-<6>-<7>-");
118 }
119
120
122 void
123 verify_pick ()
124 {
125 using E0 = Pick<List2,0>::Type;
126 using E1 = Pick<List2,1>::Type;
127 using E2 = Pick<List2,2>::Type;
128
129 using E3 = Pick<List2,3>::Type;
130 using NilE = Pick<Nil, 23>::Type;
131 using Bull = Pick<void*,456>::Type;
132 using Shit = Pick<string,0>::Type;
133
134 CHECK ((is_same<E0, Num<5> >() ));
135 CHECK ((is_same<E1, Num<6> >() ));
136 CHECK ((is_same<E2, Num<7> >() ));
137
138 CHECK ((is_same<E3, Nil >() ));
139 CHECK ((is_same<NilE, Nil >() ));
140 CHECK ((is_same<Bull, Nil >() ));
141 CHECK ((is_same<Shit, Nil >() ));
142
143 // note: in the end, all this meta-processing yields types,
144 // which can be instantiated and used as if defined directly
145 E0 e0;
146 E1 e1;
147 E2 e2;
148 CHECK (5 == e0);
149 CHECK (6 == e1);
150 CHECK (7 == e2);
151 CHECK (7 == e2.o_);
152 }
153
154
155 void
156 verify_last()
157 {
158 using Elm = PickLast<List1>::Type;
159 using Prefix = PickLast<List1>::List;
160
161 using ElmL = Types<Elm>::List;
162
163 EXPECT (Prefix, "-<1>-<2>-");
164 EXPECT (ElmL , "-<3>-" );
165
166 using Elm1 = PickLast<ElmL>::Type;
167 using NPrefix = PickLast<ElmL>::List;
168
169 EXPECT (Types<Elm1>, "-<3>-");
170 EXPECT (NPrefix , "-");
171
172 using NilSplit = PickLast<Nil>::Type;
173 using NilList = PickLast<Nil>::List;
174
175 EXPECT (NilSplit, "-");
176 EXPECT (NilList , "-");
177 }
178
179
181 void
182 verify_append ()
183 {
184 using Append1 = Append<Nil , Nil >; EXPECT (Append1, "-" );
185 using Append2 = Append<Num<11> , Num<22> >; EXPECT (Append2, "-<11>-<22>-" );
186 using Append3 = Append<Num<111>, Nil >; EXPECT (Append3, "-<111>-" );
187 using Append4 = Append<Nil , Num<222>>; EXPECT (Append4, "-<222>-" );
188 using Append5 = Append<List1 , Nil >; EXPECT (Append5, "-<1>-<2>-<3>-" );
189 using Append6 = Append<Nil , List2 >; EXPECT (Append6, "-<5>-<6>-<7>-" );
190 using Append7 = Append<Num<111>, List2 >; EXPECT (Append7, "-<111>-<5>-<6>-<7>-" );
191 using Append8 = Append<List1 , Num<222>>; EXPECT (Append8, "-<1>-<2>-<3>-<222>-" );
192 using Append9 = Append<List1 , List2 >; EXPECT (Append9, "-<1>-<2>-<3>-<5>-<6>-<7>-");
193 }
194
195
196
204 void
205 verify_splice ()
206 { // various base lists
207 using BaLi1 = Types<Num<1>>::List; EXPECT (BaLi1, "-<1>-");
208 using BaLi2 = Types<Num<1>,Num<2>>::List; EXPECT (BaLi2, "-<1>-<2>-");
209 using BaLi3 = Types<Num<1>,Num<2>,Num<3>>::List; EXPECT (BaLi3, "-<1>-<2>-<3>-");
210 using BaLi5 = Types<Num<1>,Num<2>,Num<3>,Num<4>,Num<5>>::List;
211 EXPECT (BaLi5, "-<1>-<2>-<3>-<4>-<5>-");
212
213 // will "paste" those overlay lists "on top" the base typelists...
214 using OLi1 = Types<Num<9>>::List; EXPECT (OLi1, "-<9>-");
215 using OLi2 = Types<Num<9>,Num<8>>::List; EXPECT (OLi2, "-<9>-<8>-");
216 using OLi3 = Types<Num<9>,Num<8>,Num<7>>::List; EXPECT (OLi3, "-<9>-<8>-<7>-");
217
218
220 // (1) simple cases : on top of 3-element base list
221 using Spli01 = Splice<BaLi3, OLi1>; EXPECT (Spli01, "-<9>-<2>-<3>-");
222 using Spli02 = Splice<BaLi3, OLi1, 1>; EXPECT (Spli02, "-<1>-<9>-<3>-");
223 using Spli03 = Splice<BaLi3, OLi1, 2>; EXPECT (Spli03, "-<1>-<2>-<9>-");
224 using Spli04 = Splice<BaLi3, OLi1, 3>; EXPECT (Spli04, "-<1>-<2>-<3>-");
225 using Spli05 = Splice<BaLi3, OLi1, 5>; EXPECT (Spli05, "-<1>-<2>-<3>-");
226
227 using Spli06 = Splice<BaLi3, OLi2, 0>; EXPECT (Spli06, "-<9>-<8>-<3>-");
228 using Spli07 = Splice<BaLi3, OLi2, 1>; EXPECT (Spli07, "-<1>-<9>-<8>-");
229 using Spli08 = Splice<BaLi3, OLi2, 2>; EXPECT (Spli08, "-<1>-<2>-<9>-");
230 using Spli09 = Splice<BaLi3, OLi2, 3>; EXPECT (Spli09, "-<1>-<2>-<3>-");
231 using Spli10 = Splice<BaLi3, OLi2, 5>; EXPECT (Spli10, "-<1>-<2>-<3>-");
232
233 using Spli11 = Splice<BaLi3, OLi3, 0>; EXPECT (Spli11, "-<9>-<8>-<7>-");
234 using Spli12 = Splice<BaLi3, OLi3, 1>; EXPECT (Spli12, "-<1>-<9>-<8>-");
235 using Spli13 = Splice<BaLi3, OLi3, 2>; EXPECT (Spli13, "-<1>-<2>-<9>-");
236 using Spli14 = Splice<BaLi3, OLi3, 3>; EXPECT (Spli14, "-<1>-<2>-<3>-");
237 using Spli15 = Splice<BaLi3, OLi3, 5>; EXPECT (Spli15, "-<1>-<2>-<3>-");
238
239 // (1b) corresponding Front / Back cases
240 using Frnt01 = Splice<BaLi3, OLi1> ::Front; EXPECT (Frnt01, "-");
241 using Frnt02 = Splice<BaLi3, OLi1, 1>::Front; EXPECT (Frnt02, "-<1>-");
242 using Frnt03 = Splice<BaLi3, OLi1, 2>::Front; EXPECT (Frnt03, "-<1>-<2>-");
243 using Frnt04 = Splice<BaLi3, OLi1, 3>::Front; EXPECT (Frnt04, "-<1>-<2>-<3>-");
244 using Frnt05 = Splice<BaLi3, OLi1, 5>::Front; EXPECT (Frnt05, "-<1>-<2>-<3>-");
245
246 using Frnt06 = Splice<BaLi3, OLi2, 0>::Front; EXPECT (Frnt06, "-");
247 using Frnt07 = Splice<BaLi3, OLi2, 1>::Front; EXPECT (Frnt07, "-<1>-");
248 using Frnt08 = Splice<BaLi3, OLi2, 2>::Front; EXPECT (Frnt08, "-<1>-<2>-");
249 using Frnt09 = Splice<BaLi3, OLi2, 3>::Front; EXPECT (Frnt09, "-<1>-<2>-<3>-");
250 using Frnt10 = Splice<BaLi3, OLi2, 5>::Front; EXPECT (Frnt10, "-<1>-<2>-<3>-");
251
252 using Frnt11 = Splice<BaLi3, OLi3, 0>::Front; EXPECT (Frnt11, "-");
253 using Frnt12 = Splice<BaLi3, OLi3, 1>::Front; EXPECT (Frnt12, "-<1>-");
254 using Frnt13 = Splice<BaLi3, OLi3, 2>::Front; EXPECT (Frnt13, "-<1>-<2>-");
255 using Frnt14 = Splice<BaLi3, OLi3, 3>::Front; EXPECT (Frnt14, "-<1>-<2>-<3>-");
256 using Frnt15 = Splice<BaLi3, OLi3, 5>::Front; EXPECT (Frnt15, "-<1>-<2>-<3>-");
257
258 using Back01 = Splice<BaLi3, OLi1> ::Back; EXPECT (Back01, "-<2>-<3>-");
259 using Back02 = Splice<BaLi3, OLi1, 1>::Back; EXPECT (Back02, "-<3>-");
260 using Back03 = Splice<BaLi3, OLi1, 2>::Back; EXPECT (Back03, "-");
261 using Back04 = Splice<BaLi3, OLi1, 3>::Back; EXPECT (Back04, "-");
262 using Back05 = Splice<BaLi3, OLi1, 5>::Back; EXPECT (Back05, "-");
263
264 using Back06 = Splice<BaLi3, OLi2, 0>::Back; EXPECT (Back06, "-<3>-");
265 using Back07 = Splice<BaLi3, OLi2, 1>::Back; EXPECT (Back07, "-");
266 using Back08 = Splice<BaLi3, OLi2, 2>::Back; EXPECT (Back08, "-");
267 using Back09 = Splice<BaLi3, OLi2, 3>::Back; EXPECT (Back09, "-");
268 using Back10 = Splice<BaLi3, OLi2, 5>::Back; EXPECT (Back10, "-");
269
270 using Back11 = Splice<BaLi3, OLi3, 0>::Back; EXPECT (Back11, "-");
271 using Back12 = Splice<BaLi3, OLi3, 1>::Back; EXPECT (Back12, "-");
272 using Back13 = Splice<BaLi3, OLi3, 2>::Back; EXPECT (Back13, "-");
273 using Back14 = Splice<BaLi3, OLi3, 3>::Back; EXPECT (Back14, "-");
274 using Back15 = Splice<BaLi3, OLi3, 5>::Back; EXPECT (Back15, "-");
275
276
278 // (2) simple cases : on top of 5-element base list
279 using Spli16 = Splice<BaLi5, OLi1>; EXPECT (Spli16, "-<9>-<2>-<3>-<4>-<5>-");
280 using Spli17 = Splice<BaLi5, OLi1, 1>; EXPECT (Spli17, "-<1>-<9>-<3>-<4>-<5>-");
281 using Spli18 = Splice<BaLi5, OLi1, 2>; EXPECT (Spli18, "-<1>-<2>-<9>-<4>-<5>-");
282 using Spli19 = Splice<BaLi5, OLi1, 3>; EXPECT (Spli19, "-<1>-<2>-<3>-<9>-<5>-");
283 using Spli20 = Splice<BaLi5, OLi1, 4>; EXPECT (Spli20, "-<1>-<2>-<3>-<4>-<9>-");
284 using Spli21 = Splice<BaLi5, OLi1, 5>; EXPECT (Spli21, "-<1>-<2>-<3>-<4>-<5>-");
285 using Spli22 = Splice<BaLi5, OLi1, 8>; EXPECT (Spli22, "-<1>-<2>-<3>-<4>-<5>-");
286
287 using Spli23 = Splice<BaLi5, OLi2, 0>; EXPECT (Spli23, "-<9>-<8>-<3>-<4>-<5>-");
288 using Spli24 = Splice<BaLi5, OLi2, 1>; EXPECT (Spli24, "-<1>-<9>-<8>-<4>-<5>-");
289 using Spli25 = Splice<BaLi5, OLi2, 2>; EXPECT (Spli25, "-<1>-<2>-<9>-<8>-<5>-");
290 using Spli26 = Splice<BaLi5, OLi2, 3>; EXPECT (Spli26, "-<1>-<2>-<3>-<9>-<8>-");
291 using Spli27 = Splice<BaLi5, OLi2, 4>; EXPECT (Spli27, "-<1>-<2>-<3>-<4>-<9>-");
292 using Spli28 = Splice<BaLi5, OLi2, 5>; EXPECT (Spli28, "-<1>-<2>-<3>-<4>-<5>-");
293 using Spli29 = Splice<BaLi5, OLi2, 8>; EXPECT (Spli29, "-<1>-<2>-<3>-<4>-<5>-");
294
295 using Spli30 = Splice<BaLi5, OLi3, 0>; EXPECT (Spli30, "-<9>-<8>-<7>-<4>-<5>-");
296 using Spli31 = Splice<BaLi5, OLi3, 1>; EXPECT (Spli31, "-<1>-<9>-<8>-<7>-<5>-");
297 using Spli32 = Splice<BaLi5, OLi3, 2>; EXPECT (Spli32, "-<1>-<2>-<9>-<8>-<7>-");
298 using Spli33 = Splice<BaLi5, OLi3, 3>; EXPECT (Spli33, "-<1>-<2>-<3>-<9>-<8>-");
299 using Spli34 = Splice<BaLi5, OLi3, 4>; EXPECT (Spli34, "-<1>-<2>-<3>-<4>-<9>-");
300 using Spli35 = Splice<BaLi5, OLi3, 5>; EXPECT (Spli35, "-<1>-<2>-<3>-<4>-<5>-");
301 using Spli36 = Splice<BaLi5, OLi3, 8>; EXPECT (Spli36, "-<1>-<2>-<3>-<4>-<5>-");
302
303 // (2b) corresponding Front / Back cases
304 using Frnt16 = Splice<BaLi5, OLi1> ::Front; EXPECT (Frnt16, "-");
305 using Frnt17 = Splice<BaLi5, OLi1, 1>::Front; EXPECT (Frnt17, "-<1>-");
306 using Frnt18 = Splice<BaLi5, OLi1, 2>::Front; EXPECT (Frnt18, "-<1>-<2>-");
307 using Frnt19 = Splice<BaLi5, OLi1, 3>::Front; EXPECT (Frnt19, "-<1>-<2>-<3>-");
308 using Frnt20 = Splice<BaLi5, OLi1, 4>::Front; EXPECT (Frnt20, "-<1>-<2>-<3>-<4>-");
309 using Frnt21 = Splice<BaLi5, OLi1, 5>::Front; EXPECT (Frnt21, "-<1>-<2>-<3>-<4>-<5>-");
310 using Frnt22 = Splice<BaLi5, OLi1, 8>::Front; EXPECT (Frnt22, "-<1>-<2>-<3>-<4>-<5>-");
311
312 using Frnt23 = Splice<BaLi5, OLi2, 0>::Front; EXPECT (Frnt23, "-");
313 using Frnt24 = Splice<BaLi5, OLi2, 1>::Front; EXPECT (Frnt24, "-<1>-");
314 using Frnt25 = Splice<BaLi5, OLi2, 2>::Front; EXPECT (Frnt25, "-<1>-<2>-");
315 using Frnt26 = Splice<BaLi5, OLi2, 3>::Front; EXPECT (Frnt26, "-<1>-<2>-<3>-");
316 using Frnt27 = Splice<BaLi5, OLi2, 4>::Front; EXPECT (Frnt27, "-<1>-<2>-<3>-<4>-");
317 using Frnt28 = Splice<BaLi5, OLi2, 5>::Front; EXPECT (Frnt28, "-<1>-<2>-<3>-<4>-<5>-");
318 using Frnt29 = Splice<BaLi5, OLi2, 8>::Front; EXPECT (Frnt29, "-<1>-<2>-<3>-<4>-<5>-");
319
320 using Frnt30 = Splice<BaLi5, OLi3, 0>::Front; EXPECT (Frnt30, "-");
321 using Frnt31 = Splice<BaLi5, OLi3, 1>::Front; EXPECT (Frnt31, "-<1>-");
322 using Frnt32 = Splice<BaLi5, OLi3, 2>::Front; EXPECT (Frnt32, "-<1>-<2>-");
323 using Frnt33 = Splice<BaLi5, OLi3, 3>::Front; EXPECT (Frnt33, "-<1>-<2>-<3>-");
324 using Frnt34 = Splice<BaLi5, OLi3, 4>::Front; EXPECT (Frnt34, "-<1>-<2>-<3>-<4>-");
325 using Frnt35 = Splice<BaLi5, OLi3, 5>::Front; EXPECT (Frnt35, "-<1>-<2>-<3>-<4>-<5>-");
326 using Frnt36 = Splice<BaLi5, OLi3, 8>::Front; EXPECT (Frnt36, "-<1>-<2>-<3>-<4>-<5>-");
327
328 using Back16 = Splice<BaLi5, OLi1> ::Back; EXPECT (Back16, "-<2>-<3>-<4>-<5>-");
329 using Back17 = Splice<BaLi5, OLi1, 1>::Back; EXPECT (Back17, "-<3>-<4>-<5>-");
330 using Back18 = Splice<BaLi5, OLi1, 2>::Back; EXPECT (Back18, "-<4>-<5>-");
331 using Back19 = Splice<BaLi5, OLi1, 3>::Back; EXPECT (Back19, "-<5>-");
332 using Back20 = Splice<BaLi5, OLi1, 4>::Back; EXPECT (Back20, "-");
333 using Back21 = Splice<BaLi5, OLi1, 5>::Back; EXPECT (Back21, "-");
334 using Back22 = Splice<BaLi5, OLi1, 8>::Back; EXPECT (Back22, "-");
335
336 using Back23 = Splice<BaLi5, OLi2, 0>::Back; EXPECT (Back23, "-<3>-<4>-<5>-");
337 using Back24 = Splice<BaLi5, OLi2, 1>::Back; EXPECT (Back24, "-<4>-<5>-");
338 using Back25 = Splice<BaLi5, OLi2, 2>::Back; EXPECT (Back25, "-<5>-");
339 using Back26 = Splice<BaLi5, OLi2, 3>::Back; EXPECT (Back26, "-");
340 using Back27 = Splice<BaLi5, OLi2, 4>::Back; EXPECT (Back27, "-");
341 using Back28 = Splice<BaLi5, OLi2, 5>::Back; EXPECT (Back28, "-");
342 using Back29 = Splice<BaLi5, OLi2, 8>::Back; EXPECT (Back29, "-");
343
344 using Back30 = Splice<BaLi5, OLi3, 0>::Back; EXPECT (Back30, "-<4>-<5>-");
345 using Back31 = Splice<BaLi5, OLi3, 1>::Back; EXPECT (Back31, "-<5>-");
346 using Back32 = Splice<BaLi5, OLi3, 2>::Back; EXPECT (Back32, "-");
347 using Back33 = Splice<BaLi5, OLi3, 3>::Back; EXPECT (Back33, "-");
348 using Back34 = Splice<BaLi5, OLi3, 4>::Back; EXPECT (Back34, "-");
349 using Back35 = Splice<BaLi5, OLi3, 5>::Back; EXPECT (Back35, "-");
350 using Back36 = Splice<BaLi5, OLi3, 8>::Back; EXPECT (Back36, "-");
351
352
354 // (3) degenerate case : excess overlay over smaller base
355 using Spli37 = Splice<BaLi2, OLi3, 0>; EXPECT (Spli37, "-<9>-<8>-");
356 using Spli38 = Splice<BaLi2, OLi3, 1>; EXPECT (Spli38, "-<1>-<9>-");
357 using Spli39 = Splice<BaLi2, OLi3, 2>; EXPECT (Spli39, "-<1>-<2>-");
358 using Spli40 = Splice<BaLi2, OLi3, 5>; EXPECT (Spli40, "-<1>-<2>-");
359
360 using Spli41 = Splice<BaLi1, OLi3, 0>; EXPECT (Spli41, "-<9>-");
361 using Spli42 = Splice<BaLi1, OLi3, 1>; EXPECT (Spli42, "-<1>-");
362 using Spli43 = Splice<BaLi1, OLi3, 2>; EXPECT (Spli43, "-<1>-");
363 using Spli44 = Splice<BaLi1, OLi3, 5>; EXPECT (Spli44, "-<1>-");
364
365 // (3b) corresponding Front / Back cases
366 using Frnt37 = Splice<BaLi2, OLi3, 0>::Front; EXPECT (Frnt37, "-");
367 using Frnt38 = Splice<BaLi2, OLi3, 1>::Front; EXPECT (Frnt38, "-<1>-");
368 using Frnt39 = Splice<BaLi2, OLi3, 2>::Front; EXPECT (Frnt39, "-<1>-<2>-");
369 using Frnt40 = Splice<BaLi2, OLi3, 5>::Front; EXPECT (Frnt40, "-<1>-<2>-");
370
371 using Frnt41 = Splice<BaLi1, OLi3, 0>::Front; EXPECT (Frnt41, "-");
372 using Frnt42 = Splice<BaLi1, OLi3, 1>::Front; EXPECT (Frnt42, "-<1>-");
373 using Frnt43 = Splice<BaLi1, OLi3, 2>::Front; EXPECT (Frnt43, "-<1>-");
374 using Frnt44 = Splice<BaLi1, OLi3, 5>::Front; EXPECT (Frnt44, "-<1>-");
375
376 using Back37 = Splice<BaLi2, OLi3, 0>::Back; EXPECT (Back37, "-");
377 using Back38 = Splice<BaLi2, OLi3, 1>::Back; EXPECT (Back38, "-");
378 using Back39 = Splice<BaLi2, OLi3, 2>::Back; EXPECT (Back39, "-");
379 using Back40 = Splice<BaLi2, OLi3, 5>::Back; EXPECT (Back40, "-");
380
381 using Back41 = Splice<BaLi1, OLi3, 0>::Back; EXPECT (Back41, "-");
382 using Back42 = Splice<BaLi1, OLi3, 1>::Back; EXPECT (Back42, "-");
383 using Back43 = Splice<BaLi1, OLi3, 2>::Back; EXPECT (Back43, "-");
384 using Back44 = Splice<BaLi1, OLi3, 5>::Back; EXPECT (Back44, "-");
385
386
388 // (4) degenerate case : empty base
389 using Spli45 = Splice<Nil, OLi3, 0>; EXPECT (Spli45, "-");
390 using Spli46 = Splice<Nil, OLi3, 1>; EXPECT (Spli46, "-");
391 using Spli47 = Splice<Nil, OLi3, 5>; EXPECT (Spli47, "-");
392
393 using Spli48 = Splice<Nil, OLi1, 0>; EXPECT (Spli48, "-");
394 using Spli49 = Splice<Nil, OLi1, 1>; EXPECT (Spli49, "-");
395 using Spli50 = Splice<Nil, OLi1, 5>; EXPECT (Spli50, "-");
396
397 using Spli51 = Splice<Nil, Nil, 0>; EXPECT (Spli51, "-");
398 using Spli52 = Splice<Nil, Nil, 1>; EXPECT (Spli52, "-");
399 using Spli53 = Splice<Nil, Nil, 5>; EXPECT (Spli53, "-");
400
401 // (4b) corresponding Front / Back cases
402 using Frnt45 = Splice<Nil, OLi3, 0>::Front; EXPECT (Frnt45, "-");
403 using Frnt46 = Splice<Nil, OLi3, 1>::Front; EXPECT (Frnt46, "-");
404 using Frnt47 = Splice<Nil, OLi3, 5>::Front; EXPECT (Frnt47, "-");
405
406 using Frnt48 = Splice<Nil, OLi1, 0>::Front; EXPECT (Frnt48, "-");
407 using Frnt49 = Splice<Nil, OLi1, 1>::Front; EXPECT (Frnt49, "-");
408 using Frnt50 = Splice<Nil, OLi1, 5>::Front; EXPECT (Frnt50, "-");
409
410 using Frnt51 = Splice<Nil, Nil, 0>::Front; EXPECT (Frnt51, "-");
411 using Frnt52 = Splice<Nil, Nil, 1>::Front; EXPECT (Frnt52, "-");
412 using Frnt53 = Splice<Nil, Nil, 5>::Front; EXPECT (Frnt53, "-");
413
414 using Back45 = Splice<Nil, OLi3, 0>::Back; EXPECT (Back45, "-");
415 using Back46 = Splice<Nil, OLi3, 1>::Back; EXPECT (Back46, "-");
416 using Back47 = Splice<Nil, OLi3, 5>::Back; EXPECT (Back47, "-");
417
418 using Back48 = Splice<Nil, OLi1, 0>::Back; EXPECT (Back48, "-");
419 using Back49 = Splice<Nil, OLi1, 1>::Back; EXPECT (Back49, "-");
420 using Back50 = Splice<Nil, OLi1, 5>::Back; EXPECT (Back50, "-");
421
422 using Back51 = Splice<Nil, Nil, 0>::Back; EXPECT (Back51, "-");
423 using Back52 = Splice<Nil, Nil, 1>::Back; EXPECT (Back52, "-");
424 using Back53 = Splice<Nil, Nil, 5>::Back; EXPECT (Back53, "-");
425
426
428 // (4) special case : zero-splice is split
429 using Spli54 = Splice<BaLi3, Nil, 0>; EXPECT (Spli54, "-<1>-<2>-<3>-");
430 using Spli55 = Splice<BaLi3, Nil, 1>; EXPECT (Spli55, "-<1>-<2>-<3>-");
431 using Spli56 = Splice<BaLi3, Nil, 2>; EXPECT (Spli56, "-<1>-<2>-<3>-");
432 using Spli57 = Splice<BaLi3, Nil, 3>; EXPECT (Spli57, "-<1>-<2>-<3>-");
433 using Spli58 = Splice<BaLi3, Nil, 4>; EXPECT (Spli58, "-<1>-<2>-<3>-");
434 using Spli59 = Splice<BaLi3, Nil, 5>; EXPECT (Spli59, "-<1>-<2>-<3>-");
435
436 // (4b) Front / Back cases : split parts
437 using Frnt54 = Splice<BaLi3, Nil, 0>::Front; EXPECT (Frnt54, "-");
438 using Frnt55 = Splice<BaLi3, Nil, 1>::Front; EXPECT (Frnt55, "-<1>-");
439 using Frnt56 = Splice<BaLi3, Nil, 2>::Front; EXPECT (Frnt56, "-<1>-<2>-");
440 using Frnt57 = Splice<BaLi3, Nil, 3>::Front; EXPECT (Frnt57, "-<1>-<2>-<3>-");
441 using Frnt58 = Splice<BaLi3, Nil, 4>::Front; EXPECT (Frnt58, "-<1>-<2>-<3>-");
442 using Frnt59 = Splice<BaLi3, Nil, 5>::Front; EXPECT (Frnt59, "-<1>-<2>-<3>-");
443
444 using Back54 = Splice<BaLi3, Nil, 0>::Back; EXPECT (Back54, "-<1>-<2>-<3>-");
445 using Back55 = Splice<BaLi3, Nil, 1>::Back; EXPECT (Back55, "-<2>-<3>-");
446 using Back56 = Splice<BaLi3, Nil, 2>::Back; EXPECT (Back56, "-<3>-");
447 using Back57 = Splice<BaLi3, Nil, 3>::Back; EXPECT (Back57, "-");
448 using Back58 = Splice<BaLi3, Nil, 4>::Back; EXPECT (Back58, "-");
449 using Back59 = Splice<BaLi3, Nil, 5>::Back; EXPECT (Back59, "-");
450
451 // Note: these special usages are provided as shorthand
452 using Prfx55 = Prefix<BaLi3, 1>; EXPECT (Prfx55, "-<1>-");
453 using Sufx55 = Suffix<BaLi3, 1>; EXPECT (Sufx55, "-<2>-<3>-");
454 using Prfx56 = Prefix<BaLi3, 2>; EXPECT (Prfx56, "-<1>-<2>-");
455 using Sufx56 = Suffix<BaLi3, 2>; EXPECT (Sufx56, "-<3>-");
456 }
457
458
459
461 void
462 verify_dissect()
463 {
464 using LL = Append<List1,List2>::List; EXPECT (LL , "-<1>-<2>-<3>-<5>-<6>-<7>-");
465
466 using List = Dissect<LL>::List; EXPECT (List , "-<1>-<2>-<3>-<5>-<6>-<7>-");
467 using First = Dissect<LL>::First; EXPECT (First , "-<1>-" );
468 using Tail = Dissect<LL>::Tail; EXPECT (Tail , "-<2>-<3>-<5>-<6>-<7>-" );
469 using Prefix = Dissect<LL>::Prefix; EXPECT (Prefix, "-<1>-<2>-<3>-<5>-<6>-" );
470 using Last = Dissect<LL>::Last; EXPECT (Last , "-<7>-" );
471
472 using Head = Dissect<LL>::Head;
473 using End = Dissect<LL>::End;
474
475 using HeadEnd = Types<Head,End>; EXPECT (HeadEnd, "-<1>-<7>-");
476 }
477
478
479
480
481 template<class X> struct AddConst2 { typedef X Type; };
482 template<int I> struct AddConst2<Num<I>> { typedef Num<I+2> Type; };
483
485 void
486 verify_apply()
487 {
488 using Added2 = Apply<List1, AddConst2>;
489 EXPECT (List1 , "-<1>-<2>-<3>-");
490 EXPECT (Added2, "-<3>-<4>-<5>-");
491 }
492
493
494 template<class X> struct IsEven { enum {value = false }; };
495 template<int I> struct IsEven<Num<I>> { enum {value = (0 == I % 2) }; };
496
498 void
499 verify_filter()
500 {
501 CHECK (not IsEven<Num<5>>::value);
502 CHECK ( IsEven<Num<6>>::value);
503
504 using FilterEven = Filter<Append<List1,List2>::List, IsEven >;
505 EXPECT (FilterEven, "-<2>-<6>-");
506 }
507
508
509
510
517 void
518 verify_prefix ()
519 {
520 using Prefix1 = PrefixAll<Num<11>,Num<22>>;
521 // Note this creates a nested two-dimensional structure,
522 // i.e. a type-list, whose elements are again type-lists.
523 // The diagnostic helper prints each sublist in a new line,
524 // and prefixed by a tab:
525 EXPECT (Prefix1, "\n\t" "+---<11>-<22>-+-");
526
527 using Prefix2 = PrefixAll<Num<101>,List1>;
528 EXPECT (List1 , "-<1>-<2>-<3>-");
529 EXPECT (Prefix2, "\n\t" "+---<101>-<1>-+"
530 "\n\t" "+---<101>-<2>-+"
531 "\n\t" "+---<101>-<3>-+-");
532
533 using Prefix3 = PrefixAll<Nil,List1>;
534 EXPECT (Prefix3, "\n\t" "+---<1>-+"
535 "\n\t" "+---<2>-+"
536 "\n\t" "+---<3>-+-");
537
538 // Notably this can also be used to distribute into an already nested structure,
539 // since the implementation is based on Append, which will actually concatenate lists
540 // To demonstrate this, we first create a mixed list, where some elements are nested lists
541 using List_of_Lists = Types<List1::List
542 ,Num<0> // ◁—————————————— this one is a regular element
543 ,List2::List>::List;
544 EXPECT (List_of_Lists,
545 "\n\t" "+---<1>-<2>-<3>-+"
546 "-<0>" // ◁—————————————— here shows the regular element
547 "\n\t" "+---<5>-<6>-<7>-+-");
548
549 using Prefix4 = PrefixAll<Num<111>, List_of_Lists>;
550 EXPECT (Prefix4, "\n\t" "+---<111>-<1>-<2>-<3>-+" // ◁——————— concatenation »flattens« the lists
551 "\n\t" "+---<111>-<0>-+"
552 "\n\t" "+---<111>-<5>-<6>-<7>-+-");
553
554 using Prefix5 = PrefixAll<List1,List2>;
555 EXPECT (Prefix5, "\n\t" "+---<1>-<2>-<3>-<5>-+"
556 "\n\t" "+---<1>-<2>-<3>-<6>-+"
557 "\n\t" "+---<1>-<2>-<3>-<7>-+-");
558
559 using Prefix6 = PrefixAll<List1,List_of_Lists>;
560 EXPECT (Prefix6, "\n\t" "+---<1>-<2>-<3>-<1>-<2>-<3>-+"
561 "\n\t" "+---<1>-<2>-<3>-<0>-+"
562 "\n\t" "+---<1>-<2>-<3>-<5>-<6>-<7>-+-");
563 }
564
565
566
568 void
569 verify_distribute()
570 {
571 using Dist1 = Distribute<Num<11>, List1>;
572 EXPECT (Dist1, "\n\t" "+---<11>-<1>-+"
573 "\n\t" "+---<11>-<2>-+"
574 "\n\t" "+---<11>-<3>-+-");
575
576 using Prefixes = Types<Num<11>,Num<22>,Num<33>>::List;
577 using Dist2 = Distribute<Prefixes, Num<0>>;
578 EXPECT (Dist2, "\n\t" "+---<11>-<0>-+"
579 "\n\t" "+---<22>-<0>-+"
580 "\n\t" "+---<33>-<0>-+-");
581
582 using Dist3 = Distribute<Prefixes, List1>;
583 EXPECT (Dist3, "\n\t" "+---<11>-<1>-+"
584 "\n\t" "+---<11>-<2>-+"
585 "\n\t" "+---<11>-<3>-+"
586 "\n\t" "+---<22>-<1>-+"
587 "\n\t" "+---<22>-<2>-+"
588 "\n\t" "+---<22>-<3>-+"
589 "\n\t" "+---<33>-<1>-+"
590 "\n\t" "+---<33>-<2>-+"
591 "\n\t" "+---<33>-<3>-+-");
592
593 using LioLi = Types<List1::List,List2::List>::List;
594 EXPECT (LioLi, "\n\t" "+---<1>-<2>-<3>-+"
595 "\n\t" "+---<5>-<6>-<7>-+-");
596 using Dist4 = Distribute<Prefixes, LioLi>;
597 EXPECT (Dist4, "\n\t" "+---<11>-<1>-<2>-<3>-+"
598 "\n\t" "+---<11>-<5>-<6>-<7>-+"
599 "\n\t" "+---<22>-<1>-<2>-<3>-+"
600 "\n\t" "+---<22>-<5>-<6>-<7>-+"
601 "\n\t" "+---<33>-<1>-<2>-<3>-+"
602 "\n\t" "+---<33>-<5>-<6>-<7>-+-");
603 }
604
605
611 void
612 verify_combine()
613 { // ▽▽▽ ———————————————defined in typelist-diagnostic.cpp
614 using Count = CountDown<Num<11>>;
615 EXPECT (Count, "-<11>-<10>-<9>-<8>-<7>-<6>-<5>-<4>-<3>-<2>-<1>-<0>-");
616
617 // Apply on a single type and tabulate
618 using Apply = Combine<Num<5>, CountDown>;
619 EXPECT (Apply, "\n\t" "+---<5>-<·>-+"
620 "\n\t" "+---<4>-<·>-+"
621 "\n\t" "+---<3>-<·>-+"
622 "\n\t" "+---<2>-<·>-+"
623 "\n\t" "+---<1>-<·>-+"
624 "\n\t" "+---<0>-<·>-+-");
625
626 // Apply recursively to generate all combinations
627 using Combi = Combine<List1::List, CountDown>;
628 EXPECT (Combi, "\n\t" "+---<1>-<2>-<3>-<·>-+"
629 "\n\t" "+---<1>-<2>-<2>-<·>-+"
630 "\n\t" "+---<1>-<2>-<1>-<·>-+"
631 "\n\t" "+---<1>-<2>-<0>-<·>-+"
632 "\n\t" "+---<1>-<1>-<3>-<·>-+"
633 "\n\t" "+---<1>-<1>-<2>-<·>-+"
634 "\n\t" "+---<1>-<1>-<1>-<·>-+"
635 "\n\t" "+---<1>-<1>-<0>-<·>-+"
636 "\n\t" "+---<1>-<0>-<3>-<·>-+"
637 "\n\t" "+---<1>-<0>-<2>-<·>-+"
638 "\n\t" "+---<1>-<0>-<1>-<·>-+"
639 "\n\t" "+---<1>-<0>-<0>-<·>-+"
640 "\n\t" "+---<0>-<2>-<3>-<·>-+"
641 "\n\t" "+---<0>-<2>-<2>-<·>-+"
642 "\n\t" "+---<0>-<2>-<1>-<·>-+"
643 "\n\t" "+---<0>-<2>-<0>-<·>-+"
644 "\n\t" "+---<0>-<1>-<3>-<·>-+"
645 "\n\t" "+---<0>-<1>-<2>-<·>-+"
646 "\n\t" "+---<0>-<1>-<1>-<·>-+"
647 "\n\t" "+---<0>-<1>-<0>-<·>-+"
648 "\n\t" "+---<0>-<0>-<3>-<·>-+"
649 "\n\t" "+---<0>-<0>-<2>-<·>-+"
650 "\n\t" "+---<0>-<0>-<1>-<·>-+"
651 "\n\t" "+---<0>-<0>-<0>-<·>-+-");
652
653 // Special use-case: call combinations of a set of flags
654 using OnOff = CombineFlags<List1::List>;
655 EXPECT (OnOff, "\n\t" "+---<1>-<2>-<3>-<·>-+"
656 "\n\t" "+---<1>-<2>-<·>-+"
657 "\n\t" "+---<1>-<3>-<·>-+"
658 "\n\t" "+---<1>-<·>-+"
659 "\n\t" "+---<2>-<3>-<·>-+"
660 "\n\t" "+---<2>-<·>-+"
661 "\n\t" "+---<3>-<·>-+"
662 "\n\t" "+---<·>-+-");
663 }
664 };
665
666
668 LAUNCHER (TypeListManip_test, "unit common");
669
670
671
672}}} // namespace lib::meta::test
lib::meta::test::TypeListManip_test
Definition typelist-manip-test.cpp:79
lib::meta::test::TypeListManip_test::run
virtual void run(Arg)
Definition typelist-manip-test.cpp:81
lib::meta::test::TypeListManip_test::verify_last
void verify_last()
Definition typelist-manip-test.cpp:156
lib::meta::test::TypeListManip_test::verify_splice
void verify_splice()
Definition typelist-manip-test.cpp:205
lib::meta::test::TypeListManip_test::verify_prefix
void verify_prefix()
Definition typelist-manip-test.cpp:518
lib::meta::test::TypeListManip_test::verify_apply
void verify_apply()
Definition typelist-manip-test.cpp:486
lib::meta::test::TypeListManip_test::verify_pick
void verify_pick()
Definition typelist-manip-test.cpp:123
lib::meta::test::TypeListManip_test::verify_dissect
void verify_dissect()
Definition typelist-manip-test.cpp:462
lib::meta::test::TypeListManip_test::verify_append
void verify_append()
Definition typelist-manip-test.cpp:182
lib::meta::test::TypeListManip_test::demonstrate_diagnostics
void demonstrate_diagnostics()
Definition typelist-manip-test.cpp:99
lib::meta::test::TypeListManip_test::verify_filter
void verify_filter()
Definition typelist-manip-test.cpp:499
lib::meta::test::TypeListManip_test::AddConst2::Type
X Type
Definition typelist-manip-test.cpp:481
lib::meta::test::TypeListManip_test::AddConst2< Num< I > >::Type
Num< I+2 > Type
Definition typelist-manip-test.cpp:482
lib::meta::test::TypeListManip_test::verify_distribute
void verify_distribute()
Definition typelist-manip-test.cpp:569
lib::meta::test::TypeListManip_test::verify_combine
void verify_combine()
Definition typelist-manip-test.cpp:612
lib::meta::test::TypeListManip_test::AddConst2
Definition typelist-manip-test.cpp:481
generator.hpp
Helpers for working with lib::meta::Types (i.e.
lib::meta::test::anonymous_namespace{typelist-manip-test.cpp}::List1
Types< Num< 1 >, Num< 2 >, Num< 3 > >::List List1
Definition typelist-manip-test.cpp:51
lib::meta::test::anonymous_namespace{typelist-manip-test.cpp}::List2
Types< Num< 5 >, Num< 6 >, Num< 7 > >::List List2
Definition typelist-manip-test.cpp:55
lib::meta::Prefix
Splice< LI, Nil, l >::Front Prefix
extract prefix of given length
Definition typelist-manip.hpp:206
lib::meta::enable_if
enable_if_c< Cond::value, T >::type enable_if
SFINAE helper to control the visibility of specialisations and overloads.
Definition meta/util.hpp:87
lib::meta::Append::List
Node< TY1, typename Append< TY2, Nil >::List > List
Definition typelist-manip.hpp:123
lib::meta::Apply
apply a transformation (template) to each type in the list
Definition typelist-manip.hpp:85
lib::meta::CountDown
helper for generating test lists
Definition typelist-diagnostics.hpp:83
lib::meta::Dissect
Allows to access various parts of a given typelist: Start and End, Prefix and Tail....
Definition typelist-manip.hpp:220
lib::meta::Nil
»Empty« mark
Definition typelist.hpp:82
lib::meta::PickLast
access the last list element
Definition typelist-manip.hpp:150
lib::meta::Splice
splice some typelist like an overlay into a base typelist, starting at given index.
Definition typelist-manip.hpp:179
lib::meta::Types
variadic sequence of types
Definition typelist.hpp:102
lib
Implementation namespace for support and library code.
Definition common-services.cpp:55
test
Test runner and basic definitions for tests.
run.hpp
Simplistic test class runner.
LAUNCHER
#define LAUNCHER(_TEST_CLASS_, _GROUPS_)
Definition run.hpp:116
lib::meta::Num
constant-wrapper type for debugging purposes, usable for generating lists of distinguishable types
Definition typelist-diagnostics.hpp:62
lib::meta::test::TypeListManip_test::IsEven
Definition typelist-manip-test.cpp:494
lib::meta::test::TypeListManip_test::IsEven::value
@ value
Definition typelist-manip-test.cpp:494
typelist-diagnostics.hpp
Support for writing metaprogramming unit-tests dealing with typelists and flags.
EXPECT
#define EXPECT(_TY_, RENDERED_STRUCTURE)
Definition typelist-diagnostics.hpp:205
DISPLAY
#define DISPLAY(_IT_)
Definition typelist-diagnostics.hpp:199
typelist-manip.hpp
Metaprogramming: Helpers for manipulating lists-of-types.