fusion.qbk

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

[/==============================================================================
    Copyright (C) 2001-2007 Joel de Guzman, Dan Marsden, Tobias Schwinger

    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
===============================================================================/]
[library Fusion
    [quickbook 1.3]
    [version 2.0]
    [authors [de Guzman, Joel], [Marsden, Dan], [Schwinger, Tobias]]
    [copyright 2001 2002 2003 2004 2005 2006 2007 Joel de Guzman, Dan Marsden, Tobias Schwinger]
    [purpose Statically Typed Heterogeneous Data Structures and Algorithms]
    [license
        Distributed under the Boost Software License, Version 1.0.
        (See accompanying file LICENSE_1_0.txt or copy at
        [@http://www.boost.org/LICENSE_1_0.txt])
    ]
]

[def __note__                   [$images/note.png]]
[def __alert__                  [$images/alert.png]]
[def __tip__                    [$images/tip.png]]
[def __caution__                [$images/caution.png]]

[def __spirit__                 [@http://spirit.sourceforge.net Spirit]]
[def __phoenix__                [@http://boost.org/libs/spirit/phoenix/index.html Phoenix]]
[def __mpl__                    [@http://www.boost.org/libs/mpl/index.html MPL]]
[def __stl__                    [@http://en.wikipedia.org/wiki/Standard_Template_Library STL]]
[def __tuple__                  [@http://www.boost.org/libs/tuple/doc/tuple_users_guide.html Boost.Tuple]]
[def __tr1__tuple__             [@http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1403.pdf TR1 Tuple]]
[def __boost_tools__            [@http://www.boost.org/tools/index.html Boost Tools]]
[def __spirit_list__            [@https://lists.sourceforge.net/lists/listinfo/spirit-general Spirit Mailing List]]
[def __spirit_general__         [@news://news.gmane.org/gmane.comp.spirit.general Spirit General NNTP news portal]]
[def __gmane__                  [@http://www.gmane.org Gmane]]
[def __mlist_archive__          [@http://news.gmane.org/gmane.comp.parsers.spirit.general]]
[def __jaakko_jarvi__           [@http://www.boost.org/people/jaakko_jarvi.htm Jaakko Jarvi]]
[def __david_abrahams__         [@http://www.boost.org/people/dave_abrahams.htm David Abrahams]]
[def __the_forwarding_problem__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm The Forwarding Problem]]

[def __boost_any__              [@http://boost.org/doc/html/any.html Boost.Any]]
[def __new_iterator_concepts__  [@http://boost.org/libs/iterator/doc/new-iter-concepts.html New Iterator Concepts]]
[def __boost_array_library__    [@http://www.boost.org/doc/html/array.html Boost.Array Library]]
[def __boost_variant_library__  [@http://www.boost.org/doc/html/variant.html Boost.Variant Library]]
[def __boost_tuple_library__    [@http://www.boost.org/libs/tuple/doc/tuple_users_guide.html Boost.Tuple Library]]
[def __boost_ref__              [@http://www.boost.org/doc/html/ref.html Boost.Ref]]
[def __boost_ref_call__         [@http://www.boost.org/doc/html/ref.html `ref`]]
[def __boost_result_of__        [@http://www.boost.org/libs/utility/utility.htm#result_of Boost.ResultOf]]
[def __boost_result_of_call__   [@http://www.boost.org/libs/utility/utility.htm#result_of `boost::result_of`]]
[def __boost_enable_if__        [@http://www.boost.org/libs/utility/enable_if.html Boost.EnableIf utility]]
[def __boost_shared_ptr_call__  [@http://www.boost.org/libs/smart_ptr/shared_ptr.htm `boost::shared_ptr`]]
[def __std_pair_doc__           [@http://www.sgi.com/tech/stl/pair.html `std::pair`]]
[def __std_plus_doc__           [@http://www.sgi.com/tech/stl/plus.html `std::plus`]]
[def __std_minus_doc__          [@http://www.sgi.com/tech/stl/minus.html `std::minus`]]

[def __mpl_integral_constant__  [@http://www.boost.org/libs/mpl/doc/refmanual/integral-constant.html MPL Integral Constant]]
[def __mpl_boolean_constant__   [@http://www.boost.org/libs/mpl/doc/refmanual/integral-constant.html MPL Boolean Constant]]
[def __mpl_metafunction_class__ [@http://www.boost.org/libs/mpl/doc/refmanual/metafunction-class.html MPL Metafunction Class]]
[def __mpl_lambda_expression__  [@http://www.boost.org/libs/mpl/doc/refmanual/lambda-expression.html MPL Lambda Expression]]

[def __lvalue__                 LValue]
[def __unspecified__            /unspecified/]

[def __support__                [link fusion.support Support]]
[def __is_sequence__            [link fusion.support.is_sequence `is_sequence`]]
[def __is_view__                [link fusion.support.is_view `is_view`]]
[def __tag_of__                 [link fusion.support.tag_of `tag_of`]]
[def __category_of__            [link fusion.support.category_of `category_of`]]
[def __deduce__                 [link fusion.support.deduce `deduce`]]
[def __deduce_sequence__        [link fusion.support.deduce_sequence `deduce_sequence`]]
[def __fusion_pair__            [link fusion.support.pair `fusion::pair`]]
[def __pair__                   [link fusion.support.pair `pair`]]
[def __fusion_make_pair__       [link fusion.support.pair `make_pair`]]

[def __iterator__               [link fusion.iterator Iterator]]
[def __iterator_concepts__      [link fusion.iterator.concepts Iterator Concepts]]
[def __forward_iterator__       [link fusion.iterator.concepts.forward_iterator Forward Iterator]]
[def __bidirectional_iterator__ [link fusion.iterator.concepts.bidirectional_iterator Bidirectional Iterator]]
[def __random_access_iterator__ [link fusion.iterator.concepts.random_access_iterator Random Access Iterator]]

[def __next__                   [link fusion.iterator.functions.next `next`]]
[def __prior__                  [link fusion.iterator.functions.prior `prior`]]
[def __advance__                [link fusion.iterator.functions.advance `advance`]]
[def __advance_c__              [link fusion.iterator.functions.advance_c `advance_c`]]
[def __distance__               [link fusion.iterator.functions.distance `distance`]]
[def __deref__                  [link fusion.iterator.functions.deref `deref`]]

[def __result_of_next__         [link fusion.iterator.metafunctions.next `result_of::next`]]
[def __result_of_prior__        [link fusion.iterator.metafunctions.prior `result_of::prior`]]
[def __result_of_equal_to__     [link fusion.iterator.metafunctions.equal_to `result_of::equal_to`]]
[def __result_of_advance__      [link fusion.iterator.metafunctions.advance `result_of::advance`]]
[def __result_of_advance_c__    [link fusion.iterator.metafunctions.advance_c `result_of::advance_c`]]
[def __result_of_distance__     [link fusion.iterator.metafunctions.distance `result_of::distance`]]
[def __result_of_deref__        [link fusion.iterator.metafunctions.deref `result_of::deref`]]
[def __result_of_value_of__     [link fusion.iterator.metafunctions.value_of `result_of::value_of`]]
[def __value_of__               [link fusion.iterator.metafunctions.value_of `value_of`]]

[def __sequence__               [link fusion.sequence Sequence]]
[def __sequence_concepts__      [link fusion.sequence.concepts Sequence Concepts]]
[def __traversal_concept__      [link fusion.sequence.concepts.traversal Sequence Traversal Concept]]
[def __associativity_concept__  [link fusion.sequence.concepts.associativity Sequence Associativity Concept]]
[def __forward_sequence__       [link fusion.sequence.concepts.forward_sequence Forward Sequence]]
[def __bidirectional_sequence__ [link fusion.sequence.concepts.bidirectional_sequence Bidirectional Sequence]]
[def __random_access_sequence__ [link fusion.sequence.concepts.random_access_sequence Random Access Sequence]]
[def __associative_sequence__   [link fusion.sequence.concepts.associative_sequence Associative Sequence]]

[def __containers__             [link fusion.container Container]]
[def __vector__                 [link fusion.container.vector `vector`]]
[def __cons__                   [link fusion.container.cons `cons`]]
[def __list__                   [link fusion.container.list `list`]]
[def __set__                    [link fusion.container.set `set`]]
[def __map__                    [link fusion.container.map `map`]]

[def __view__                   [link fusion.view View]]
[def __views__                  [link fusion.view Views]]
[def __single_view__            [link fusion.view.single_view `single_view`]]
[def __filter_view__            [link fusion.view.filter_view `filter_view`]]
[def __iterator_range__         [link fusion.view.iterator_range `iterator_range`]]
[def __joint_view__             [link fusion.view.joint_view `joint_view`]]
[def __transform_view__         [link fusion.view.transform_view `transform_view`]]
[def __reverse_view__           [link fusion.view.reverse_view `reverse_view`]]
[def __zip_view__               [link fusion.view.zip_view `zip_view`]]

[def __std_pair__               [link fusion.adapted.std__pair `std::pair`]]
[def __boost_array__            [link fusion.adapted.boost__array `boost::array`]]
[def __mpl_sequence__           [link fusion.adapted.mpl_sequence mpl sequence]]

[def __intrinsic__              [link fusion.sequence.intrinsic Intrinsic]]
[def __intrinsics__             [link fusion.sequence.intrinsic Intrinsics]]
[def __begin__                  [link fusion.sequence.intrinsic.functions.begin `begin`]]
[def __result_of_begin__        [link fusion.sequence.intrinsic.metafunctions.begin `result_of::begin`]]
[def __end__                    [link fusion.sequence.intrinsic.functions.end `end`]]
[def __result_of_end__          [link fusion.sequence.intrinsic.metafunctions.end `result_of::end`]]
[def __size__                   [link fusion.sequence.intrinsic.functions.size `size`]]
[def __result_of_size__         [link fusion.sequence.intrinsic.metafunctions.size `result_of::size`]]
[def __empty__                  [link fusion.sequence.intrinsic.functions.empty `empty`]]
[def __result_of_empty__        [link fusion.sequence.intrinsic.metafunctions.empty `result_of::empty`]]
[def __front__                  [link fusion.sequence.intrinsic.functions.front `front`]]
[def __result_of_front__        [link fusion.sequence.intrinsic.metafunctions.front `result_of::front`]]
[def __back__                   [link fusion.sequence.intrinsic.functions.back `back`]]
[def __result_of_back__         [link fusion.sequence.intrinsic.metafunctions.back `result_of::back`]]
[def __at__                     [link fusion.sequence.intrinsic.functions.at `at`]]
[def __result_of_at__           [link fusion.sequence.intrinsic.metafunctions.at `result_of::at`]]
[def __at_c__                   [link fusion.sequence.intrinsic.functions.at_c `at_c`]]
[def __result_of_at_c__         [link fusion.sequence.intrinsic.metafunctions.at_c `result_of::at_c`]]
[def __at_key__                 [link fusion.sequence.intrinsic.functions.at_key `at_key`]]
[def __result_of_at_key__       [link fusion.sequence.intrinsic.metafunctions.at_key `result_of::at_key`]]
[def __has_key__                [link fusion.sequence.intrinsic.functions.has_key `has_key`]]
[def __result_of_has_key__      [link fusion.sequence.intrinsic.metafunctions.has_key `result_of::has_key`]]
[def __value_at_key__           [link fusion.sequence.intrinsic.metafunctions.value_at_key `value_at_key`]]
[def __result_of_value_at__     [link fusion.sequence.intrinsic.metafunctions.value_at `result_of::value_at`]]
[def __result_of_value_at_c__   [link fusion.sequence.intrinsic.metafunctions.value_at_c `result_of::value_at_c`]]
[def __result_of_value_at_key__ [link fusion.sequence.intrinsic.metafunctions.value_at_key `result_of::value_at_key`]]

[def __conversion__             [link fusion.container.conversion.functions Conversion]]
[def __result_of_conversion__   [link fusion.container.conversion.metafunctions Conversion Metafunctions]]
[def __as_vector__              [link fusion.container.conversion.functions.as_vector `as_vector`]]
[def __result_of_as_vector__    [link fusion.container.conversion.metafunctions.as_vector `result_of::as_vector`]]
[def __as_list__                [link fusion.container.conversion.functions.as_list `as_list`]]
[def __result_of_as_list__      [link fusion.container.conversion.metafunctions.as_list `result_of::as_list`]]
[def __as_set__                 [link fusion.container.conversion.functions.as_set `as_set`]]