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 11Fusion 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 25structured as a simple `struct` where each element is held as a member 26variable. `vector` is the simplest of the Fusion sequence container (a 27vector with N elements is just a struct with N members), and in many 28cases 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 85The numbered form accepts the exact number of elements. Example: 86 87 vector3<int, char, double> 88 89For C++11 compilers, the variadic function interface has no upper bound. 90 91For C++03 compilers, the The variadic form accepts `0` to 92`FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a 93user definable predefined maximum that defaults to `10`. Example: 94 95 vector<int, char, double> 96 97You may define the preprocessor constant `FUSION_MAX_VECTOR_SIZE` before 98including 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 122Semantics of an expression is defined only where it differs from, or is not 123defined 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 146structure where `car` is the /head/ and `cdr` is the /tail/: usually 147another cons structure or `nil`: the empty list. Fusion's __list__ is built 148on 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 150time). 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 187Semantics of an expression is defined only where it differs from, or is not 188defined 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 202with 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 205constant (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 221constructed piecemeal (a data at a time). The runtime cost of access to 222each 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 242For C++11 compilers, the variadic function interface has no upper bound. 243 244For C++03 compilers, the variadic class interface accepts `0` to 245`FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user 246definable predefined maximum that defaults to `10`. Example: 247 248 list<int, char, double> 249 250You may define the preprocessor constant `FUSION_MAX_LIST_SIZE` before 251including 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 276Semantics of an expression is defined only where it differs from, or is not 277defined 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 289with 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 292constant (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 307constant-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 310piecemeal (a data at a time, e.g. when constructing expression 311templates). Like the __list__ and __cons__, runtime cost of access to 312each element is peculiarly constant (see __recursive_inline__). 313 314Element 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 329For C++11 compilers, the variadic class interface has no upper bound. 330 331For C++03 compilers, the variadic class interface accepts `0` to 332`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a 333user definable predefined maximum that defaults to `10`. Example: 334 335 deque<int, char, double> 336 337You may define the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before 338including 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 363Semantics of an expression is defined only where it differs from, or is not 364defined 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 377a __random_access_sequence__ requirement). The runtime complexity of 378__at__ is constant (see __recursive_inline__). `deque` element access 379utilizes operator overloading with argument dependent lookup (ADL) of 380the proper element getter function given a static constant index 381parameter. Interestingly, with modern C++ compilers, this lookup is very 382fast and rivals recursive template instantiations in compile time-speed, 383so much so that `deque` relies on ADL for all element access (indexing) 384as 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 399the 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 433Semantics of an expression is defined only where it differs from, or is 434not 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 460the 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 494Semantics of an expression is defined only where it differs from, or is 495not 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 520set is an __associative_sequence__ of heterogeneous typed data elements. 521Type identity is used to impose an equivalence relation on keys. The 522element's type is its key. A set may contain at most one element for each 523key. Membership testing and element key lookup has constant runtime 524complexity (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 544For C++11 compilers, the variadic function interface has no upper bound. 545 546For C++03 compilers, the variadic class interface accepts `0` to 547`FUSION_MAX_SET_SIZE` elements, where `FUSION_MAX_SET_SIZE` is a user 548definable predefined maximum that defaults to `10`. Example: 549 550 set<int, char, double> 551 552You may define the preprocessor constant `FUSION_MAX_SET_SIZE` before 553including 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 578Semantics of an expression is defined only where it differs from, or is not 579defined 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 603map is an __associative_sequence__ of heterogeneous typed data elements. 604Each element is a key/data pair (see __fusion_pair__) where the key has no 605data (type only). Type identity is used to impose an equivalence relation 606on keys. A map may contain at most one element for each key. Membership 607testing 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 628For C++11 compilers, the variadic function interface has no upper bound. 629 630For C++03 compilers, the variadic class interface accepts `0` to 631`FUSION_MAX_MAP_SIZE` elements, where `FUSION_MAX_MAP_SIZE` is a user 632definable predefined maximum that defaults to `10`. Example: 633 634 map<__pair__<int, char>, __pair__<char, char>, __pair__<double, char> > 635 636You may define the preprocessor constant `FUSION_MAX_MAP_SIZE` before 637including 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 662Semantics of an expression is defined only where it differs from, or is not 663defined 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 691These 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 705Create 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 713For C++11 compilers, the variadic function interface has no upper bound. 714 715For C++03 compilers, the variadic function accepts `0` to 716`FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user 717definable predefined maximum that defaults to `10`. You may define the 718preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion 719header 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 757Create 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 805Create 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 813For C++11 compilers, the variadic function interface has no upper bound. 814 815For C++03 compilers, the variadic function accepts `0` to 816`FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a 817user definable predefined maximum that defaults to `10`. You may define 818the preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any 819Fusion 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 857Create 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 865For C++11 compilers, the variadic function interface has no upper bound. 866 867For C++03 compilers, the variadic function accepts `0` to 868`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a 869user definable predefined maximum that defaults to `10`. You may define 870the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any 871Fusion 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 909Create 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 917For C++11 compilers, the variadic function interface has no upper bound. 918 919For C++03 compilers, the variadic function accepts `0` to 920`FUSION_MAX_SET_SIZE` elements, where `FUSION_MAX_SET_SIZE` is a user 921definable predefined maximum that defaults to `10`. You may define the 922preprocessor constant `FUSION_MAX_SET_SIZE` before including any Fusion 923header 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 963Create 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 973For C++11 compilers, the variadic function interface has no upper bound. 974 975For C++03 compilers, the variadic function accepts `0` to `FUSION_MAX_MAP_SIZE` elements, 976where `FUSION_MAX_MAP_SIZE` is a user definable predefined maximum that 977defaults to `10`. You may define the preprocessor constant 978`FUSION_MAX_MAP_SIZE` before including any Fusion header to change the 979default. 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 1019Tiers are sequences, where all elements are non-const reference types. They 1020are constructed with a call to a couple of /tie/ function templates. The 1021succeeding sections document the various /tier/ flavors. 1022 1023* __list_tie__ 1024* __vector_tie__ 1025* __map_tie__ 1026* __deque_tie__ 1027 1028Example: 1029 1030 int i; char c; double d; 1031 ... 1032 __vector_tie__(i, c, d); 1033 1034The __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 1039A /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 1045This code prints 1 a 5.5 to the standard output stream. A sequence 1046unpacking operation like this is found for example in ML and Python. It is 1047convenient when calling functions which return sequences. 1048 1049[heading Ignore] 1050 1051There is also an object called /ignore/ which allows you to ignore an 1052element assigned by a sequence. The idea is that a function may return a 1053sequence, 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 1064Constructs 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 1072For C++11 compilers, the variadic function interface has no upper bound. 1073 1074For C++03 compilers, the variadic function accepts `0` to 1075`FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user 1076definable predefined maximum that defaults to `10`. You may define the 1077preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion 1078header 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 1114Constructs 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 1122For C++11 compilers, the variadic function interface has no upper bound. 1123 1124For C++03 compilers, the variadic function accepts `0` to 1125`FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a 1126user definable predefined maximum that defaults to `10`. You may define 1127the preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any 1128Fusion 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 1164Constructs 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 1172For C++11 compilers, the variadic function interface has no upper bound. 1173 1174For C++03 compilers, the variadic function accepts `0` to 1175`FUSION_MAX_MAP_SIZE` elements, where `FUSION_MAX_MAP_SIZE` is a user 1176definable predefined maximum that defaults to `10`, and a corresponding 1177number of key types. You may define the preprocessor constant 1178`FUSION_MAX_MAP_SIZE` before including any Fusion header to change the 1179default. 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 1219Constructs a tie using a __deque__ sequence. 1220 1221[heading Synopsis] 1222 1223 template <typename ...Elements> 1224 __deque__<Elements&...> 1225 deque_tie(Elements&... elements); 1226 1227For C++11 compilers, the variadic function interface has no upper bound. 1228 1229For C++03 compilers, the variadic function accepts `0` to 1230`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a 1231user definable predefined maximum that defaults to `10`. You may define 1232the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any 1233Fusion 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 1273Returns the result type of __make_list__. 1274 1275[heading Synopsis] 1276 1277 template <typename T0, typename T1,... typename TN> 1278 struct make_list; 1279 1280For C++11 compilers, the variadic function interface has no upper bound. 1281 1282For C++03 compilers, the variadic function accepts `0` to 1283`FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user 1284definable predefined maximum that defaults to `10`. You may define the 1285preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion 1286header 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 1302rules 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 1321Returns 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 1341following 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 1360Returns the result type of __make_vector__. 1361 1362[heading Synopsis] 1363 1364 template <typename T0, typename T1,... typename TN> 1365 struct make_vector; 1366 1367For C++11 compilers, the variadic function interface has no upper bound. 1368 1369For C++03 compilers, the variadic function accepts `0` to 1370`FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a user 1371definable predefined maximum that defaults to `10`. You may define the 1372preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any Fusion 1373header 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 1389rules 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 1408Returns the result type of __make_deque__. 1409 1410[heading Synopsis] 1411 1412 template <typename ...Elements> 1413 struct make_deque; 1414 1415For C++11 compilers, the variadic template interface has no upper bound. 1416 1417For C++03 The variadic function accepts `0` to `FUSION_MAX_DEQUE_SIZE` 1418elements, where `FUSION_MAX_DEQUE_SIZE` is a user definable predefined 1419maximum that defaults to `10`. You may define the preprocessor constant 1420`FUSION_MAX_DEQUE_SIZE` before including any Fusion header to change the 1421default. 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 1437rules 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 1456Returns the result type of __make_set__. 1457 1458[heading Synopsis] 1459 1460 template <typename T0, typename T1,... typename TN> 1461 struct make_set; 1462 1463For C++11 compilers, the variadic function interface has no upper bound. 1464 1465For C++03 compilers, the variadic function accepts `0` to 1466`FUSION_MAX_SET_SIZE` elements, where `FUSION_MAX_SET_SIZE` is a user definable 1467predefined maximum that defaults to `10`. You may define the preprocessor 1468constant `FUSION_MAX_SET_SIZE` before including any Fusion header to change 1469the 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 1485rules 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 1506Returns the result type of __make_map__. 1507 1508The implementation depends on the support of variadic templates. 1509 1510When 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 1519For C++11 compilers, the variadic function interface has no upper bound. 1520 1521For C++03 compilers, the variadic function accepts `0` to `FUSION_MAX_MAP_SIZE` elements, 1522where `FUSION_MAX_MAP_SIZE` is a user definable predefined maximum that 1523defaults to `10`. You may define the preprocessor constant 1524`FUSION_MAX_MAP_SIZE` before including any Fusion header to change the 1525default. Example: 1526 1527 #define FUSION_MAX_MAP_SIZE 20 1528 1529When 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` 1558when variadic templates are not supported, or 1559__result_of_make_map__`<K0, K0,... KN>::apply<T0, T1,... TN>::type` 1560when 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 1590Returns the result type of __list_tie__. 1591 1592[heading Synopsis] 1593 1594 template <typename T0, typename T1,... typename TN> 1595 struct list_tie; 1596 1597For C++11 compilers, the variadic function interface has no upper bound. 1598 1599For C++03 compilers, the variadic function accepts `0` to 1600`FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user 1601definable predefined maximum that defaults to `10`. You may define the 1602preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion 1603header 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 1637Returns the result type of __vector_tie__. 1638 1639[heading Synopsis] 1640 1641 template <typename T0, typename T1,... typename TN> 1642 struct vector_tie; 1643 1644For C++11 compilers, the variadic function interface has no upper bound. 1645 1646For C++03 compilers, the variadic function accepts `0` to 1647`FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a user 1648definable predefined maximum that defaults to `10`. You may define the 1649preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any Fusion 1650header 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 1684Returns the result type of __deque_tie__. 1685 1686[heading Synopsis] 1687 1688 template <typename ...Elements> 1689 struct deque_tie; 1690 1691For C++11 compilers, the variadic template interface has no upper bound. 1692 1693For C++03 compilers, the variadic function accepts `0` to 1694`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a 1695user definable predefined maximum that defaults to `10`. You may define 1696the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any 1697Fusion 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 1731Returns 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 1738For C++11 compilers, the variadic function interface has no upper bound. 1739 1740For C++03 compilers, the variadic function accepts `0` to 1741`FUSION_MAX_MAP_SIZE` elements, where `FUSION_MAX_MAP_SIZE` is a user definable 1742predefined maximum that defaults to `10`. You may define the preprocessor 1743constant `FUSION_MAX_MAP_SIZE` before including any Fusion header to change 1744the 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 1784All fusion sequences can be converted to one of the __containers__ types 1785using 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 1797Convert 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 1839Convert 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 1881Convert 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 1923Convert 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 1967Convert 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 2034Returns 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 2072Returns 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 2110Returns 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 2148Returns 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 2188Returns 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] 2248