support.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)
===============================================================================/]
[section Support]

A couple of classes and metafunctions provide basic support for Fusion.

[section is_sequence]

[heading Description]

Metafunction that evaluates to `mpl::true_` if a certain type `T` is a
conforming Fusion __sequence__, `mpl::false_` otherwise. This may be
specialized to accomodate clients which provide Fusion conforming sequences.

[heading Synopsis]

    namespace traits
    {
        template <typename T>
        struct is_sequence
        {
            typedef __unspecified__ type;
        };
    }

[heading Parameters]

[table
    [[Parameter]    [Requirement]                       [Description]]
    [[`T`]          [Any type]                          [The type to query.]]
]

[heading Expression Semantics]

    typedef traits::is_sequence<T>::type c;

[*Return type]: An __mpl_boolean_constant__.

[*Semantics]: Metafunction that evaluates to `mpl::true_` if a certain type
`T` is a conforming Fusion sequence, `mpl::false_` otherwise.

[heading Header]

    #include <boost/fusion/support/is_sequence.hpp>
    #include <boost/fusion/include/is_sequence.hpp>

[heading Example]

    BOOST_MPL_ASSERT_NOT(( traits::is_sequence< std::vector<int> > ));
    BOOST_MPL_ASSERT_NOT(( is_sequence< int > ));
    BOOST_MPL_ASSERT(( traits::is_sequence<__list__<> > ));
    BOOST_MPL_ASSERT(( traits::is_sequence<__list__<int> > ));
    BOOST_MPL_ASSERT(( traits::is_sequence<__vector__<> > ));
    BOOST_MPL_ASSERT(( traits::is_sequence<__vector__<int> > ));

[endsect]

[section is_view]

[heading Description]

Metafunction that evaluates to `mpl::true_` if a certain type `T` is a
conforming Fusion __view__, `mpl::false_` otherwise. A view is a
specialized sequence that does not actually contain data. Views hold
sequences which may be other views. In general, views are held by other
views by value, while non-views are held by other views by reference. `is_view`
may be specialized to accomodate clients providing Fusion conforming views.

[heading Synopsis]

    namespace traits
    {
        template <typename T>
        struct is_view
        {
            typedef __unspecified__ type;
        };
    }

[heading Parameters]

[table
    [[Parameter]    [Requirement]                       [Description]]
    [[`T`]          [Any type]                          [The type to query.]]
]

[heading Expression Semantics]

    typedef traits::is_view<T>::type c;

[*Return type]: An __mpl_boolean_constant__.

[*Semantics]: Metafunction that evaluates to `mpl::true_` if a certain type
`T` is a conforming Fusion view, `mpl::false_` otherwise.

[heading Header]

    #include <boost/fusion/support/is_view.hpp>
    #include <boost/fusion/include/is_view.hpp>

[heading Example]

    BOOST_MPL_ASSERT_NOT(( traits::is_view<std::vector<int> > ));
    BOOST_MPL_ASSERT_NOT(( traits::is_view<int> ));

    using boost::mpl::_
    using boost::is_pointer;
    typedef __vector__<int*, char, long*, bool, double> vector_type;
    typedef __filter_view__<vector_type, is_pointer<_> > filter_view_type;
    BOOST_MPL_ASSERT(( traits::is_view<filter_view_type> ));

[endsect]

[section tag_of]

[heading Description]

All conforming Fusion sequences and iterators have an associated tag type. The
purpose of the tag is to enable __tag_dispatching__ from  __intrinsic__
functions to implementations appropriate for the type.

This metafunction may be specialized to accomodate clients providing Fusion
conforming sequences.

[heading Synopsis]

    namespace traits
    {
        template<typename Sequence>
        struct tag_of
        {
            typedef __unspecified__ type;
        };
    }

[heading Parameters]

[table
    [[Parameter]    [Requirement]                       [Description]]
    [[`T`]          [Any type]                          [The type to query.]]
]

[heading Expression Semantics]

    typedef traits::tag_of<T>::type tag;

[*Return type]: Any type.

[*Semantics]: Returns the tag type associated with `T`.

[heading Header]

    #include <boost/fusion/support/tag_of.hpp>
    #include <boost/fusion/include/tag_of.hpp>

[heading Example]

    typedef traits::tag_of<__list__<> >::type tag1;
    typedef traits::tag_of<__list__<int> >::type tag2;
    typedef traits::tag_of<__vector__<> >::type tag3;
    typedef traits::tag_of<__vector__<int> >::type tag4;

    BOOST_MPL_ASSERT((boost::is_same<tag1, tag2>));
    BOOST_MPL_ASSERT((boost::is_same<tag3, tag4>));

[endsect]

[section category_of]

[heading Description]

A metafunction that establishes the conceptual classification of a particular
__sequence__ or __iterator__ (see __iterator_concepts__ and
__sequence_concepts__).

[heading Synopsis]

    namespace traits
    {
        template <typename T>
        struct category_of
        {
            typedef __unspecified__ type;
        };
    }

[heading Parameters]

[table
    [[Parameter]    [Requirement]                       [Description]]
    [[`T`]          [Any type]                          [The type to query.]]
]

[heading Expression Semantics]

    typedef traits::category_of<T>::type category;

[*Return type]:

For Iterators, the return type is derived from one of:

        namespace boost { namespace fusion
        {
            struct incrementable_traversal_tag {};

            struct single_pass_traversal_tag
                : incrementable_traversal_tag {};

            struct forward_traversal_tag
                : single_pass_traversal_tag {};

            struct bidirectional_traversal_tag
                : forward_traversal_tag {};

            struct random_access_traversal_tag
                : bidirectional_traversal_tag {};
        }}

For Sequences, the return type is derived from one of:

        namespace boost { namespace fusion
        {
            struct incrementable_sequence_tag {};

            struct single_pass_sequence_tag
                : incrementable_sequence_tag {};

            struct forward_traversal_tag
                : single_pass_sequence_tag {};

            struct bidirectional_traversal_tag
                : forward_traversal_tag {};

            struct random_access_traversal_tag
                : bidirectional_traversal_tag {};
        }}

And optionally from:

        namespace boost { namespace fusion
        {
            struct associative_sequence_tag {};
        }}

[*Semantics]: Establishes the conceptual classification of a particular
__sequence__ or __iterator__.

[heading Header]

    #include <boost/fusion/support/category_of.hpp>
    #include <boost/fusion/include/category_of.hpp>

[heading Example]

    using boost::is_base_of;
    typedef traits::category_of<__list__<> >::type list_category;
    typedef traits::category_of<__vector__<> >::type vector_category;
    BOOST_MPL_ASSERT(( is_base_of<forward_traversal_tag, list_category> ));
    BOOST_MPL_ASSERT(( is_base_of<random_access_traversal_tag, vector_category> ));

[endsect]

[section deduce]

[heading Description]
Metafunction to apply __element_conversion__ to the full argument type.

It removes references to `const`, references to array types are kept, even
if the array is `const`. Reference wrappers are removed (see
__note_boost_ref__).

[heading Header]

    #include <boost/fusion/support/deduce.hpp>
    #include <boost/fusion/include/deduce.hpp>

[heading Synopsis]
    namespace traits
    {
        template <typename T>
        struct deduce
        {
            typedef __unspecified__ type;
        };
    }

[heading Example]
    template <typename T>
    struct holder
    {
        typename traits::deduce<T const &>::type element;

        holder(T const & a)
          : element(a)
        { }
    };

    template <typename T>
    holder<T> make_holder(T const & a)
    {
        return holder<T>(a);
    }

[heading See also]
* __deduce_sequence__

[endsect]

[section deduce_sequence]

[heading Description]
Applies __element_conversion__ to each element in a __forward_sequence__.
The resulting type is a __random_access_sequence__ that provides a converting
constructor accepting the original type as its argument.

[heading Header]

    #include <boost/fusion/support/deduce_sequence.hpp>
    #include <boost/fusion/include/deduce_sequence.hpp>

[heading Synopsis]
    namespace traits
    {
        template <class Sequence>
        struct deduce_sequence
        {
            typedef __unspecified__ type;
        };
    }

[heading Example]
    template <class Seq>
    struct holder
    {
        typename traits::deduce_sequence<Seq>::type element;

        holder(Seq const & a)
          : element(a)
        { }
    };

    template <typename T0, typename T1>
    holder< __vector__<T0 const &, T1 const &> >
    make_holder(T0 const & a0, T1 const & a1)
    {
        typedef __vector__<T0 const &, T1 const &> arg_vec_t;
        return holder<arg_vec_t>( arg_vec_t(a0,a1) );
    }

[heading See also]
* __deduce__

[endsect]

[section pair]

[heading Description]

Fusion `pair` type is a half runtime pair. A half runtime pair is similar
to a __std_pair__, but, unlike __std_pair__, the first type does not have data.
It is used as elements in __map__s, for example.

[heading Synopsis]

    template <typename First, typename Second>
    struct pair;

    namespace result_of
    {
        template <typename Pair>
        struct first;

        template <typename Pair>
        struct second;

        template <typename First, typename Second>
        struct make_pair;
    }

    template <typename First, typename Second>
    typename result_of::make_pair<First,Second>::type
    make_pair(Second const &);

[heading Template parameters]

[table
    [[Parameter]    [Description]]
    [[First]        [The first type. This is purely a type. No data is held.]]
    [[Second]       [The second type. This contains data.]]
]

[variablelist Notation
    [[`P`]          [Fusion pair type]]
    [[`p`, `p2`]    [Fusion pairs]]
    [[`F`, `S`]     [Arbitrary types]]
    [[`s`]          [Value of type `S`]]
    [[`o`]          [Output stream]]
    [[`i`]          [Input stream]]
]

[heading Expression Semantics]

[table
    [[Expression]       [Semantics]]
    [[`P::first_type`]  [The type of the first template parameter, `F`, equivalent to
                        `result_of::first<P>::type`. ]]
    [[`P::second_type`] [The type of the second template parameter, `S`, equivalent to
                        `result_of::second<P>::type`. ]]
    [[`P()`]            [Default construction.]]
    [[`P(s)`]           [Construct a pair given value for the second type, `s`.]]
    [[`P(p2)`]          [Copy constructs a pair from another pair, `p2`.]]
    [[`p.second`]       [Get the data from `p1`.]]
    [[`p = p2`]         [Assigns a pair, `p1`, from another pair, `p2`.]]
    [[make_pair<F>(s)]  [Make a pair given the first type, `F`, and a value for
                        the second type, `s`. The second type assumes the type of `s`]]
    [[`o << p`]         [Output `p` to output stream, `o`.]]
    [[`i >> p`]         [Input `p` from input stream, `i`.]]
    [[`p == p2`]        [Tests two pairs for equality.]]
    [[`p != p2`]        [Tests two pairs for inequality.]]
]

[heading Header]

    #include <boost/fusion/support/pair.hpp>
    #include <boost/fusion/include/pair.hpp>

[heading Example]

    pair<int, char> p('X');
    std::cout << p << std::endl;
    std::cout << make_pair<int>('X') << std::endl;
    assert((p == make_pair<int>('X')));

[endsect]

[endsect]