123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427 |
- [/==============================================================================
- Copyright (C) 2001-2011 Joel de Guzman
- Copyright (C) 2006 Dan Marsden
- 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 accommodate 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 accommodate 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 accommodate 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]:
- 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 {};
- }}
- And optionally from:
- namespace boost { namespace fusion
- {
- struct associative_tag {};
- struct unbounded_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_ref_wrappers__)[footnote Since C++11, the standard reference wrappers
- are also removed.].
- [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]
|