]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | [/============================================================================== |
2 | Copyright (C) 2001-2011 Joel de Guzman | |
3 | Copyright (C) 2006 Dan Marsden | |
4 | ||
5 | Use, modification and distribution is subject to the Boost Software | |
6 | License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
7 | http://www.boost.org/LICENSE_1_0.txt) | |
8 | ===============================================================================/] | |
9 | [section Container] | |
10 | ||
11 | Fusion provides a few predefined sequences out of the box. These | |
12 | /containers/ actually hold heterogeneously typed data; unlike | |
13 | __views__. These containers are more or less counterparts of those in __stl__. | |
14 | ||
15 | [heading Header] | |
16 | ||
17 | #include <boost/fusion/container.hpp> | |
18 | #include <boost/fusion/include/container.hpp> | |
19 | ||
20 | [section vector] | |
21 | ||
22 | [heading Description] | |
23 | ||
24 | `vector` is a __random_access_sequence__ of heterogeneous typed data | |
25 | structured as a simple `struct` where each element is held as a member | |
26 | variable. `vector` is the simplest of the Fusion sequence container (a | |
27 | vector with N elements is just a struct with N members), and in many | |
28 | cases the most efficient. | |
29 | ||
30 | [heading Header] | |
31 | ||
32 | #include <boost/fusion/container/vector.hpp> | |
33 | #include <boost/fusion/include/vector.hpp> | |
34 | #include <boost/fusion/container/vector/vector_fwd.hpp> | |
35 | #include <boost/fusion/include/vector_fwd.hpp> | |
36 | ||
37 | // numbered forms | |
38 | #include <boost/fusion/container/vector/vector10.hpp> | |
39 | #include <boost/fusion/include/vector10.hpp> | |
40 | #include <boost/fusion/container/vector/vector20.hpp> | |
41 | #include <boost/fusion/include/vector20.hpp> | |
42 | #include <boost/fusion/container/vector/vector30.hpp> | |
43 | #include <boost/fusion/include/vector30.hpp> | |
44 | #include <boost/fusion/container/vector/vector40.hpp> | |
45 | #include <boost/fusion/include/vector40.hpp> | |
46 | #include <boost/fusion/container/vector/vector50.hpp> | |
47 | #include <boost/fusion/include/vector50.hpp> | |
48 | ||
49 | [heading Synopsis] | |
50 | ||
51 | [*Numbered forms] | |
52 | ||
53 | struct vector0; | |
54 | ||
55 | template <typename T0> | |
56 | struct vector1; | |
57 | ||
58 | template <typename T0, typename T1> | |
59 | struct vector2; | |
60 | ||
61 | template <typename T0, typename T1, typename T2> | |
62 | struct vector3; | |
63 | ||
64 | ... | |
65 | ||
66 | template <typename T0, typename T1, typename T2..., typename TN> | |
67 | struct vectorN; | |
68 | ||
69 | [important Numbered forms will be deprecated in C++11 and it will be provided | |
70 | via aliasing templates. It means that your partial specialization | |
71 | might be compile error. You can detect whether it is aliasing | |
72 | templates or not, using `BOOST_FUSION_HAS_VARIADIC_VECTOR`.] | |
73 | ||
74 | [*Variadic form] | |
75 | ||
76 | template < | |
77 | typename T0 = __unspecified__ | |
78 | , typename T1 = __unspecified__ | |
79 | , typename T2 = __unspecified__ | |
80 | ... | |
81 | , typename TN = __unspecified__ | |
82 | > | |
83 | struct vector; | |
84 | ||
85 | The numbered form accepts the exact number of elements. Example: | |
86 | ||
87 | vector3<int, char, double> | |
88 | ||
89 | For C++11 compilers, the variadic function interface has no upper bound. | |
90 | ||
91 | For C++03 compilers, the The variadic form accepts `0` to | |
92 | `FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a | |
93 | user definable predefined maximum that defaults to `10`. Example: | |
94 | ||
95 | vector<int, char, double> | |
96 | ||
97 | You may define the preprocessor constant `FUSION_MAX_VECTOR_SIZE` before | |
98 | including any Fusion header to change the default. Example: | |
99 | ||
100 | #define FUSION_MAX_VECTOR_SIZE 20 | |
101 | ||
102 | [heading Template parameters] | |
103 | ||
104 | [table | |
105 | [[Parameter] [Description] [Default]] | |
106 | [[`T0`...`TN`] [Element types] [__unspecified__]] | |
107 | ] | |
108 | ||
109 | [heading Model of] | |
110 | ||
111 | * __random_access_sequence__ | |
112 | ||
113 | [variablelist Notation | |
114 | [[`v`] [Instance of `vector`]] | |
115 | [[`V`] [A `vector` type]] | |
116 | [[`e0`...`en`] [Heterogeneous values]] | |
117 | [[`s`] [A __forward_sequence__]] | |
118 | ] | |
119 | ||
120 | [heading Expression Semantics] | |
121 | ||
122 | Semantics of an expression is defined only where it differs from, or is not | |
123 | defined in __random_access_sequence__. | |
124 | ||
125 | [table | |
126 | [[Expression] [Semantics]] | |
127 | [[`V()`] [Creates a vector with default constructed elements.]] | |
128 | [[`V(e0, e1,... en)`] [Creates a vector with elements `e0`...`en`.]] | |
129 | [[`V(s)`] [Copy constructs a vector from a __forward_sequence__, `s`.]] | |
130 | [[`v = s`] [Assigns to a vector, `v`, from a __forward_sequence__, `s`.]] | |
131 | ] | |
132 | ||
133 | [heading Example] | |
134 | ||
135 | vector<int, float> v(12, 5.5f); | |
136 | std::cout << __at_c__<0>(v) << std::endl; | |
137 | std::cout << __at_c__<1>(v) << std::endl; | |
138 | ||
139 | [endsect] | |
140 | ||
141 | [section cons] | |
142 | ||
143 | [heading Description] | |
144 | ||
145 | `cons` is a simple __forward_sequence__. It is a lisp style recursive list | |
146 | structure where `car` is the /head/ and `cdr` is the /tail/: usually | |
147 | another cons structure or `nil`: the empty list. Fusion's __list__ is built | |
148 | on top of this more primitive data structure. It is more efficient than | |
149 | __vector__ when the target sequence is constructed piecemeal (a data at a | |
150 | time). The runtime cost of access to each element is peculiarly constant | |
151 | (see __recursive_inline__). | |
152 | ||
153 | [heading Header] | |
154 | ||
155 | #include <boost/fusion/container/list/cons.hpp> | |
156 | #include <boost/fusion/include/cons.hpp> | |
157 | ||
158 | [heading Synopsis] | |
159 | ||
160 | template <typename Car, typename Cdr = nil> | |
161 | struct cons; | |
162 | ||
163 | [heading Template parameters] | |
164 | ||
165 | [table | |
166 | [[Parameter] [Description] [Default]] | |
167 | [[`Car`] [Head type] [ ]] | |
168 | [[`Cdr`] [Tail type] [`nil`]] | |
169 | ] | |
170 | ||
171 | [heading Model of] | |
172 | ||
173 | * __forward_sequence__ | |
174 | ||
175 | [variablelist Notation | |
176 | [[`nil`] [An empty `cons`]] | |
177 | [[`C`] [A `cons` type]] | |
178 | [[`l`, `l2`] [Instances of `cons`]] | |
179 | [[`car`] [An arbitrary data]] | |
180 | [[`cdr`] [Another `cons` list]] | |
181 | [[`s`] [A __forward_sequence__]] | |
182 | [[`N`] [An __mpl_integral_constant__]] | |
183 | ] | |
184 | ||
185 | [heading Expression Semantics] | |
186 | ||
187 | Semantics of an expression is defined only where it differs from, or is not | |
188 | defined in __forward_sequence__. | |
189 | ||
190 | [table | |
191 | [[Expression] [Semantics]] | |
192 | [[`nil()`] [Creates an empty list.]] | |
193 | [[`C()`] [Creates a cons with default constructed elements.]] | |
194 | [[`C(car)`] [Creates a cons with `car` head and default constructed tail.]] | |
195 | [[`C(car, cdr)`] [Creates a cons with `car` head and `cdr` tail.]] | |
196 | [[`C(s)`] [Copy constructs a cons from a __forward_sequence__, `s`.]] | |
197 | [[`l = s`] [Assigns to a cons, `l`, from a __forward_sequence__, `s`.]] | |
198 | [[`__at__<N>(l)`] [The Nth element from the beginning of the sequence; see __at__.]] | |
199 | ] | |
200 | ||
201 | [note `__at__<N>(l)` is provided for convenience and compatibility | |
202 | with the original __tuple__ library, despite `cons` being a | |
203 | __forward_sequence__ only (`at` is supposed to be a | |
204 | __random_access_sequence__ requirement). The runtime complexity of __at__ is | |
205 | constant (see __recursive_inline__).] | |
206 | ||
207 | [heading Example] | |
208 | ||
209 | cons<int, cons<float> > l(12, cons<float>(5.5f)); | |
210 | std::cout << __at_c__<0>(l) << std::endl; | |
211 | std::cout << __at_c__<1>(l) << std::endl; | |
212 | ||
213 | [endsect] | |
214 | ||
215 | [section list] | |
216 | ||
217 | [heading Description] | |
218 | ||
219 | `list` is a __forward_sequence__ of heterogeneous typed data built on top of | |
220 | __cons__. It is more efficient than __vector__ when the target sequence is | |
221 | constructed piecemeal (a data at a time). The runtime cost of access to | |
222 | each element is peculiarly constant (see __recursive_inline__). | |
223 | ||
224 | [heading Header] | |
225 | ||
226 | #include <boost/fusion/container/list.hpp> | |
227 | #include <boost/fusion/include/list.hpp> | |
228 | #include <boost/fusion/container/list/list_fwd.hpp> | |
229 | #include <boost/fusion/include/list_fwd.hpp> | |
230 | ||
231 | [heading Synopsis] | |
232 | ||
233 | template < | |
234 | typename T0 = __unspecified__ | |
235 | , typename T1 = __unspecified__ | |
236 | , typename T2 = __unspecified__ | |
237 | ... | |
238 | , typename TN = __unspecified__ | |
239 | > | |
240 | struct list; | |
241 | ||
242 | For C++11 compilers, the variadic function interface has no upper bound. | |
243 | ||
244 | For C++03 compilers, the variadic class interface accepts `0` to | |
245 | `FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user | |
246 | definable predefined maximum that defaults to `10`. Example: | |
247 | ||
248 | list<int, char, double> | |
249 | ||
250 | You may define the preprocessor constant `FUSION_MAX_LIST_SIZE` before | |
251 | including any Fusion header to change the default. Example: | |
252 | ||
253 | #define FUSION_MAX_LIST_SIZE 20 | |
254 | ||
255 | [heading Template parameters] | |
256 | ||
257 | [table | |
258 | [[Parameter] [Description] [Default]] | |
259 | [[`T0`...`TN`] [Element types] [__unspecified__]] | |
260 | ] | |
261 | ||
262 | [heading Model of] | |
263 | ||
264 | * __forward_sequence__ | |
265 | ||
266 | [variablelist Notation | |
267 | [[`L`] [A `list` type]] | |
268 | [[`l`] [An instance of `list`]] | |
269 | [[`e0`...`en`] [Heterogeneous values]] | |
270 | [[`s`] [A __forward_sequence__]] | |
271 | [[`N`] [An __mpl_integral_constant__]] | |
272 | ] | |
273 | ||
274 | [heading Expression Semantics] | |
275 | ||
276 | Semantics of an expression is defined only where it differs from, or is not | |
277 | defined in __forward_sequence__. | |
278 | ||
279 | [table | |
280 | [[Expression] [Semantics]] | |
281 | [[`L()`] [Creates a list with default constructed elements.]] | |
282 | [[`L(e0, e1,... en)`] [Creates a list with elements `e0`...`en`.]] | |
283 | [[`L(s)`] [Copy constructs a list from a __forward_sequence__, `s`.]] | |
284 | [[`l = s`] [Assigns to a list, `l`, from a __forward_sequence__, `s`.]] | |
285 | [[`__at__<N>(l)`] [The Nth element from the beginning of the sequence; see __at__.]] | |
286 | ] | |
287 | ||
288 | [note `__at__<n>(l)` is provided for convenience and compatibility | |
289 | with the original __tuple__ library, despite `list` being a | |
290 | __forward_sequence__ only (__at__ is supposed to be a | |
291 | __random_access_sequence__ requirement). The runtime complexity of __at__ is | |
292 | constant (see __recursive_inline__).] | |
293 | ||
294 | [heading Example] | |
295 | ||
296 | list<int, float> l(12, 5.5f); | |
297 | std::cout << __at_c__<0>(l) << std::endl; | |
298 | std::cout << __at_c__<1>(l) << std::endl; | |
299 | ||
300 | [endsect] | |
301 | ||
302 | [section deque] | |
303 | ||
304 | [heading Description] | |
305 | ||
306 | `deque` is a simple __bidirectional_sequence__ that supports | |
307 | constant-time insertion and removal of elements at both ends. Like the | |
308 | __list__ and __cons__, `deque` is more efficient than __vector__ | |
309 | (especially at compile time) when the target sequence is constructed | |
310 | piecemeal (a data at a time, e.g. when constructing expression | |
311 | templates). Like the __list__ and __cons__, runtime cost of access to | |
312 | each element is peculiarly constant (see __recursive_inline__). | |
313 | ||
314 | Element insertion and removal are done by special `deque` helper classes | |
315 | __front_extended_deque__ and __back_extended_deque__. | |
316 | ||
317 | [heading Header] | |
318 | ||
319 | #include <boost/fusion/container/deque.hpp> | |
320 | #include <boost/fusion/include/deque.hpp> | |
321 | #include <boost/fusion/container/deque/deque_fwd.hpp> | |
322 | #include <boost/fusion/include/deque_fwd.hpp> | |
323 | ||
324 | [heading Synopsis] | |
325 | ||
326 | template <typename ...Elements> | |
327 | struct deque; | |
328 | ||
329 | For C++11 compilers, the variadic class interface has no upper bound. | |
330 | ||
331 | For C++03 compilers, the variadic class interface accepts `0` to | |
332 | `FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a | |
333 | user definable predefined maximum that defaults to `10`. Example: | |
334 | ||
335 | deque<int, char, double> | |
336 | ||
337 | You may define the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before | |
338 | including any Fusion header to change the default. Example: | |
339 | ||
340 | #define FUSION_MAX_DEQUE_SIZE 20 | |
341 | ||
342 | [heading Template parameters] | |
343 | ||
344 | [table | |
345 | [[Parameter] [Description] [Default]] | |
346 | [[`Elements`] [Element types] [ ]] | |
347 | ] | |
348 | ||
349 | [heading Model of] | |
350 | ||
351 | * __bidirectional_sequence__ | |
352 | ||
353 | [variablelist Notation | |
354 | [[`D`] [A `deque` type]] | |
355 | [[`d`, `d2`] [Instances of `deque`]] | |
356 | [[`e0`...`en`] [Heterogeneous values]] | |
357 | [[`s`] [A __forward_sequence__]] | |
358 | [[`N`] [An __mpl_integral_constant__]] | |
359 | ] | |
360 | ||
361 | [heading Expression Semantics] | |
362 | ||
363 | Semantics of an expression is defined only where it differs from, or is not | |
364 | defined in __bidirectional_sequence__. | |
365 | ||
366 | [table | |
367 | [[Expression] [Semantics]] | |
368 | [[`D()`] [Creates a deque with default constructed elements.]] | |
369 | [[`D(e0, e1,... en)`] [Creates a deque with elements `e0`...`en`.]] | |
370 | [[`D(s)`] [Copy constructs a deque from a __forward_sequence__, `s`.]] | |
371 | [[`d = s`] [Assigns to a deque, `d`, from a __forward_sequence__, `s`.]] | |
372 | [[`__at__<N>(d)`] [The Nth element from the beginning of the sequence; see __at__.]] | |
373 | ] | |
374 | ||
375 | [note `__at__<N>(d)` is provided for convenience, despite | |
376 | `deque` being a __bidirectional_sequence__ only (`at` is supposed to be | |
377 | a __random_access_sequence__ requirement). The runtime complexity of | |
378 | __at__ is constant (see __recursive_inline__). `deque` element access | |
379 | utilizes operator overloading with argument dependent lookup (ADL) of | |
380 | the proper element getter function given a static constant index | |
381 | parameter. Interestingly, with modern C++ compilers, this lookup is very | |
382 | fast and rivals recursive template instantiations in compile time-speed, | |
383 | so much so that `deque` relies on ADL for all element access (indexing) | |
384 | as well as iteration.] | |
385 | ||
386 | [heading Example] | |
387 | ||
388 | deque<int, float> d(12, 5.5f); | |
389 | std::cout << __at_c__<0>(d) << std::endl; | |
390 | std::cout << __at_c__<1>(d) << std::endl; | |
391 | ||
392 | [endsect] | |
393 | ||
394 | [section front_extended_deque] | |
395 | ||
396 | [heading Description] | |
397 | ||
398 | `front_extended_deque` allows a __deque__ to be front extended. It shares | |
399 | the same properties as the __deque__. | |
400 | ||
401 | [heading Header] | |
402 | ||
403 | See __deque__ | |
404 | ||
405 | [heading Synopsis] | |
406 | ||
407 | template <typename Deque, typename T> | |
408 | struct front_extended_deque; | |
409 | ||
410 | [heading Template parameters] | |
411 | ||
412 | [table | |
413 | [[Parameter] [Description] [Default]] | |
414 | [[`Deque`] [Deque type] [ ]] | |
415 | [[`T`] [Element type] [ ]] | |
416 | ] | |
417 | ||
418 | [note `Deque` can be a __deque__, a __front_extended_deque__ or a | |
419 | __back_extended_deque__] | |
420 | ||
421 | [heading Model of] | |
422 | ||
423 | * __bidirectional_sequence__ | |
424 | ||
425 | [variablelist Notation | |
426 | [[`D`] [A `front_extended_deque` type]] | |
427 | [[`e`] [Heterogeneous value]] | |
428 | [[`N`] [An __mpl_integral_constant__]] | |
429 | ] | |
430 | ||
431 | [heading Expression Semantics] | |
432 | ||
433 | Semantics of an expression is defined only where it differs from, or is | |
434 | not defined in __bidirectional_sequence__. | |
435 | ||
436 | [table | |
437 | [[Expression] [Semantics]] | |
438 | [[`D(d, e)`] [Extend `d` prepending `e` to its front.]] | |
439 | [[`__at__<N>(d)`] [The Nth element from the beginning of the sequence; see __at__.]] | |
440 | ] | |
441 | ||
442 | [note See __deque__ for further details.] | |
443 | ||
444 | [heading Example] | |
445 | ||
446 | typedef deque<int, float> initial_deque; | |
447 | initial_deque d(12, 5.5f); | |
448 | front_extended_deque<initial_deque, int> d2(d, 999); | |
449 | std::cout << __at_c__<0>(d2) << std::endl; | |
450 | std::cout << __at_c__<1>(d2) << std::endl; | |
451 | std::cout << __at_c__<2>(d2) << std::endl; | |
452 | ||
453 | [endsect] | |
454 | ||
455 | [section back_extended_deque] | |
456 | ||
457 | [heading Description] | |
458 | ||
459 | `back_extended_deque` allows a __deque__ to be back extended. It shares | |
460 | the same properties as the __deque__. | |
461 | ||
462 | [heading Header] | |
463 | ||
464 | See __deque__ | |
465 | ||
466 | [heading Synopsis] | |
467 | ||
468 | template <typename Deque, typename T> | |
469 | struct back_extended_deque; | |
470 | ||
471 | [heading Template parameters] | |
472 | ||
473 | [table | |
474 | [[Parameter] [Description] [Default]] | |
475 | [[`Deque`] [Deque type] [ ]] | |
476 | [[`T`] [Element type] [ ]] | |
477 | ] | |
478 | ||
479 | [note `Deque` can be a __deque__, a __back_extended_deque__ or a | |
480 | __back_extended_deque__] | |
481 | ||
482 | [heading Model of] | |
483 | ||
484 | * __bidirectional_sequence__ | |
485 | ||
486 | [variablelist Notation | |
487 | [[`D`] [A `back_extended_deque` type]] | |
488 | [[`e`] [Heterogeneous value]] | |
489 | [[`N`] [An __mpl_integral_constant__]] | |
490 | ] | |
491 | ||
492 | [heading Expression Semantics] | |
493 | ||
494 | Semantics of an expression is defined only where it differs from, or is | |
495 | not defined in __bidirectional_sequence__. | |
496 | ||
497 | [table | |
498 | [[Expression] [Semantics]] | |
499 | [[`D(d, e)`] [Extend `d` prepending `e` to its back.]] | |
500 | [[`__at__<N>(d)`] [The Nth element from the beginning of the sequence; see __at__.]] | |
501 | ] | |
502 | ||
503 | [note See __deque__ for further details.] | |
504 | ||
505 | [heading Example] | |
506 | ||
507 | typedef deque<int, float> initial_deque; | |
508 | initial_deque d(12, 5.5f); | |
509 | back_extended_deque<initial_deque, int> d2(d, 999); | |
510 | std::cout << __at_c__<0>(d2) << std::endl; | |
511 | std::cout << __at_c__<1>(d2) << std::endl; | |
512 | std::cout << __at_c__<2>(d2) << std::endl; | |
513 | ||
514 | [endsect] | |
515 | ||
516 | [section set] | |
517 | ||
518 | [heading Description] | |
519 | ||
520 | set is an __associative_sequence__ of heterogeneous typed data elements. | |
521 | Type identity is used to impose an equivalence relation on keys. The | |
522 | element's type is its key. A set may contain at most one element for each | |
523 | key. Membership testing and element key lookup has constant runtime | |
524 | complexity (see __overloaded_functions__). | |
525 | ||
526 | [heading Header] | |
527 | ||
528 | #include <boost/fusion/container/set.hpp> | |
529 | #include <boost/fusion/include/set.hpp> | |
530 | #include <boost/fusion/container/set/set_fwd.hpp> | |
531 | #include <boost/fusion/include/set_fwd.hpp> | |
532 | ||
533 | [heading Synopsis] | |
534 | ||
535 | template < | |
536 | typename T0 = __unspecified__ | |
537 | , typename T1 = __unspecified__ | |
538 | , typename T2 = __unspecified__ | |
539 | ... | |
540 | , typename TN = __unspecified__ | |
541 | > | |
542 | struct set; | |
543 | ||
544 | For C++11 compilers, the variadic function interface has no upper bound. | |
545 | ||
546 | For C++03 compilers, the variadic class interface accepts `0` to | |
547 | `FUSION_MAX_SET_SIZE` elements, where `FUSION_MAX_SET_SIZE` is a user | |
548 | definable predefined maximum that defaults to `10`. Example: | |
549 | ||
550 | set<int, char, double> | |
551 | ||
552 | You may define the preprocessor constant `FUSION_MAX_SET_SIZE` before | |
553 | including any Fusion header to change the default. Example: | |
554 | ||
555 | #define FUSION_MAX_SET_SIZE 20 | |
556 | ||
557 | [heading Template parameters] | |
558 | ||
559 | [table | |
560 | [[Parameter] [Description] [Default]] | |
561 | [[`T0`...`TN`] [Element types] [__unspecified__]] | |
562 | ] | |
563 | ||
564 | [heading Model of] | |
565 | ||
566 | * __associative_sequence__ | |
567 | * __forward_sequence__ | |
568 | ||
569 | [variablelist Notation | |
570 | [[`S`] [A `set` type]] | |
571 | [[`s`] [An instance of `set`]] | |
572 | [[`e0`...`en`] [Heterogeneous values]] | |
573 | [[`fs`] [A __forward_sequence__]] | |
574 | ] | |
575 | ||
576 | [heading Expression Semantics] | |
577 | ||
578 | Semantics of an expression is defined only where it differs from, or is not | |
579 | defined in __random_access_sequence__ and __associative_sequence__. | |
580 | ||
581 | [table | |
582 | [[Expression] [Semantics]] | |
583 | [[`S()`] [Creates a set with default constructed elements.]] | |
584 | [[`S(e0, e1,... en)`] [Creates a set with elements `e0`...`en`.]] | |
585 | [[`S(fs)`] [Copy constructs a set from a __forward_sequence__ `fs`.]] | |
586 | [[`s = fs`] [Assigns to a set, `s`, from a __forward_sequence__ `fs`.]] | |
587 | ] | |
588 | ||
589 | [heading Example] | |
590 | ||
591 | typedef set<int, float> S; | |
592 | S s(12, 5.5f); | |
593 | std::cout << __at_key__<int>(s) << std::endl; | |
594 | std::cout << __at_key__<float>(s) << std::endl; | |
595 | std::cout << __result_of_has_key__<S, double>::value << std::endl; | |
596 | ||
597 | [endsect] | |
598 | ||
599 | [section map] | |
600 | ||
601 | [heading Description] | |
602 | ||
603 | map is an __associative_sequence__ of heterogeneous typed data elements. | |
604 | Each element is a key/data pair (see __fusion_pair__) where the key has no | |
605 | data (type only). Type identity is used to impose an equivalence relation | |
606 | on keys. A map may contain at most one element for each key. Membership | |
607 | testing and element key lookup has constant runtime complexity (see | |
608 | __overloaded_functions__). | |
609 | ||
610 | [heading Header] | |
611 | ||
612 | #include <boost/fusion/container/map.hpp> | |
613 | #include <boost/fusion/include/map.hpp> | |
614 | #include <boost/fusion/container/map/map_fwd.hpp> | |
615 | #include <boost/fusion/include/map_fwd.hpp> | |
616 | ||
617 | [heading Synopsis] | |
618 | ||
619 | template < | |
620 | typename T0 = __unspecified__ | |
621 | , typename T1 = __unspecified__ | |
622 | , typename T2 = __unspecified__ | |
623 | ... | |
624 | , typename TN = __unspecified__ | |
625 | > | |
626 | struct map; | |
627 | ||
628 | For C++11 compilers, the variadic function interface has no upper bound. | |
629 | ||
630 | For C++03 compilers, the variadic class interface accepts `0` to | |
631 | `FUSION_MAX_MAP_SIZE` elements, where `FUSION_MAX_MAP_SIZE` is a user | |
632 | definable predefined maximum that defaults to `10`. Example: | |
633 | ||
634 | map<__pair__<int, char>, __pair__<char, char>, __pair__<double, char> > | |
635 | ||
636 | You may define the preprocessor constant `FUSION_MAX_MAP_SIZE` before | |
637 | including any Fusion header to change the default. Example: | |
638 | ||
639 | #define FUSION_MAX_MAP_SIZE 20 | |
640 | ||
641 | [heading Template parameters] | |
642 | ||
643 | [table | |
644 | [[Parameter] [Description] [Default]] | |
645 | [[`T0`...`TN`] [Element types] [__unspecified__]] | |
646 | ] | |
647 | ||
648 | [heading Model of] | |
649 | ||
650 | * __associative_sequence__ | |
651 | * __random_access_sequence__ | |
652 | ||
653 | [variablelist Notation | |
654 | [[`M`] [A `map` type]] | |
655 | [[`m`] [An instance of `map`]] | |
656 | [[`e0`...`en`] [Heterogeneous key/value pairs (see __fusion_pair__)]] | |
657 | [[`s`] [A __forward_sequence__]] | |
658 | ] | |
659 | ||
660 | [heading Expression Semantics] | |
661 | ||
662 | Semantics of an expression is defined only where it differs from, or is not | |
663 | defined in __forward_sequence__ and __associative_sequence__. | |
664 | ||
665 | [table | |
666 | [[Expression] [Semantics]] | |
667 | [[`M()`] [Creates a map with default constructed elements.]] | |
668 | [[`M(e0, e1,... en)`] [Creates a map with element pairs `e0`...`en`.]] | |
669 | [[`M(s)`] [Copy constructs a map from a __forward_sequence__ `s`.]] | |
670 | [[`m = s`] [Assigns to a map, `m`, from a __forward_sequence__ `s`.]] | |
671 | ] | |
672 | ||
673 | [heading Example] | |
674 | ||
675 | typedef map< | |
676 | __pair__<int, char> | |
677 | , __pair__<double, std::string> > | |
678 | map_type; | |
679 | ||
680 | map_type m( | |
681 | __fusion_make_pair__<int>('X') | |
682 | , __fusion_make_pair__<double>("Men")); | |
683 | ||
684 | std::cout << __at_key__<int>(m) << std::endl; | |
685 | std::cout << __at_key__<double>(m) << std::endl; | |
686 | ||
687 | [endsect] | |
688 | ||
689 | [section Generation] | |
690 | ||
691 | These are the functions that you can use to generate various forms of | |
692 | __containers__ from elemental values. | |
693 | ||
694 | [heading Header] | |
695 | ||
696 | #include <boost/fusion/container/generation.hpp> | |
697 | #include <boost/fusion/include/generation.hpp> | |
698 | ||
699 | [section Functions] | |
700 | ||
701 | [section make_list] | |
702 | ||
703 | [heading Description] | |
704 | ||
705 | Create a __list__ from one or more values. | |
706 | ||
707 | [heading Synopsis] | |
708 | ||
709 | template <typename T0, typename T1,... typename TN> | |
710 | typename __result_of_make_list__<T0, T1,... TN>::type | |
711 | make_list(T0 const& x0, T1 const& x1... TN const& xN); | |
712 | ||
713 | For C++11 compilers, the variadic function interface has no upper bound. | |
714 | ||
715 | For C++03 compilers, the variadic function accepts `0` to | |
716 | `FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user | |
717 | definable predefined maximum that defaults to `10`. You may define the | |
718 | preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion | |
719 | header to change the default. Example: | |
720 | ||
721 | #define FUSION_MAX_LIST_SIZE 20 | |
722 | ||
723 | [heading Parameters] | |
724 | ||
725 | [table | |
726 | [[Parameter] [Requirement] [Description]] | |
727 | [[`x0, x1,... xN`] [Instances of `T0, T1,... TN`] [The arguments to `make_list`]] | |
728 | ] | |
729 | ||
730 | [heading Expression Semantics] | |
731 | ||
732 | make_list(x0, x1,... xN); | |
733 | ||
734 | [*Return type]: __result_of_make_list__`<T0, T1,... TN>::type` | |
735 | ||
736 | [*Semantics]: Create a __list__ from `x0, x1,... xN`. | |
737 | ||
738 | [heading Header] | |
739 | ||
740 | #include <boost/fusion/container/generation/make_list.hpp> | |
741 | #include <boost/fusion/include/make_list.hpp> | |
742 | ||
743 | [heading Example] | |
744 | ||
745 | make_list(123, "hello", 12.5) | |
746 | ||
747 | [heading See also] | |
748 | ||
749 | __note_ref_wrappers__ | |
750 | ||
751 | [endsect] | |
752 | ||
753 | [section make_cons] | |
754 | ||
755 | [heading Description] | |
756 | ||
757 | Create a __cons__ from `car` (/head/) and optional `cdr` (/tail/). | |
758 | ||
759 | [heading Synopsis] | |
760 | ||
761 | template <typename Car> | |
762 | typename __result_of_make_cons__<Car>::type | |
763 | make_cons(Car const& car); | |
764 | ||
765 | template <typename Car, typename Cdr> | |
766 | typename __result_of_make_cons__<Car, Cdr>::type | |
767 | make_cons(Car const& car, Cdr const& cdr); | |
768 | ||
769 | [heading Parameters] | |
770 | ||
771 | [table | |
772 | [[Parameter] [Requirement] [Description]] | |
773 | [[`car`] [Instance of `Car`] [The list's head]] | |
774 | [[`cdr`] [Instance of `Cdr`] [The list's tail (optional)]] | |
775 | ] | |
776 | ||
777 | [heading Expression Semantics] | |
778 | ||
779 | make_cons(car, cdr); | |
780 | ||
781 | [*Return type]: __result_of_make_cons__`<Car, Cdr>::type` or | |
782 | __result_of_make_cons__`<Car>::type` | |
783 | ||
784 | [*Semantics]: Create a __cons__ from `car` (/head/) and optional `cdr` (/tail/). | |
785 | ||
786 | [heading Header] | |
787 | ||
788 | #include <boost/fusion/container/generation/make_cons.hpp> | |
789 | #include <boost/fusion/include/make_cons.hpp> | |
790 | ||
791 | [heading Example] | |
792 | ||
793 | make_cons('x', make_cons(123)) | |
794 | ||
795 | [heading See also] | |
796 | ||
797 | __note_ref_wrappers__ | |
798 | ||
799 | [endsect] | |
800 | ||
801 | [section make_vector] | |
802 | ||
803 | [heading Description] | |
804 | ||
805 | Create a __vector__ from one or more values. | |
806 | ||
807 | [heading Synopsis] | |
808 | ||
809 | template <typename T0, typename T1,... typename TN> | |
810 | typename __result_of_make_vector__<T0, T1,... TN>::type | |
811 | make_vector(T0 const& x0, T1 const& x1... TN const& xN); | |
812 | ||
813 | For C++11 compilers, the variadic function interface has no upper bound. | |
814 | ||
815 | For C++03 compilers, the variadic function accepts `0` to | |
816 | `FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a | |
817 | user definable predefined maximum that defaults to `10`. You may define | |
818 | the preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any | |
819 | Fusion header to change the default. Example: | |
820 | ||
821 | #define FUSION_MAX_VECTOR_SIZE 20 | |
822 | ||
823 | [heading Parameters] | |
824 | ||
825 | [table | |
826 | [[Parameter] [Requirement] [Description]] | |
827 | [[`x0, x1,... xN`] [Instances of `T0, T1,... TN`] [The arguments to `make_vector`]] | |
828 | ] | |
829 | ||
830 | [heading Expression Semantics] | |
831 | ||
832 | make_vector(x0, x1,... xN); | |
833 | ||
834 | [*Return type]: __result_of_make_vector__`<T0, T1,... TN>::type` | |
835 | ||
836 | [*Semantics]: Create a __vector__ from `x0, x1,... xN`. | |
837 | ||
838 | [heading Header] | |
839 | ||
840 | #include <boost/fusion/container/generation/make_vector.hpp> | |
841 | #include <boost/fusion/include/make_vector.hpp> | |
842 | ||
843 | [heading Example] | |
844 | ||
845 | make_vector(123, "hello", 12.5) | |
846 | ||
847 | [heading See also] | |
848 | ||
849 | __note_ref_wrappers__ | |
850 | ||
851 | [endsect] | |
852 | ||
853 | [section make_deque] | |
854 | ||
855 | [heading Description] | |
856 | ||
857 | Create a __deque__ from one or more values. | |
858 | ||
859 | [heading Synopsis] | |
860 | ||
861 | template <typename ...Elements> | |
862 | typename __result_of_make_deque__<Elements...>::type | |
863 | make_deque(Elements const&... elements); | |
864 | ||
865 | For C++11 compilers, the variadic function interface has no upper bound. | |
866 | ||
867 | For C++03 compilers, the variadic function accepts `0` to | |
868 | `FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a | |
869 | user definable predefined maximum that defaults to `10`. You may define | |
870 | the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any | |
871 | Fusion header to change the default. Example: | |
872 | ||
873 | #define FUSION_MAX_DEQUE_SIZE 20 | |
874 | ||
875 | [heading Parameters] | |
876 | ||
877 | [table | |
878 | [[Parameter] [Description] [Description]] | |
879 | [[`elements`] [Instances of `Elements`] [The arguments to `make_deque`]] | |
880 | ] | |
881 | ||
882 | [heading Expression Semantics] | |
883 | ||
884 | make_deque(elements...); | |
885 | ||
886 | [*Return type]: __result_of_make_deque__`<Elements...>::type` | |
887 | ||
888 | [*Semantics]: Create a __deque__ from `elements...`. | |
889 | ||
890 | [heading Header] | |
891 | ||
892 | #include <boost/fusion/container/generation/make_deque.hpp> | |
893 | #include <boost/fusion/include/make_deque.hpp> | |
894 | ||
895 | [heading Example] | |
896 | ||
897 | make_deque(123, "hello", 12.5) | |
898 | ||
899 | [heading See also] | |
900 | ||
901 | __note_ref_wrappers__ | |
902 | ||
903 | [endsect] | |
904 | ||
905 | [section make_set] | |
906 | ||
907 | [heading Description] | |
908 | ||
909 | Create a __set__ from one or more values. | |
910 | ||
911 | [heading Synopsis] | |
912 | ||
913 | template <typename T0, typename T1,... typename TN> | |
914 | typename __result_of_make_set__<T0, T1,... TN>::type | |
915 | make_set(T0 const& x0, T1 const& x1... TN const& xN); | |
916 | ||
917 | For C++11 compilers, the variadic function interface has no upper bound. | |
918 | ||
919 | For C++03 compilers, the variadic function accepts `0` to | |
920 | `FUSION_MAX_SET_SIZE` elements, where `FUSION_MAX_SET_SIZE` is a user | |
921 | definable predefined maximum that defaults to `10`. You may define the | |
922 | preprocessor constant `FUSION_MAX_SET_SIZE` before including any Fusion | |
923 | header to change the default. Example: | |
924 | ||
925 | #define FUSION_MAX_SET_SIZE 20 | |
926 | ||
927 | [heading Parameters] | |
928 | ||
929 | [table | |
930 | [[Parameter] [Requirement] [Description]] | |
931 | [[`x0, x1,... xN`] [Instances of `T0, T1,... TN`] [The arguments to `make_set`]] | |
932 | ] | |
933 | ||
934 | [heading Expression Semantics] | |
935 | ||
936 | make_set(x0, x1,... xN); | |
937 | ||
938 | [*Return type]: __result_of_make_set__`<T0, T1,... TN>::type` | |
939 | ||
940 | [*Semantics]: Create a __set__ from `x0, x1,... xN`. | |
941 | ||
942 | [*Precondition]: There may be no duplicate key types. | |
943 | ||
944 | [heading Header] | |
945 | ||
946 | #include <boost/fusion/container/generation/make_set.hpp> | |
947 | #include <boost/fusion/include/make_set.hpp> | |
948 | ||
949 | [heading Example] | |
950 | ||
951 | make_set(123, "hello", 12.5) | |
952 | ||
953 | [heading See also] | |
954 | ||
955 | __note_ref_wrappers__ | |
956 | ||
957 | [endsect] | |
958 | ||
959 | [section make_map] | |
960 | ||
961 | [heading Description] | |
962 | ||
963 | Create a __map__ from one or more key/data pairs. | |
964 | ||
965 | [heading Synopsis] | |
966 | ||
967 | template < | |
968 | typename K0, typename K1,... typename KN | |
969 | , typename T0, typename T1,... typename TN> | |
970 | typename __result_of_make_map__<K0, K0,... KN, T0, T1,... TN>::type | |
971 | make_map(T0 const& x0, T1 const& x1... TN const& xN); | |
972 | ||
973 | For C++11 compilers, the variadic function interface has no upper bound. | |
974 | ||
975 | For C++03 compilers, the variadic function accepts `0` to `FUSION_MAX_MAP_SIZE` elements, | |
976 | where `FUSION_MAX_MAP_SIZE` is a user definable predefined maximum that | |
977 | defaults to `10`. You may define the preprocessor constant | |
978 | `FUSION_MAX_MAP_SIZE` before including any Fusion header to change the | |
979 | default. Example: | |
980 | ||
981 | #define FUSION_MAX_MAP_SIZE 20 | |
982 | ||
983 | [heading Parameters] | |
984 | ||
985 | [table | |
986 | [[Parameter] [Requirement] [Description]] | |
987 | [[`K0, K1,... KN`] [The key types] [Keys associated with `x0, x1,... xN`]] | |
988 | [[`x0, x1,... xN`] [Instances of `T0, T1,... TN`] [The arguments to `make_map`]] | |
989 | ] | |
990 | ||
991 | [heading Expression Semantics] | |
992 | ||
993 | make_map<K0, K1,... KN>(x0, x1,... xN); | |
994 | ||
995 | [*Return type]: __result_of_make_map__`<K0, K0,... KN, T0, T1,... TN>::type` | |
996 | ||
997 | [*Semantics]: Create a __map__ from `K0, K1,... KN` keys and | |
998 | `x0, x1,... xN` data. | |
999 | ||
1000 | [*Precondition]: There may be no duplicate key types. | |
1001 | ||
1002 | [heading Header] | |
1003 | ||
1004 | #include <boost/fusion/container/generation/make_map.hpp> | |
1005 | #include <boost/fusion/include/make_map.hpp> | |
1006 | ||
1007 | [heading Example] | |
1008 | ||
1009 | make_map<int, double>('X', "Men") | |
1010 | ||
1011 | [heading See also] | |
1012 | ||
1013 | __note_ref_wrappers__, __fusion_pair__ | |
1014 | ||
1015 | [endsect] | |
1016 | ||
1017 | [section Tiers] | |
1018 | ||
1019 | Tiers are sequences, where all elements are non-const reference types. They | |
1020 | are constructed with a call to a couple of /tie/ function templates. The | |
1021 | succeeding sections document the various /tier/ flavors. | |
1022 | ||
1023 | * __list_tie__ | |
1024 | * __vector_tie__ | |
1025 | * __map_tie__ | |
1026 | * __deque_tie__ | |
1027 | ||
1028 | Example: | |
1029 | ||
1030 | int i; char c; double d; | |
1031 | ... | |
1032 | __vector_tie__(i, c, d); | |
1033 | ||
1034 | The __vector_tie__ function creates a __vector__ of type | |
1035 | `__vector__<int&, char&, double&>`. The same result could be achieved with the call | |
1036 | __make_vector__(__boost_ref_call__(i), __boost_ref_call__(c), __boost_ref_call__(d)) | |
1037 | [footnote see __boost_ref__ for details about `ref`]. | |
1038 | ||
1039 | A /tie/ can be used to 'unpack' another tuple into variables. E.g.: | |
1040 | ||
1041 | int i; char c; double d; | |
1042 | __vector_tie__(i, c, d) = __make_vector__(1,'a', 5.5); | |
1043 | std::cout << i << " " << c << " " << d; | |
1044 | ||
1045 | This code prints 1 a 5.5 to the standard output stream. A sequence | |
1046 | unpacking operation like this is found for example in ML and Python. It is | |
1047 | convenient when calling functions which return sequences. | |
1048 | ||
1049 | [heading Ignore] | |
1050 | ||
1051 | There is also an object called /ignore/ which allows you to ignore an | |
1052 | element assigned by a sequence. The idea is that a function may return a | |
1053 | sequence, only part of which you are interested in. For example: | |
1054 | ||
1055 | char c; | |
1056 | __vector_tie__(ignore, c) = __make_vector__(1, 'a'); | |
1057 | ||
1058 | [endsect] | |
1059 | ||
1060 | [section list_tie] | |
1061 | ||
1062 | [heading Description] | |
1063 | ||
1064 | Constructs a tie using a __list__ sequence. | |
1065 | ||
1066 | [heading Synopsis] | |
1067 | ||
1068 | template <typename T0, typename T1,... typename TN> | |
1069 | __list__<T0&, T1&,... TN&> | |
1070 | list_tie(T0& x0, T1& x1... TN& xN); | |
1071 | ||
1072 | For C++11 compilers, the variadic function interface has no upper bound. | |
1073 | ||
1074 | For C++03 compilers, the variadic function accepts `0` to | |
1075 | `FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user | |
1076 | definable predefined maximum that defaults to `10`. You may define the | |
1077 | preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion | |
1078 | header to change the default. Example: | |
1079 | ||
1080 | #define FUSION_MAX_LIST_SIZE 20 | |
1081 | ||
1082 | [heading Parameters] | |
1083 | ||
1084 | [table | |
1085 | [[Parameter] [Requirement] [Description]] | |
1086 | [[`x0, x1,... xN`] [Instances of `T0, T1,... TN`] [The arguments to `list_tie`]] | |
1087 | ] | |
1088 | ||
1089 | [heading Expression Semantics] | |
1090 | ||
1091 | list_tie(x0, x1,... xN); | |
1092 | ||
1093 | [*Return type]: __list__<T0&, T1&,... TN&> | |
1094 | ||
1095 | [*Semantics]: Create a __list__ of references from `x0, x1,... xN`. | |
1096 | ||
1097 | [heading Header] | |
1098 | ||
1099 | #include <boost/fusion/container/generation/list_tie.hpp> | |
1100 | #include <boost/fusion/include/list_tie.hpp> | |
1101 | ||
1102 | [heading Example] | |
1103 | ||
1104 | int i = 123; | |
1105 | double d = 123.456; | |
1106 | list_tie(i, d) | |
1107 | ||
1108 | [endsect] | |
1109 | ||
1110 | [section vector_tie] | |
1111 | ||
1112 | [heading Description] | |
1113 | ||
1114 | Constructs a tie using a __vector__ sequence. | |
1115 | ||
1116 | [heading Synopsis] | |
1117 | ||
1118 | template <typename T0, typename T1,... typename TN> | |
1119 | __vector__<T0&, T1&,... TN&> | |
1120 | vector_tie(T0& x0, T1& x1... TN& xN); | |
1121 | ||
1122 | For C++11 compilers, the variadic function interface has no upper bound. | |
1123 | ||
1124 | For C++03 compilers, the variadic function accepts `0` to | |
1125 | `FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a | |
1126 | user definable predefined maximum that defaults to `10`. You may define | |
1127 | the preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any | |
1128 | Fusion header to change the default. Example: | |
1129 | ||
1130 | #define FUSION_MAX_VECTOR_SIZE 20 | |
1131 | ||
1132 | [heading Parameters] | |
1133 | ||
1134 | [table | |
1135 | [[Parameter] [Requirement] [Description]] | |
1136 | [[`x0, x1,... xN`] [Instances of `T0, T1,... TN`] [The arguments to `vector_tie`]] | |
1137 | ] | |
1138 | ||
1139 | [heading Expression Semantics] | |
1140 | ||
1141 | vector_tie(x0, x1,... xN); | |
1142 | ||
1143 | [*Return type]: __vector__<T0&, T1&,... TN&> | |
1144 | ||
1145 | [*Semantics]: Create a __vector__ of references from `x0, x1,... xN`. | |
1146 | ||
1147 | [heading Header] | |
1148 | ||
1149 | #include <boost/fusion/container/generation/vector_tie.hpp> | |
1150 | #include <boost/fusion/include/vector_tie.hpp> | |
1151 | ||
1152 | [heading Example] | |
1153 | ||
1154 | int i = 123; | |
1155 | double d = 123.456; | |
1156 | vector_tie(i, d) | |
1157 | ||
1158 | [endsect] | |
1159 | ||
1160 | [section map_tie] | |
1161 | ||
1162 | [heading Description] | |
1163 | ||
1164 | Constructs a tie using a __map__ sequence. | |
1165 | ||
1166 | [heading Synopsis] | |
1167 | ||
1168 | template <typename K0, typename K1,... typename KN, typename D0, typename D1,... typename DN> | |
1169 | __map__<__pair__<K0, D0&>, __pair__<K1, D1&>,... __pair__<KN, DN&> > | |
1170 | map_tie(D0& d0, D1& d1... DN& dN); | |
1171 | ||
1172 | For C++11 compilers, the variadic function interface has no upper bound. | |
1173 | ||
1174 | For C++03 compilers, the variadic function accepts `0` to | |
1175 | `FUSION_MAX_MAP_SIZE` elements, where `FUSION_MAX_MAP_SIZE` is a user | |
1176 | definable predefined maximum that defaults to `10`, and a corresponding | |
1177 | number of key types. You may define the preprocessor constant | |
1178 | `FUSION_MAX_MAP_SIZE` before including any Fusion header to change the | |
1179 | default. Example: | |
1180 | ||
1181 | #define FUSION_MAX_MAP_SIZE 20 | |
1182 | ||
1183 | [heading Parameters] | |
1184 | ||
1185 | [table | |
1186 | [[Parameter] [Requirement] [Description]] | |
1187 | [[`K0, K1,... KN`] [Any type][The key types associated with each of the `x1,x2,...,xN` values]] | |
1188 | [[`x0, x1,... xN`] [Instances of `T0, T1,... TN`] [The arguments to `map_tie`]] | |
1189 | ] | |
1190 | ||
1191 | [heading Expression Semantics] | |
1192 | ||
1193 | map_tie<K0, K1,... KN>(x0, x1,... xN); | |
1194 | ||
1195 | [*Return type]: __map__<__pair__<K0, D0&>, __pair__<K1, D1&>,... __pair__<KN, DN&> > | |
1196 | ||
1197 | [*Semantics]: Create a __map__ of references from `x0, x1,... xN` with keys `K0, K1,... KN` | |
1198 | ||
1199 | [heading Header] | |
1200 | ||
1201 | #include <boost/fusion/container/generation/map_tie.hpp> | |
1202 | #include <boost/fusion/include/map_tie.hpp> | |
1203 | ||
1204 | [heading Example] | |
1205 | ||
1206 | struct int_key; | |
1207 | struct double_key; | |
1208 | ... | |
1209 | int i = 123; | |
1210 | double d = 123.456; | |
1211 | map_tie<int_key, double_key>(i, d) | |
1212 | ||
1213 | [endsect] | |
1214 | ||
1215 | [section deque_tie] | |
1216 | ||
1217 | [heading Description] | |
1218 | ||
1219 | Constructs a tie using a __deque__ sequence. | |
1220 | ||
1221 | [heading Synopsis] | |
1222 | ||
1223 | template <typename ...Elements> | |
1224 | __deque__<Elements&...> | |
1225 | deque_tie(Elements&... elements); | |
1226 | ||
1227 | For C++11 compilers, the variadic function interface has no upper bound. | |
1228 | ||
1229 | For C++03 compilers, the variadic function accepts `0` to | |
1230 | `FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a | |
1231 | user definable predefined maximum that defaults to `10`. You may define | |
1232 | the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any | |
1233 | Fusion header to change the default. Example: | |
1234 | ||
1235 | #define FUSION_MAX_DEQUE_SIZE 20 | |
1236 | ||
1237 | [heading Parameters] | |
1238 | ||
1239 | [table | |
1240 | [[Parameter] [Description] [Description]] | |
1241 | [[`elements`] [Instances of `Elements`] [The arguments to `deque_tie`]] | |
1242 | ] | |
1243 | ||
1244 | [heading Expression Semantics] | |
1245 | ||
1246 | deque_tie(elements...); | |
1247 | ||
1248 | [*Return type]: __deque__<Elements&...> | |
1249 | ||
1250 | [*Semantics]: Create a __deque__ of references from `elements...`. | |
1251 | ||
1252 | [heading Header] | |
1253 | ||
1254 | #include <boost/fusion/container/generation/deque_tie.hpp> | |
1255 | #include <boost/fusion/include/deque_tie.hpp> | |
1256 | ||
1257 | [heading Example] | |
1258 | ||
1259 | int i = 123; | |
1260 | double d = 123.456; | |
1261 | deque_tie(i, d) | |
1262 | ||
1263 | [endsect] | |
1264 | ||
1265 | [endsect] | |
1266 | ||
1267 | [section MetaFunctions] | |
1268 | ||
1269 | [section make_list] | |
1270 | ||
1271 | [heading Description] | |
1272 | ||
1273 | Returns the result type of __make_list__. | |
1274 | ||
1275 | [heading Synopsis] | |
1276 | ||
1277 | template <typename T0, typename T1,... typename TN> | |
1278 | struct make_list; | |
1279 | ||
1280 | For C++11 compilers, the variadic function interface has no upper bound. | |
1281 | ||
1282 | For C++03 compilers, the variadic function accepts `0` to | |
1283 | `FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user | |
1284 | definable predefined maximum that defaults to `10`. You may define the | |
1285 | preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion | |
1286 | header to change the default. Example: | |
1287 | ||
1288 | #define FUSION_MAX_LIST_SIZE 20 | |
1289 | ||
1290 | [heading Parameters] | |
1291 | ||
1292 | [table | |
1293 | [[Parameter] [Requirement] [Description]] | |
1294 | [[`T0, T1,... TN`] [Any type] [Template arguments to `make_list`]] | |
1295 | ] | |
1296 | ||
1297 | [heading Expression Semantics] | |
1298 | ||
1299 | result_of::make_list<T0, T1,... TN>::type | |
1300 | ||
1301 | [*Return type]: A __list__ with elements of types converted following the | |
1302 | rules for __element_conversion__. | |
1303 | ||
1304 | [*Semantics]: Create a __list__ from `T0, T1,... TN`. | |
1305 | ||
1306 | [heading Header] | |
1307 | ||
1308 | #include <boost/fusion/container/generation/make_list.hpp> | |
1309 | #include <boost/fusion/include/make_list.hpp> | |
1310 | ||
1311 | [heading Example] | |
1312 | ||
1313 | result_of::make_list<int, const char(&)[7], double>::type | |
1314 | ||
1315 | [endsect] | |
1316 | ||
1317 | [section make_cons] | |
1318 | ||
1319 | [heading Description] | |
1320 | ||
1321 | Returns the result type of __make_cons__. | |
1322 | ||
1323 | [heading Synopsis] | |
1324 | ||
1325 | template <typename Car, typename Cdr = nil> | |
1326 | struct make_cons; | |
1327 | ||
1328 | [heading Parameters] | |
1329 | ||
1330 | [table | |
1331 | [[Parameter] [Requirement] [Description]] | |
1332 | [[`Car`] [Any type] [The list's head type]] | |
1333 | [[`Cdr`] [A `cons`] [The list's tail type (optional)]] | |
1334 | ] | |
1335 | ||
1336 | [heading Expression Semantics] | |
1337 | ||
1338 | result_of::make_cons<Car, Cdr>::type | |
1339 | ||
1340 | [*Return type]: A __cons__ with head element, `Car`, of type converted | |
1341 | following the rules for __element_conversion__, and tail, `Cdr`. | |
1342 | ||
1343 | [*Semantics]: Create a __cons__ from `Car` (/head/) and optional `Cdr` (/tail/). | |
1344 | ||
1345 | [heading Header] | |
1346 | ||
1347 | #include <boost/fusion/container/generation/make_cons.hpp> | |
1348 | #include <boost/fusion/include/make_cons.hpp> | |
1349 | ||
1350 | [heading Example] | |
1351 | ||
1352 | result_of::make_cons<char, result_of::make_cons<int>::type>::type | |
1353 | ||
1354 | [endsect] | |
1355 | ||
1356 | [section make_vector] | |
1357 | ||
1358 | [heading Description] | |
1359 | ||
1360 | Returns the result type of __make_vector__. | |
1361 | ||
1362 | [heading Synopsis] | |
1363 | ||
1364 | template <typename T0, typename T1,... typename TN> | |
1365 | struct make_vector; | |
1366 | ||
1367 | For C++11 compilers, the variadic function interface has no upper bound. | |
1368 | ||
1369 | For C++03 compilers, the variadic function accepts `0` to | |
1370 | `FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a user | |
1371 | definable predefined maximum that defaults to `10`. You may define the | |
1372 | preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any Fusion | |
1373 | header to change the default. Example: | |
1374 | ||
1375 | #define FUSION_MAX_VECTOR_SIZE 20 | |
1376 | ||
1377 | [heading Parameters] | |
1378 | ||
1379 | [table | |
1380 | [[Parameter] [Requirement] [Description]] | |
1381 | [[`T0, T1,... TN`] [Any type] [Template arguments to `make_vector`]] | |
1382 | ] | |
1383 | ||
1384 | [heading Expression Semantics] | |
1385 | ||
1386 | result_of::make_vector<T0, T1,... TN>::type | |
1387 | ||
1388 | [*Return type]: A __vector__ with elements of types converted following the | |
1389 | rules for __element_conversion__. | |
1390 | ||
1391 | [*Semantics]: Create a __vector__ from `T0, T1,... TN`. | |
1392 | ||
1393 | [heading Header] | |
1394 | ||
1395 | #include <boost/fusion/container/generation/make_vector.hpp> | |
1396 | #include <boost/fusion/include/make_vector.hpp> | |
1397 | ||
1398 | [heading Example] | |
1399 | ||
1400 | result_of::make_vector<int, const char(&)[7], double>::type | |
1401 | ||
1402 | [endsect] | |
1403 | ||
1404 | [section make_deque] | |
1405 | ||
1406 | [heading Description] | |
1407 | ||
1408 | Returns the result type of __make_deque__. | |
1409 | ||
1410 | [heading Synopsis] | |
1411 | ||
1412 | template <typename ...Elements> | |
1413 | struct make_deque; | |
1414 | ||
1415 | For C++11 compilers, the variadic template interface has no upper bound. | |
1416 | ||
1417 | For C++03 The variadic function accepts `0` to `FUSION_MAX_DEQUE_SIZE` | |
1418 | elements, where `FUSION_MAX_DEQUE_SIZE` is a user definable predefined | |
1419 | maximum that defaults to `10`. You may define the preprocessor constant | |
1420 | `FUSION_MAX_DEQUE_SIZE` before including any Fusion header to change the | |
1421 | default. Example: | |
1422 | ||
1423 | #define FUSION_MAX_DEQUE_SIZE 20 | |
1424 | ||
1425 | [heading Parameters] | |
1426 | ||
1427 | [table | |
1428 | [[Parameter] [Requirement] [Description]] | |
1429 | [[`Elements`] [Variadic template types] [Template arguments to `make_deque`]] | |
1430 | ] | |
1431 | ||
1432 | [heading Expression Semantics] | |
1433 | ||
1434 | result_of::make_deque<Elements...>::type | |
1435 | ||
1436 | [*Return type]: A __deque__ with elements of types converted following the | |
1437 | rules for __element_conversion__. | |
1438 | ||
1439 | [*Semantics]: Create a __deque__ from `Elements...`. | |
1440 | ||
1441 | [heading Header] | |
1442 | ||
1443 | #include <boost/fusion/container/generation/make_deque.hpp> | |
1444 | #include <boost/fusion/include/make_deque.hpp> | |
1445 | ||
1446 | [heading Example] | |
1447 | ||
1448 | result_of::make_deque<int, const char(&)[7], double>::type | |
1449 | ||
1450 | [endsect] | |
1451 | ||
1452 | [section make_set] | |
1453 | ||
1454 | [heading Description] | |
1455 | ||
1456 | Returns the result type of __make_set__. | |
1457 | ||
1458 | [heading Synopsis] | |
1459 | ||
1460 | template <typename T0, typename T1,... typename TN> | |
1461 | struct make_set; | |
1462 | ||
1463 | For C++11 compilers, the variadic function interface has no upper bound. | |
1464 | ||
1465 | For C++03 compilers, the variadic function accepts `0` to | |
1466 | `FUSION_MAX_SET_SIZE` elements, where `FUSION_MAX_SET_SIZE` is a user definable | |
1467 | predefined maximum that defaults to `10`. You may define the preprocessor | |
1468 | constant `FUSION_MAX_SET_SIZE` before including any Fusion header to change | |
1469 | the default. Example: | |
1470 | ||
1471 | #define FUSION_MAX_SET_SIZE 20 | |
1472 | ||
1473 | [heading Parameters] | |
1474 | ||
1475 | [table | |
1476 | [[Parameter] [Requirement] [Description]] | |
1477 | [[`T0, T1,... TN`] [Any type] [The arguments to `make_set`]] | |
1478 | ] | |
1479 | ||
1480 | [heading Expression Semantics] | |
1481 | ||
1482 | result_of::make_set<T0, T1,... TN>::type | |
1483 | ||
1484 | [*Return type]: A __set__ with elements of types converted following the | |
1485 | rules for __element_conversion__. | |
1486 | ||
1487 | [*Semantics]: Create a __set__ from `T0, T1,... TN`. | |
1488 | ||
1489 | [*Precondition]: There may be no duplicate key types. | |
1490 | ||
1491 | [heading Header] | |
1492 | ||
1493 | #include <boost/fusion/container/generation/make_set.hpp> | |
1494 | #include <boost/fusion/include/make_set.hpp> | |
1495 | ||
1496 | [heading Example] | |
1497 | ||
1498 | result_of::make_set<int, char, double>::type | |
1499 | ||
1500 | [endsect] | |
1501 | ||
1502 | [section make_map] | |
1503 | ||
1504 | [heading Description] | |
1505 | ||
1506 | Returns the result type of __make_map__. | |
1507 | ||
1508 | The implementation depends on the support of variadic templates. | |
1509 | ||
1510 | When variadic templates are not supported, make_map is a metafunction of the form: | |
1511 | ||
1512 | [heading Synopsis] | |
1513 | ||
1514 | template < | |
1515 | typename K0, typename K1,... typename KN | |
1516 | , typename T0, typename T1,... typename TN> | |
1517 | struct make_map; | |
1518 | ||
1519 | For C++11 compilers, the variadic function interface has no upper bound. | |
1520 | ||
1521 | For C++03 compilers, the variadic function accepts `0` to `FUSION_MAX_MAP_SIZE` elements, | |
1522 | where `FUSION_MAX_MAP_SIZE` is a user definable predefined maximum that | |
1523 | defaults to `10`. You may define the preprocessor constant | |
1524 | `FUSION_MAX_MAP_SIZE` before including any Fusion header to change the | |
1525 | default. Example: | |
1526 | ||
1527 | #define FUSION_MAX_MAP_SIZE 20 | |
1528 | ||
1529 | When variadic templates are supported, make_map is a metafunction class of the form: | |
1530 | ||
1531 | [heading Synopsis] | |
1532 | ||
1533 | template < | |
1534 | typename K0, typename K1,... typename KN> | |
1535 | struct make_map | |
1536 | { | |
1537 | struct apply< | |
1538 | typename T0, typename T1,... typename TN> | |
1539 | }; | |
1540 | ||
1541 | [heading Parameters] | |
1542 | ||
1543 | [table | |
1544 | [[Parameter] [Requirement] [Description]] | |
1545 | [[`K0, K1,... KN`] [Any type] [Keys associated with `T0, T1,... TN`]] | |
1546 | [[`T0, T1,... TN`] [Any type] [Data associated with keys `K0, K1,... KN`]] | |
1547 | ] | |
1548 | ||
1549 | [heading Expression Semantics] | |
1550 | ||
1551 | #if !defined(BOOST_FUSION_HAS_VARIADIC_MAP) | |
1552 | resulf_of::make_map<K0, K1,... KN, T0, T1,... TN>::type; | |
1553 | #else | |
1554 | resulf_of::make_map<K0, K1,... KN>::apply<T0, T1,... TN>::type; | |
1555 | #endif | |
1556 | ||
1557 | [*Return type]: __result_of_make_map__`<K0, K0,... KN, T0, T1,... TN>::type` | |
1558 | when variadic templates are not supported, or | |
1559 | __result_of_make_map__`<K0, K0,... KN>::apply<T0, T1,... TN>::type` | |
1560 | when variadic templates are supported. | |
1561 | ||
1562 | [*Semantics]: A __map__ with __fusion_pair__ elements where the | |
1563 | `second_type` is converted following the rules for __element_conversion__. | |
1564 | ||
1565 | [*Precondition]: There may be no duplicate key types. | |
1566 | ||
1567 | [heading Header] | |
1568 | ||
1569 | #include <boost/fusion/container/generation/make_map.hpp> | |
1570 | #include <boost/fusion/include/make_map.hpp> | |
1571 | ||
1572 | [heading Example] | |
1573 | ||
1574 | #if !defined(BOOST_FUSION_HAS_VARIADIC_MAP) | |
1575 | result_of::make_map<int, double, char, double>::type | |
1576 | #else | |
1577 | result_of::make_map<int, double>::apply<char, double>::type | |
1578 | #endif | |
1579 | ||
1580 | [heading See also] | |
1581 | ||
1582 | __fusion_pair__ | |
1583 | ||
1584 | [endsect] | |
1585 | ||
1586 | [section list_tie] | |
1587 | ||
1588 | [heading Description] | |
1589 | ||
1590 | Returns the result type of __list_tie__. | |
1591 | ||
1592 | [heading Synopsis] | |
1593 | ||
1594 | template <typename T0, typename T1,... typename TN> | |
1595 | struct list_tie; | |
1596 | ||
1597 | For C++11 compilers, the variadic function interface has no upper bound. | |
1598 | ||
1599 | For C++03 compilers, the variadic function accepts `0` to | |
1600 | `FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user | |
1601 | definable predefined maximum that defaults to `10`. You may define the | |
1602 | preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion | |
1603 | header to change the default. Example: | |
1604 | ||
1605 | #define FUSION_MAX_LIST_SIZE 20 | |
1606 | ||
1607 | [heading Parameters] | |
1608 | ||
1609 | [table | |
1610 | [[Parameter] [Requirement] [Description]] | |
1611 | [[`T0, T1,... TN`] [Any type] [The arguments to `list_tie`]] | |
1612 | ] | |
1613 | ||
1614 | [heading Expression Semantics] | |
1615 | ||
1616 | result_of::list_tie<T0, T1,... TN>::type; | |
1617 | ||
1618 | [*Return type]: __list__<T0&, T1&,... TN&> | |
1619 | ||
1620 | [*Semantics]: Create a __list__ of references from `T0, T1,... TN`. | |
1621 | ||
1622 | [heading Header] | |
1623 | ||
1624 | #include <boost/fusion/container/generation/list_tie.hpp> | |
1625 | #include <boost/fusion/include/list_tie.hpp> | |
1626 | ||
1627 | [heading Example] | |
1628 | ||
1629 | result_of::list_tie<int, double>::type | |
1630 | ||
1631 | [endsect] | |
1632 | ||
1633 | [section vector_tie] | |
1634 | ||
1635 | [heading Description] | |
1636 | ||
1637 | Returns the result type of __vector_tie__. | |
1638 | ||
1639 | [heading Synopsis] | |
1640 | ||
1641 | template <typename T0, typename T1,... typename TN> | |
1642 | struct vector_tie; | |
1643 | ||
1644 | For C++11 compilers, the variadic function interface has no upper bound. | |
1645 | ||
1646 | For C++03 compilers, the variadic function accepts `0` to | |
1647 | `FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a user | |
1648 | definable predefined maximum that defaults to `10`. You may define the | |
1649 | preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any Fusion | |
1650 | header to change the default. Example: | |
1651 | ||
1652 | #define FUSION_MAX_VECTOR_SIZE 20 | |
1653 | ||
1654 | [heading Parameters] | |
1655 | ||
1656 | [table | |
1657 | [[Parameter] [Requirement] [Description]] | |
1658 | [[`T0, T1,... TN`] [Any type] [The arguments to `vector_tie`]] | |
1659 | ] | |
1660 | ||
1661 | [heading Expression Semantics] | |
1662 | ||
1663 | result_of::vector_tie<T0, T1,... TN>::type; | |
1664 | ||
1665 | [*Return type]: __vector__<T0&, T1&,... TN&> | |
1666 | ||
1667 | [*Semantics]: Create a __vector__ of references from `T0, T1,... TN`. | |
1668 | ||
1669 | [heading Header] | |
1670 | ||
1671 | #include <boost/fusion/container/generation/vector_tie.hpp> | |
1672 | #include <boost/fusion/include/vector_tie.hpp> | |
1673 | ||
1674 | [heading Example] | |
1675 | ||
1676 | result_of::vector_tie<int, double>::type | |
1677 | ||
1678 | [endsect] | |
1679 | ||
1680 | [section deque_tie] | |
1681 | ||
1682 | [heading Description] | |
1683 | ||
1684 | Returns the result type of __deque_tie__. | |
1685 | ||
1686 | [heading Synopsis] | |
1687 | ||
1688 | template <typename ...Elements> | |
1689 | struct deque_tie; | |
1690 | ||
1691 | For C++11 compilers, the variadic template interface has no upper bound. | |
1692 | ||
1693 | For C++03 compilers, the variadic function accepts `0` to | |
1694 | `FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a | |
1695 | user definable predefined maximum that defaults to `10`. You may define | |
1696 | the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any | |
1697 | Fusion header to change the default. Example: | |
1698 | ||
1699 | #define FUSION_MAX_DEQUE_SIZE 20 | |
1700 | ||
1701 | [heading Parameters] | |
1702 | ||
1703 | [table | |
1704 | [[Parameter] [Requirement] [Description]] | |
1705 | [[`Elements`] [Variadic template types] [Template arguments to `deque_tie`]] | |
1706 | ] | |
1707 | ||
1708 | [heading Expression Semantics] | |
1709 | ||
1710 | result_of::deque_tie<Elements...>::type; | |
1711 | ||
1712 | [*Return type]: __deque__<Elements&...> | |
1713 | ||
1714 | [*Semantics]: Create a __deque__ of references from `Elements...`. | |
1715 | ||
1716 | [heading Header] | |
1717 | ||
1718 | #include <boost/fusion/container/generation/deque_tie.hpp> | |
1719 | #include <boost/fusion/include/deque_tie.hpp> | |
1720 | ||
1721 | [heading Example] | |
1722 | ||
1723 | result_of::deque_tie<int, double>::type | |
1724 | ||
1725 | [endsect] | |
1726 | ||
1727 | [section map_tie] | |
1728 | ||
1729 | [heading Description] | |
1730 | ||
1731 | Returns the result type of __map_tie__. | |
1732 | ||
1733 | [heading Synopsis] | |
1734 | ||
1735 | template <typename K0, typename K1,... typename KN, typename D0, typename D1,... typename DN> | |
1736 | struct map_tie; | |
1737 | ||
1738 | For C++11 compilers, the variadic function interface has no upper bound. | |
1739 | ||
1740 | For C++03 compilers, the variadic function accepts `0` to | |
1741 | `FUSION_MAX_MAP_SIZE` elements, where `FUSION_MAX_MAP_SIZE` is a user definable | |
1742 | predefined maximum that defaults to `10`. You may define the preprocessor | |
1743 | constant `FUSION_MAX_MAP_SIZE` before including any Fusion header to change | |
1744 | the default. Example: | |
1745 | ||
1746 | #define FUSION_MAX_MAP_SIZE 20 | |
1747 | ||
1748 | [heading Parameters] | |
1749 | ||
1750 | [table | |
1751 | [[Parameter] [Requirement] [Description]] | |
1752 | [[`K0, K1,... KN`] [Any type] [The key types for `map_tie`]] | |
1753 | [[`D0, D1,... DN`] [Any type] [The arguments types for `map_tie`]] | |
1754 | ] | |
1755 | ||
1756 | [heading Expression Semantics] | |
1757 | ||
1758 | result_of::map_tie<K0, K1,... KN, D0, D1,... DN>::type; | |
1759 | ||
1760 | [*Return type]: __map__<__pair__<K0, D0&>, __pair__<K1, D1&>,... __pair__<KN, DN&> > | |
1761 | ||
1762 | [*Semantics]: Create a __map__ of references from `D0, D1,... DN` with keys `K0, K1,... KN` | |
1763 | ||
1764 | [heading Header] | |
1765 | ||
1766 | #include <boost/fusion/container/generation/map_tie.hpp> | |
1767 | #include <boost/fusion/include/map_tie.hpp> | |
1768 | ||
1769 | [heading Example] | |
1770 | ||
1771 | struct int_key; | |
1772 | struct double_key; | |
1773 | ... | |
1774 | result_of::map_tie<int_key, double_key, int, double>::type | |
1775 | ||
1776 | [endsect] | |
1777 | ||
1778 | [endsect] | |
1779 | ||
1780 | [endsect] | |
1781 | ||
1782 | [section Conversion] | |
1783 | ||
1784 | All fusion sequences can be converted to one of the __containers__ types | |
1785 | using one of these conversion functions. | |
1786 | ||
1787 | [heading Header] | |
1788 | ||
1789 | #include <boost/fusion/include/convert.hpp> | |
1790 | ||
1791 | [section Functions] | |
1792 | ||
1793 | [section as_list] | |
1794 | ||
1795 | [heading Description] | |
1796 | ||
1797 | Convert a fusion sequence to a __list__. | |
1798 | ||
1799 | [heading Synopsis] | |
1800 | ||
1801 | template <typename Sequence> | |
1802 | typename result_of::as_list<Sequence>::type | |
1803 | as_list(Sequence& seq); | |
1804 | ||
1805 | template <typename Sequence> | |
1806 | typename result_of::as_list<Sequence const>::type | |
1807 | as_list(Sequence const& seq); | |
1808 | ||
1809 | [heading Parameters] | |
1810 | ||
1811 | [table | |
1812 | [[Parameter] [Requirement] [Description]] | |
1813 | [[`seq`] [An instance of Sequence] [The sequence to convert.]] | |
1814 | ] | |
1815 | ||
1816 | [heading Expression Semantics] | |
1817 | ||
1818 | as_list(seq); | |
1819 | ||
1820 | [*Return type]: __result_of_as_list__`<Sequence>::type` | |
1821 | ||
1822 | [*Semantics]: Convert a fusion sequence, `seq`, to a __list__. | |
1823 | ||
1824 | [heading Header] | |
1825 | ||
1826 | #include <boost/fusion/container/list/convert.hpp> | |
1827 | #include <boost/fusion/include/as_list.hpp> | |
1828 | ||
1829 | [heading Example] | |
1830 | ||
1831 | as_list(__make_vector__('x', 123, "hello")) | |
1832 | ||
1833 | [endsect] | |
1834 | ||
1835 | [section as_vector] | |
1836 | ||
1837 | [heading Description] | |
1838 | ||
1839 | Convert a fusion sequence to a __vector__. | |
1840 | ||
1841 | [heading Synopsis] | |
1842 | ||
1843 | template <typename Sequence> | |
1844 | typename result_of::as_vector<Sequence>::type | |
1845 | as_vector(Sequence& seq); | |
1846 | ||
1847 | template <typename Sequence> | |
1848 | typename result_of::as_vector<Sequence const>::type | |
1849 | as_vector(Sequence const& seq); | |
1850 | ||
1851 | [heading Parameters] | |
1852 | ||
1853 | [table | |
1854 | [[Parameter] [Requirement] [Description]] | |
1855 | [[`seq`] [An instance of Sequence] [The sequence to convert.]] | |
1856 | ] | |
1857 | ||
1858 | [heading Expression Semantics] | |
1859 | ||
1860 | as_vector(seq); | |
1861 | ||
1862 | [*Return type]: __result_of_as_vector__`<Sequence>::type` | |
1863 | ||
1864 | [*Semantics]: Convert a fusion sequence, `seq`, to a __vector__. | |
1865 | ||
1866 | [heading Header] | |
1867 | ||
1868 | #include <boost/fusion/container/vector/convert.hpp> | |
1869 | #include <boost/fusion/include/as_vector.hpp> | |
1870 | ||
1871 | [heading Example] | |
1872 | ||
1873 | as_vector(__make_list__('x', 123, "hello")) | |
1874 | ||
1875 | [endsect] | |
1876 | ||
1877 | [section as_deque] | |
1878 | ||
1879 | [heading Description] | |
1880 | ||
1881 | Convert a fusion sequence to a __deque__. | |
1882 | ||
1883 | [heading Synopsis] | |
1884 | ||
1885 | template <typename Sequence> | |
1886 | typename result_of::as_deque<Sequence>::type | |
1887 | as_deque(Sequence& seq); | |
1888 | ||
1889 | template <typename Sequence> | |
1890 | typename result_of::as_deque<Sequence const>::type | |
1891 | as_deque(Sequence const& seq); | |
1892 | ||
1893 | [heading Parameters] | |
1894 | ||
1895 | [table | |
1896 | [[Parameter] [Requirement] [Description]] | |
1897 | [[`seq`] [An instance of Sequence] [The sequence to convert.]] | |
1898 | ] | |
1899 | ||
1900 | [heading Expression Semantics] | |
1901 | ||
1902 | as_deque(seq); | |
1903 | ||
1904 | [*Return type]: __result_of_as_deque__`<Sequence>::type` | |
1905 | ||
1906 | [*Semantics]: Convert a fusion sequence, `seq`, to a __deque__. | |
1907 | ||
1908 | [heading Header] | |
1909 | ||
1910 | #include <boost/fusion/container/deque/convert.hpp> | |
1911 | #include <boost/fusion/include/as_deque.hpp> | |
1912 | ||
1913 | [heading Example] | |
1914 | ||
1915 | as_deque(__make_vector__('x', 123, "hello")) | |
1916 | ||
1917 | [endsect] | |
1918 | ||
1919 | [section as_set] | |
1920 | ||
1921 | [heading Description] | |
1922 | ||
1923 | Convert a fusion sequence to a __set__. | |
1924 | ||
1925 | [heading Synopsis] | |
1926 | ||
1927 | template <typename Sequence> | |
1928 | typename result_of::as_set<Sequence>::type | |
1929 | as_set(Sequence& seq); | |
1930 | ||
1931 | template <typename Sequence> | |
1932 | typename result_of::as_set<Sequence const>::type | |
1933 | as_set(Sequence const& seq); | |
1934 | ||
1935 | [heading Parameters] | |
1936 | ||
1937 | [table | |
1938 | [[Parameter] [Requirement] [Description]] | |
1939 | [[`seq`] [An instance of Sequence] [The sequence to convert.]] | |
1940 | ] | |
1941 | ||
1942 | [heading Expression Semantics] | |
1943 | ||
1944 | as_set(seq); | |
1945 | ||
1946 | [*Return type]: __result_of_as_set__`<Sequence>::type` | |
1947 | ||
1948 | [*Semantics]: Convert a fusion sequence, `seq`, to a __set__. | |
1949 | ||
1950 | [*Precondition]: There may be no duplicate key types. | |
1951 | ||
1952 | [heading Header] | |
1953 | ||
1954 | #include <boost/fusion/container/set/convert.hpp> | |
1955 | #include <boost/fusion/include/as_set.hpp> | |
1956 | ||
1957 | [heading Example] | |
1958 | ||
1959 | as_set(__make_vector__('x', 123, "hello")) | |
1960 | ||
1961 | [endsect] | |
1962 | ||
1963 | [section as_map] | |
1964 | ||
1965 | [heading Description] | |
1966 | ||
1967 | Convert a fusion sequence to a __map__. | |
1968 | ||
1969 | [heading Synopsis] | |
1970 | ||
1971 | template <typename Sequence> | |
1972 | typename result_of::as_map<Sequence>::type | |
1973 | as_map(Sequence& seq); | |
1974 | ||
1975 | template <typename Sequence> | |
1976 | typename result_of::as_map<Sequence const>::type | |
1977 | as_map(Sequence const& seq); | |
1978 | ||
1979 | [heading Parameters] | |
1980 | ||
1981 | [table | |
1982 | [[Parameter] [Requirement] [Description]] | |
1983 | [[`seq`] [An instance of Sequence] [The sequence to convert.]] | |
1984 | ] | |
1985 | ||
1986 | [heading Expression Semantics] | |
1987 | ||
1988 | as_map(seq); | |
1989 | ||
1990 | [*Return type]: __result_of_as_map__`<Sequence>::type` | |
1991 | ||
1992 | [*Semantics]: Convert a fusion sequence, `seq`, to a __map__. | |
1993 | ||
1994 | [*Precondition]: For non-associative sequence, the elements are assumed to be | |
1995 | __fusion_pair__s. There may be no duplicate __fusion_pair__ key types. | |
1996 | ||
1997 | [heading Header] | |
1998 | ||
1999 | #include <boost/fusion/container/map/convert.hpp> | |
2000 | #include <boost/fusion/include/as_map.hpp> | |
2001 | ||
2002 | [heading Example] | |
2003 | ||
2004 | // from sequence of __fusion_pair__ | |
2005 | as_map(__make_vector__( | |
2006 | __fusion_make_pair__<int>('X') | |
2007 | , __fusion_make_pair__<double>("Men"))) | |
2008 | ||
2009 | // from associative sequence | |
2010 | namespace ns | |
2011 | { | |
2012 | struct x_member; | |
2013 | struct y_member; | |
2014 | } | |
2015 | BOOST_FUSION_DEFINE_ASSOC_STRUCT( | |
2016 | (ns), | |
2017 | point, | |
2018 | (int, x, ns::x_member) | |
2019 | (int, y, ns::y_member) | |
2020 | ) | |
2021 | ... | |
2022 | as_map(ns::point(123, 456)) | |
2023 | ||
2024 | [endsect] | |
2025 | ||
2026 | [endsect] | |
2027 | ||
2028 | [section Metafunctions] | |
2029 | ||
2030 | [section as_list] | |
2031 | ||
2032 | [heading Description] | |
2033 | ||
2034 | Returns the result type of __as_list__. | |
2035 | ||
2036 | [heading Synopsis] | |
2037 | ||
2038 | template <typename Sequence> | |
2039 | struct as_list; | |
2040 | ||
2041 | [heading Parameters] | |
2042 | ||
2043 | [table | |
2044 | [[Parameter] [Requirement] [Description]] | |
2045 | [[`Sequence`] [A fusion __sequence__] [The sequence type to convert.]] | |
2046 | ] | |
2047 | ||
2048 | [heading Expression Semantics] | |
2049 | ||
2050 | result_of::as_list<Sequence>::type; | |
2051 | ||
2052 | [*Return type]: A __list__ with same elements as the input sequence, | |
2053 | `Sequence`. | |
2054 | ||
2055 | [*Semantics]: Convert a fusion sequence, `Sequence`, to a __list__. | |
2056 | ||
2057 | [heading Header] | |
2058 | ||
2059 | #include <boost/fusion/container/list/convert.hpp> | |
2060 | #include <boost/fusion/include/as_list.hpp> | |
2061 | ||
2062 | [heading Example] | |
2063 | ||
2064 | result_of::as_list<__vector__<char, int> >::type | |
2065 | ||
2066 | [endsect] | |
2067 | ||
2068 | [section as_vector] | |
2069 | ||
2070 | [heading Description] | |
2071 | ||
2072 | Returns the result type of __as_vector__. | |
2073 | ||
2074 | [heading Synopsis] | |
2075 | ||
2076 | template <typename Sequence> | |
2077 | struct as_vector; | |
2078 | ||
2079 | [heading Parameters] | |
2080 | ||
2081 | [table | |
2082 | [[Parameter] [Requirement] [Description]] | |
2083 | [[`Sequence`] [A fusion __sequence__] [The sequence to convert.]] | |
2084 | ] | |
2085 | ||
2086 | [heading Expression Semantics] | |
2087 | ||
2088 | result_of::as_vector<Sequence>::type; | |
2089 | ||
2090 | [*Return type]: A __vector__ with same elements as the input sequence, | |
2091 | `Sequence`. | |
2092 | ||
2093 | [*Semantics]: Convert a fusion sequence, `Sequence`, to a __vector__. | |
2094 | ||
2095 | [heading Header] | |
2096 | ||
2097 | #include <boost/fusion/container/vector/convert.hpp> | |
2098 | #include <boost/fusion/include/as_vector.hpp> | |
2099 | ||
2100 | [heading Example] | |
2101 | ||
2102 | result_of::as_vector<__list__<char, int> >::type | |
2103 | ||
2104 | [endsect] | |
2105 | ||
2106 | [section as_deque] | |
2107 | ||
2108 | [heading Description] | |
2109 | ||
2110 | Returns the result type of __as_deque__. | |
2111 | ||
2112 | [heading Synopsis] | |
2113 | ||
2114 | template <typename Sequence> | |
2115 | struct as_deque; | |
2116 | ||
2117 | [heading Parameters] | |
2118 | ||
2119 | [table | |
2120 | [[Parameter] [Requirement] [Description]] | |
2121 | [[`Sequence`] [A fusion __sequence__] [The sequence type to convert.]] | |
2122 | ] | |
2123 | ||
2124 | [heading Expression Semantics] | |
2125 | ||
2126 | result_of::as_deque<Sequence>::type; | |
2127 | ||
2128 | [*Return type]: A __deque__ with same elements as the input sequence, | |
2129 | `Sequence`. | |
2130 | ||
2131 | [*Semantics]: Convert a fusion sequence, `Sequence`, to a __deque__. | |
2132 | ||
2133 | [heading Header] | |
2134 | ||
2135 | #include <boost/fusion/container/deque/convert.hpp> | |
2136 | #include <boost/fusion/include/as_deque.hpp> | |
2137 | ||
2138 | [heading Example] | |
2139 | ||
2140 | result_of::as_deque<__vector__<char, int> >::type | |
2141 | ||
2142 | [endsect] | |
2143 | ||
2144 | [section as_set] | |
2145 | ||
2146 | [heading Description] | |
2147 | ||
2148 | Returns the result type of __as_set__. | |
2149 | ||
2150 | [heading Synopsis] | |
2151 | ||
2152 | template <typename Sequence> | |
2153 | struct as_set; | |
2154 | ||
2155 | [heading Parameters] | |
2156 | ||
2157 | [table | |
2158 | [[Parameter] [Requirement] [Description]] | |
2159 | [[`Sequence`] [A fusion __sequence__] [The sequence to convert.]] | |
2160 | ] | |
2161 | ||
2162 | [heading Expression Semantics] | |
2163 | ||
2164 | result_of::as_set<Sequence>::type; | |
2165 | ||
2166 | [*Return type]: A __set__ with same elements as the input sequence, | |
2167 | `Sequence`. | |
2168 | ||
2169 | [*Semantics]: Convert a fusion sequence, `Sequence`, to a __set__. | |
2170 | ||
2171 | [*Precondition]: There may be no duplicate key types. | |
2172 | ||
2173 | [heading Header] | |
2174 | ||
2175 | #include <boost/fusion/container/set/convert.hpp> | |
2176 | #include <boost/fusion/include/as_set.hpp> | |
2177 | ||
2178 | [heading Example] | |
2179 | ||
2180 | result_of::as_set<__vector__<char, int> >::type | |
2181 | ||
2182 | [endsect] | |
2183 | ||
2184 | [section as_map] | |
2185 | ||
2186 | [heading Description] | |
2187 | ||
2188 | Returns the result type of __as_map__. | |
2189 | ||
2190 | [heading Synopsis] | |
2191 | ||
2192 | template <typename Sequence> | |
2193 | struct as_map; | |
2194 | ||
2195 | [heading Parameters] | |
2196 | ||
2197 | [table | |
2198 | [[Parameter] [Requirement] [Description]] | |
2199 | [[`Sequence`] [A fusion __sequence__] [The sequence to convert.]] | |
2200 | ] | |
2201 | ||
2202 | [heading Expression Semantics] | |
2203 | ||
2204 | result_of::as_map<Sequence>::type; | |
2205 | ||
2206 | [*Return type]: A __map__ with same elements as the input sequence, | |
2207 | `Sequence`. | |
2208 | ||
2209 | [*Semantics]: Convert a fusion sequence, `Sequence`, to a __map__. | |
2210 | ||
2211 | [*Precondition]: For non-associative sequence, the elements are assumed to be | |
2212 | __fusion_pair__s. There may be no duplicate __fusion_pair__ key types. | |
2213 | ||
2214 | [heading Header] | |
2215 | ||
2216 | #include <boost/fusion/container/map/convert.hpp> | |
2217 | #include <boost/fusion/include/as_map.hpp> | |
2218 | ||
2219 | [heading Example] | |
2220 | ||
2221 | // from sequence of __fusion_pair__ | |
2222 | result_of::as_map<__vector__< | |
2223 | __fusion_pair__<int, char> | |
2224 | , __fusion_pair__<double, std::string> > >::type | |
2225 | ||
2226 | // from associative sequence | |
2227 | namespace ns | |
2228 | { | |
2229 | struct x_member; | |
2230 | struct y_member; | |
2231 | } | |
2232 | BOOST_FUSION_DEFINE_ASSOC_STRUCT( | |
2233 | (ns), | |
2234 | point, | |
2235 | (int, x, ns::x_member) | |
2236 | (int, y, ns::y_member) | |
2237 | ) | |
2238 | ... | |
2239 | result_of::as_map<ns::point>::type // __map__<__fusion_pair__<ns::x_member, int>, __fusion_pair__<ns::y_member, int> > | |
2240 | ||
2241 | [endsect] | |
2242 | ||
2243 | [endsect] | |
2244 | ||
2245 | [endsect] | |
2246 | ||
2247 | [endsect] |