|
+Home | +Libraries | +People | +FAQ | +More | +
++ Special thanks to David Abrahams, Douglas Gregor, Hartmut Kaiser, Aleksey Gurtovoy, + Peder Holt, Daniel Wallin, Jaakko Jarvi, Jeremiah Willcock, Dan Marsden, Eric + Niebler, Joao Abecasis and Andy Little. These people are instrumental in the + design and development of Fusion. +
++ Special thanks to Ronald Garcia, the review manager and to all the people in + the boost community who participated in the review: Andreas Pokorny, Andreas + Huber, Jeff Flinn, David Abrahams, Pedro Lamarao, Larry Evans, Ryan Gallagher, + Andy Little, Gennadiy Rozental, Tobias Schwinger, Joao Abecasis, Eric Niebler, + Oleg Abrosimov, Gary Powell, Eric Friedman, Darren Cook, Martin Bonner and + Douglas Gregor. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Fusion provides a couple of adapters for other sequences such as std::pair, + MPL sequences, + and boost::array. These adapters are written using Fusion's + non-intrusive Extension mechanism. + If you wish to use these sequences with fusion, simply include the necessary + files and they will be regarded as first-class, fully conforming fusion sequences + [13] + . +
++#include <boost/fusion/adapted.hpp> +#include <boost/fusion/include/adapted.hpp> ++
[13] + Fusion sequences may also be adapted as fully conforming MPL + sequences (see Intrinsics). + That way, we can have 2-way adaptation to and from MPL + and Fusion +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ This module provides adapters for boost::array. + Including the module header makes boost::array + a fully conforming Random + Access Sequence. +
++#include <boost/fusion/adapted/array.hpp> +#include <boost/fusion/include/array.hpp> ++
+boost::array<int,3> arr = {{1,2,3}}; + +std::cout << *begin(arr) << std::endl; +std::cout << *next(begin(arr)) << std::endl; +std::cout << *advance_c<2>(begin(arr)) << std::endl; +std::cout << *prior(end(arr)) << std::endl; +std::cout << at_c<2>(arr) << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ This module provides adapters for boost::tuple. + Including the module header makes boost::tuple + a fully conforming Forward + Sequence. +
++#include <boost/fusion/adapted/boost_tuple.hpp> +#include <boost/fusion/include/boost_tuple.hpp> ++
+boost::tuple<int,std::string> example_tuple(101, "hello"); +std::cout << *boost::fusion::begin(example_tuple) << '\n'; +std::cout << *boost::fusion::next(boost::fusion::begin(example_tuple)) << '\n'; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ This module provides adapters for boost::variant. + Including the module header makes boost::variant + a fully conforming Forward + Sequence. The variant acts as a sequence of the types that can be + contained in the variant. Accessing types not currently stored int the variant + will lead to the variant being populated with a default constructed value + of that type. +
++#include <boost/fusion/adapted/variant.hpp> +#include <boost/fusion/include/variant.hpp> ++
+boost::variant<int,std::string> example_variant = 101; +std::cout << example_variant << '\n'; +*boost::fusion::find<std::string>(example_variant) = "hello"; +std::cout << example_variant << '\n'; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ This module provides adapters for MPL + sequences. Including the module header makes all MPL + sequences fully conforming fusion sequences. +
++#include <boost/fusion/adapted/mpl.hpp> +#include <boost/fusion/include/mpl.hpp> ++
+mpl::vector_c<int, 123, 456> vec_c; +fusion::vector2<int, long> v(vec_c); +std::cout << at_c<0>(v) << std::endl; +std::cout << at_c<1>(v) << std::endl; + +v = mpl::vector_c<int, 456, 789>(); +std::cout << at_c<0>(v) << std::endl; +std::cout << at_c<1>(v) << std::endl; ++
+ MPL +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ This module provides adapters for std::pair. + Including the module header makes std::pair + a fully conforming Random + Access Sequence. +
++#include <boost/fusion/adapted/std_pair.hpp> +#include <boost/fusion/include/std_pair.hpp> ++
+std::pair<int, std::string> p(123, "Hola!!!"); +std::cout << at_c<0>(p) << std::endl; +std::cout << at_c<1>(p) << std::endl; +std::cout << p << std::endl; ++
+ std::pair, + TR1 + and std::pair +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Unlike MPL, Fusion + algorithms are lazy and non sequence-type preserving. What does that mean? + It means that when you operate on a sequence through a Fusion algorithm that + returns a sequence, the sequence returned may not be of the same class as the + original. This is by design. Runtime efficiency is given a high priority. Like + MPL, and unlike + STL, + fusion algorithms are functional in nature such that algorithms are non mutating + (no side effects). However, due to the high cost of returning full sequences + such as vectors and lists, Views are returned from Fusion + algorithms instead. For example, the transform algorithm does not actually + return a transformed version of the original sequence. transform returns a transform_view. This view holds a + reference to the original sequence plus the transform function. Iteration over + the transform_view + will apply the transform function over the sequence elements on demand. This + lazy evaluation scheme allows us to chain as many algorithms + as we want without incurring a high runtime penalty. +
++ The lazy evaluation scheme where Algorithms + return Views also allows operations such + as push_back to be totally generic. In + Fusion, push_back is actually a generic algorithm + that works on all sequences. Given an input sequence s + and a value x, Fusion's push_back algorithm simply returns + a joint_view: + a view that holds a reference to the original sequence s + and the value x. Functions + that were once sequence specific and need to be implemented N times over N + different sequences are now implemented only once. That is to say that Fusion + sequences are cheaply extensible. However, an important caveat is that the + result of a sequence extending operation like push_back does not retain the properties + of the original sequence such as associativity of set(s). To regain the original sequence, + Conversion functions + are provided. You may use one of the Conversion + functions to convert back to the original sequence type. +
++#include <boost/fusion/algorithm.hpp> +#include <boost/fusion/include/algorithm.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The iteration algorithms provide the fundamental algorithms for traversing + a sequence repeatedly applying an operation to its elements. +
++#include <boost/fusion/algorithm/iteration.hpp> +#include <boost/fusion/include/iteration.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ For a sequence Seq, initial + state, and binary function object or function pointer f, + accumulate repeatedly applies binary f + to each element of Seq + and the previous state. +
++template< + typename Sequence, + typename State, + typename F + > +typename result_of::accumulate<Sequence, State, F>::type accumulate( + Sequence& seq, State const& initial_state, F const& f); ++
Table 1.34. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence, f(eN + ....f(e2,f(e1,initial_state))) must be a valid expression for + each element e1 + to eN in seq + + |
+
+ + Operation's argument + + |
+
|
+ + initial_state + + |
+
+ + Any type + + |
+
+ + Initial state + + |
+
|
+ + f + + |
+
+ + boost::result_of<F(E,S)>::type is the return type of f(e,s) + for each element e + of type E in seq, and current state s of type S + + |
+
+ + Operation's argument + + |
+
+accumulate(seq, initial_state, f); ++
+ Return type: Any type +
++ Semantics: Equivalent to f(eN ....f(e2,f(e1,initial_state))) + where e1 ...eN are the elements of seq. +
++ Linear, exactly result_of::size<Sequence>::value applications of f. +
++#include <boost/fusion/algorithm/iteration/accumulate.hpp> +#include <boost/fusion/include/accumulate.hpp> ++
+struct make_string +{ + typedef std::string result_type; + + template<typename T> + std::string operator()(const T& t, const std::string& str) const + { + return str + boost::lexical_cast<std::string>(t); + } +}; +... +const vector<int,int> vec(1,2); +assert(accumulate(vec,std::string(""), make_string()) == "12"); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ For a sequence Seq, initial + state, and binary function object or function pointer f, + fold repeatedly applies binary f + to each element of Seq + and the previous state. +
++template< + typename Sequence, + typename State, + typename F + > +typename result_of::fold<Sequence, State, F>::type fold( + Sequence& seq, State const& initial_state, F const& f); ++
Table 1.33. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence,f(e,s) must be a valid expression for + each element e + in seq, and current + state s + + |
+
+ + Operation's argument + + |
+
|
+ + initial_state + + |
+
+ + Any type + + |
+
+ + Initial state + + |
+
|
+ + f + + |
+
+ + boost::result_of<F(E,S)>::type is the return type of f(e,s) + for each element e + of type E in seq, and current state s of type S + + |
+
+ + Operation's argument + + |
+
+fold(seq, initial_state, f); ++
+ Return type: Any type +
++ Semantics: Equivalent to f(eN ....f(e2,f(e1,initial_state))) + where e1 ...eN are the elements of seq. +
++ Linear, exactly result_of::size<Sequence>::value applications of f. +
++#include <boost/fusion/algorithm/iteration/fold.hpp> +#include <boost/fusion/include/fold.hpp> ++
+struct make_string +{ + typedef std::string result_type; + + template<typename T> + std::string operator()(const T& t, const std::string& str) const + { + return str + boost::lexical_cast<std::string>(t); + } +}; +... +const vector<int,int> vec(1,2); +assert(fold(vec,std::string(""), make_string()) == "12"); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Applies a unary function object to each element of a sequence. +
++template< + typename Sequence, + typename F + > +typename result_of::for_each<Sequence, F>::type for_each( + Sequence& seq, F const& f); ++
Table 1.35. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence, f(e) must be a valid expression for + each element e + in seq + + |
+
+ + Operation's argument + + |
+
|
+ + f + + |
+
+ + A unary Regular + Callable Object + + |
+
+ + Operation's argument + + |
+
+for_each(seq, f); ++
+ Return type: void +
++ Semantics: Calls f(e) for each element e + in seq. +
++ Linear, exactly result_of::size<Sequence>::value applications of f. +
++#include <boost/fusion/algorithm/iteration/for_each.hpp> +#include <boost/fusion/include/for_each.hpp> ++
+struct increment +{ + template<typename T> + void operator()(T& t) const + { + ++t; + } +}; +... +vector<int,int> vec(1,2); +for_each(vec, increment()); +assert(vec == make_vector(2,3)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of accumulate. +
++template< + typename Sequence, + typename State, + typename F> +struct accumulate +{ + typedef unspecified type; +}; ++
Table 1.37. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + The sequence to iterate + + |
+
|
+ + State + + |
+
+ + Any type + + |
+
+ + The initial state for the first application of F + + |
+
|
+ + F + + |
+
+ + boost::result_of<F(E,S)>::type is the return type of f(e,s) + for each element e + of type E in seq, and current state s of type S + + |
+
+ + The operation to be applied on forward traversal + + |
+
+result_of::accumulate<Sequence, State, F>::type ++
+ Return type: Any type +
++ Semantics: Returns the result of applying + accumulate to a sequence + of type Sequence, with + an initial state of type State + and binary function object or function pointer of type F. +
++ Linear, exactly result_of::size<Sequence>::value applications of F. +
++#include <boost/fusion/algorithm/iteration/accumulate.hpp> +#include <boost/fusion/include/accumulate.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of fold. +
++template< + typename Sequence, + typename State, + typename F> +struct fold +{ + typedef unspecified type; +}; ++
Table 1.36. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + The sequence to iterate + + |
+
|
+ + State + + |
+
+ + Any type + + |
+
+ + The initial state for the first application of F + + |
+
|
+ + F + + |
+
+ + boost::result_of<F(E,S)>::type is the return type of f(e,s) + for each element e + of type E in seq, and current state s of type S + + |
+
+ + The operation to be applied on forward traversal + + |
+
+result_of::fold<Sequence, State, F>::type ++
+ Return type: Any type +
++ Semantics: Returns the result of applying + fold to a sequence of + type Sequence, with an + initial state of type State + and binary function object or function pointer of type F. +
++ Linear, exactly result_of::size<Sequence>::value applications of F. +
++#include <boost/fusion/algorithm/iteration/fold.hpp> +#include <boost/fusion/include/fold.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A metafunction returning the result type of applying for_each to a sequence. The + return type of for_each is always void. +
++template< + typename Sequence, + typename F +> +struct for_each +{ + typedef void type; +}; ++
Table 1.38. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + F + + |
+
+ + Any type + + |
+
+ + Operation's argument + + |
+
+result_of::for_each<Sequence, F>::type ++
+ Return type: void. +
++ Semantics: Returns the return type of + for_each for a sequence of type + Sequence and a unary + function object F. The + return type is always void. +
++ Constant. +
++#include <boost/fusion/algorithm/iteration/for_each.hpp> +#include <boost/fusion/include/for_each.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The query algorithms provide support for searching and analyzing sequences. +
++#include <boost/fusion/algorithm/query.hpp> +#include <boost/fusion/include/query.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ For a sequence seq and + unary function object f, + all returns true if + f returns true for every + element of seq. +
++template< + typename Sequence, + typename F + > +typename result_of::all<Sequence,F>::type all( + Sequence const& seq, F f); ++
Table 1.40. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence, f(e) is a valid expression, convertible + to bool, for every + element e in seq + + |
+
+ + The sequence to search + + |
+
|
+ + f + + |
+
+ + A unary function object + + |
+
+ + The search predicate + + |
+
+all(seq, f); ++
+ Return type: bool +
++ Semantics: Returns true if and only + if f(e) + evaluates to true for every + element e in seq. +
++ Linear. At most result_of::size<Sequence>::value comparisons. +
++#include <boost/fusion/algorithm/query/all.hpp> +#include <boost/fusion/include/all.hpp> ++
+struct odd +{ + template<typename T> + bool operator()(T t) const + { + return t % 2; + } +}; +... +assert(all(make_vector(1,3), odd())); +assert(!all(make_vector(1,2), odd())); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ For a sequence seq and + unary function object f, + any returns true if + f returns true for at + least one element of seq. +
++template< + typename Sequence, + typename F + > +typename result_of::any<Sequence,F>::type any( + Sequence const& seq, F f); ++
Table 1.39. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence, f(e) must be a valid expression, convertible + to bool, for each + element e in seq + + |
+
+ + The sequence to search + + |
+
|
+ + f + + |
+
+ + A unary function object + + |
+
+ + The search predicate + + |
+
+any(seq, f); ++
+ Return type: bool +
++ Semantics: Returns true if and only + if f(e) + evaluates to true for some + element e in seq. +
++ Linear. At most result_of::size<Sequence>::value comparisons. +
++#include <boost/fusion/algorithm/query/any.hpp> +#include <boost/fusion/include/any.hpp> ++
+struct odd +{ + template<typename T> + bool operator()(T t) const + { + return t % 2; + } +}; +... +assert(any(make_vector(1,2), odd())); +assert(!any(make_vector(2,4), odd())); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the number of elements of a given type within a sequence. +
++template< + typename Sequence, + typename T + > +typename result_of::count<Sequence, T>::type count( + Sequence const& seq, T const& t); ++
Table 1.44. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence, e == t + must be a valid expression, convertible to bool, + for each element e + in seq + + |
+
+ + The sequence to search + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + The type to count + + |
+
+count(seq, t); ++
+ Return type: int +
++ Semantics: Returns the number of elements + of type T and equal to + t in seq. +
++ Linear. At most result_of::size<Sequence>::value comparisons. +
++#include <boost/fusion/algorithm/query/count.hpp> +#include <boost/fusion/include/count.hpp> ++
+const vector<double,int,int> vec(1.0,2,3); +assert(count(vec,2) == 1); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the number of elements within a sequence with a type for which + a given unary function object evaluates to true. +
++template< + typename Sequence, + typename F + > +typename result_of::count_if<Sequence, F>::type count_if( + Sequence const& seq, F f); ++
Table 1.45. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence, f(e) is a valid expression, convertible + to bool, for each + element e in seq + + |
+
+ + The sequence to search + + |
+
|
+ + f + + |
+
+ + A unary function object + + |
+
+ + The search predicate + + |
+
+count_if(seq, f) ++
+ Return type: int +
++ Semantics: Returns the number of elements + in seq where f evaluates to true. +
++ Linear. At most result_of::size<Sequence>::value comparisons. +
++#include <boost/fusion/algorithm/query/count_if.hpp> +#include <boost/fusion/include/count_if.hpp> ++
+const vector<int,int,int> vec(1,2,3); +assert(count_if(vec,odd()) == 2); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Finds the first element of a given type within a sequence. +
++template< + typename T, + typename Sequence + > +unspecified find(Sequence const& seq); + +template< + typename T, + typename Sequence + > +unspecified find(Sequence& seq); ++
Table 1.42. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + The sequence to search + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + The type to search for + + |
+
+find<T>(seq) ++
+ Return type: A model of the same iterator + category as the iterators of seq. +
++ Semantics: Returns an iterator to the + first element of seq + of type T, or end(seq) if there is no such element. Equivalent + to find_if<boost::is_same<_, T> >(seq) +
++ Linear. At most result_of::size<Sequence>::value comparisons. +
++#include <boost/fusion/algorithm/query/find.hpp> +#include <boost/fusion/include/find.hpp> ++
+const vector<char,int> vec('a','0'); +assert(*find<int>(vec) == '0'); +assert(find<double>(vec) == end(vec)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Finds the first element within a sequence with a type for which a given + MPL + Lambda Expression evaluates to boost::mpl::true_. +
++template< + typename F, + typename Sequence + > +unspecified find_if(Sequence const& seq); + +template< + typename F, + typename Sequence + > +unspecified find_if(Sequence& seq); ++
Table 1.43. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + The sequence to search + + |
+
|
+ + F + + |
+
+ + A unary MPL + Lambda Expression + + |
+
+ + The search predicate + + |
+
+find_if<F>(seq) ++
+ Return type: An iterator of the same + iterator category as the iterators of seq. +
++ Semantics: Returns the first element + of seq for which MPL + Lambda Expression F + evaluates to boost::mpl::true_, or end(seq) + if there is no such element. +
++ Linear. At most result_of::size<Sequence>::value comparisons. +
++ /algorithm/query/find_if.hpp> +
++const vector<double,int> vec(1.0,2); +assert(*find_if<is_integral<mpl::_> >(vec) == 2); +assert(find_if<is_class<mpl::_> >(vec) == end(vec)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ For a sequence seq and + unary function object f, + none returns true if + f returns false for every + element of seq. +
++template< + typename Sequence, + typename F + > +typename result_of::none<Sequence,F>::type none( + Sequence const& seq, F f); ++
Table 1.41. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence, f(e) is a valid expression, convertible + to bool, for every + element e in seq + + |
+
+ + The sequence to search + + |
+
|
+ + f + + |
+
+ + A unary function object + + |
+
+ + The search predicate + + |
+
+none(seq, f); ++
+ Return type: bool +
++ Semantics: Returns true if and only + if f(e) + evaluates to false for every + element e in seq. Result equivalent to !any(seq, f). +
++ Linear. At most result_of::size<Sequence>::value comparisons. +
++#include <boost/fusion/algorithm/query/none.hpp> +#include <boost/fusion/include/none.hpp> ++
+struct odd +{ + template<typename T> + bool operator()(T t) const + { + return t % 2; + } +}; +... +assert(none(make_vector(2,4), odd())); +assert(!none(make_vector(1,2), odd())); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A metafunction returning the result type of all. +
++template< + typename Sequence, + typename F + > +struct all +{ + typedef bool type; +}; ++
Table 1.47. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + F + + |
+
+ + A model of unary Polymorphic + Function Object + + |
+
+ + Operation's argument + + |
+
+result_of::all<Sequence, F>::type ++
+ Return type: bool. +
++ Semantics: Returns the return type of + all + given a sequence of type Sequence + and a unary Polymorphic + Function Object of type F. + The return type is always bool. +
++ Constant. +
++#include <boost/fusion/algorithm/query/all.hpp> +#include <boost/fusion/include/all.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A metafunction returning the result type of any. +
++template< + typename Sequence, + typename F + > +struct any +{ + typedef bool type; +}; ++
Table 1.46. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + F + + |
+
+ + A model of unary Polymorphic + Function Object + + |
+
+ + Operation's argument + + |
+
+result_of::any<Sequence, F>::type ++
+ Return type: bool. +
++ Semantics: Returns the return type of + any + given a sequence of type Sequence + and a unary Polymorphic + Function Object of type F. + The return type is always bool. +
++ Constant. +
++#include <boost/fusion/algorithm/query/any.hpp> +#include <boost/fusion/include/any.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A metafunction that returns the result type of count + given the sequence and search types. +
++template< + typename Sequence, + typename T + > +struct count +{ + typedef int type; +}; ++
Table 1.51. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + heading Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + Operation's argument + + |
+
+result_of::count<T>::type ++
+ Return type: int. +
++ Semantics: Returns the return type of + count. The return type is always + int. +
++ Constant. +
++#include <boost/fusion/algorithm/query/count.hpp> +#include <boost/fusion/include/count.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A metafunction that returns the result type of count_if + given the sequence and predicate types. +
++template< + typename Sequence, + typename Pred + > +struct count_if +{ + typedef int type; +}; ++
Table 1.52. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + Pred + + |
+
+ + A unary function object + + |
+
+ + Operation's argument + + |
+
+result_of::count_if<Sequence, Pred>::type ++
+ Return type: int. +
++ Semantics: Returns the return type of + count_if. The return type is + always int. +
++ Constant. +
++#include <boost/fusion/algorithm/query/count_if.hpp> +#include <boost/fusion/include/count_if.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of find, + given the sequence and search types. +
++template< + typename Sequence, + typename T + > +struct find +{ + typedef unspecified type; +}; ++
Table 1.49. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + Model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + Operation's argument + + |
+
+result_of::find<Sequence, T>::type ++
+ Return type: A model of the same iterator + category as the iterators of Sequence. +
++ Semantics: Returns an iterator to the + first element of type T + in Sequence, or result_of::end<Sequence>::type + if there is no such element. +
++ Linear, at most result_of::size<Sequence>::value comparisons. +
++#include <boost/fusion/algorithm/query/find.hpp> +#include <boost/fusion/include/find.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of find_if + given the sequence and predicate types. +
++template< + typename Sequence, + typename Pred + > +struct find_if +{ + typedef unspecified type; +}; ++
Table 1.50. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + Pred + + |
+
+ + A model of MPL + Lambda Expression + + |
+
+ + Operation's arguments + + |
+
+result_of::find_if<Sequence, Pred>::type ++
+ Return type: A model of the same iterator + category as the iterators of Sequence. +
++ Semantics: Returns an iterator to the + first element in Sequence + for which Pred evaluates + to true. Returns result_of::end<Sequence>::type if there is no such element. +
++ Linear. At most result_of::size<Sequence>::value comparisons. +
++#include <boost/fusion/algorithm/query/find_if.hpp> +#include <boost/fusion/include/find_if.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A metafunction returning the result type of none. +
++template< + typename Sequence, + typename F + > +struct none +{ + typedef bool type; +}; ++
Table 1.48. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + F + + |
+
+ + A model of unary Polymorphic + Function Object + + |
+
+ + Operation's argument + + |
+
+result_of::none<Sequence, F>::type ++
+ Return type: bool. +
++ Semantics: Returns the return type of + none + given a sequence of type Sequence + and a unary Polymorphic + Function Object of type F. + The return type is always bool. +
++ Constant. +
++#include <boost/fusion/algorithm/query/none.hpp> +#include <boost/fusion/include/none.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The transformation algorithms create new sequences out of existing sequences + by performing some sort of transformation. In reality the new sequences are + views onto the data in the original sequences. +
+![[Note]](../../../../../../doc/html/images/note.png) |
+Note | +
|---|---|
+ As the transformation algorithms return views onto their input arguments, + it is important that the lifetime of the input arguments is greater than + the period during which you wish to use the results. + | |
+#include <boost/fusion/algorithm/transformation.hpp> +#include <boost/fusion/include/transformation.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ clear returns an empty sequence. +
++template< + typename Sequence + > +typename result_of::clear<Sequence const>::type clear(Sequence const& seq); ++
Table 1.62. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
+clear(seq); ++
+ Return type: A model of Forward + Sequence. +
++ Expression Semantics: Returns a sequence + with no elements. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/clear.hpp> +#include <boost/fusion/include/clear.hpp> ++
+assert(clear(make_vector(1,2,3)) == make_vector()); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a new sequence, containing all the elements of the original except + those at a specified iterator, or between two iterators. +
++template< + typename Sequence, + typename First + > +typename result_of::erase<Sequence const, First>::type erase( + Sequence const& seq, First const& it1); + +template< + typename Sequence, + typename First, + typename Last + > +typename result_of::erase<Sequence const, First, Last>::type erase( + Sequence const& seq, First const& it1, Last const& it2); ++
Table 1.63. Parameters
+|
+ + Parameters + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + it1 + + |
+
+ + A model of Forward + Iterator + + |
+
+ + Iterator into seq + + |
+
|
+ + it2 + + |
+
+ + A model of Forward + Iterator + + |
+
+ + Iterator into seq + after it1 + + |
+
+erase(seq, pos); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, containing + all the elements of seq + except the element at pos. +
++erase(seq, first, last); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, with + all the elements of seq, + in their original order, except those in the range [first,last). +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/erase.hpp> +#include <boost/fusion/include/erase.hpp> ++
+const vector<int, double, char> vec(1, 2.0, 'c'); +assert(erase(vec, next(begin(vec))) == make_vector(1, 'c')); +assert(erase(vec, next(begin(vec)), end(vec)) == make_vector(1)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ For an Associative + Sequence seq, + returns a Forward + Sequence containing all the elements of the original except those + with a given key. +
++template< + typename Key, + typename Sequence + > +typename result_of::erase_key<Sequence const, Key>::type erase_key(Sequence const& seq); ++
Table 1.64. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Associative + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + Key + + |
+
+ + Any type + + |
+
+ + Key to erase + + |
+
+erase_key<Key>(seq); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, containing + all the elements of seq, + except those with key Key. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/erase_key.hpp> +#include <boost/fusion/include/erase_key.hpp> ++
+assert(erase_key<int>(make_map<int, long>('a', 'b')) == make_map<long>('b')); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ For a given sequence, filter returns a new sequences containing only + the elements of a specified type. +
++template< + typename T, + typename Sequence + > +typename result_of::filter<Sequence const, T>::type filter(Sequence const& seq); ++
Table 1.53. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + The type to retain + + |
+
+filter<T>(seq); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence containing + all the elements of seq + of type T. Equivalent + to filter_if<boost::same_type<_, T> >(seq). +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/filter.hpp> +#include <boost/fusion/include/filter.hpp> ++
+const vector<int,int,long,long> vec(1,2,3,4); +assert(filter<int>(vec) == make_vector(1,2)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ For a given sequence, filter_if returns a new sequences + containing only the elements with types for which a given MPL + Lambda Expression evaluates to boost::mpl::true_. +
++template< + typename Pred, + typename Sequence + > +typename result_of::filter_if<Sequence const, Pred>::type filter_if(Sequence const& seq); ++
Table 1.54. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + Pred + + |
+
+ + A unary MPL + Lambda Expression + + |
+
+ + The predicate to filter by + + |
+
+filter_if<Pred>(seq); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence containing + all the elements of seq + with types for which Pred + evaluates to boost::mpl::true_. The order of the retained elements + is the same as in the original sequence. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/filter_if.hpp> +#include <boost/fusion/include/filter_if.hpp> ++
+const vector<int,int,double,double> vec(1,2,3.0,4.0); +assert(filter_if<is_integral<mpl::_> >(vec) == make_vector(1,2)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a new sequence with all the elements of the original, an a new + element inserted the position described by a given iterator. +
++template< + typename Sequence, + typename Pos, + typename T + > +unspecified insert(Sequence const& seq, Pos const& pos, T const& t); ++
Table 1.65. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + pos + + |
+
+ + A model of Forward + Iterator + + |
+
+ + The position to insert at + + |
+
|
+ + t + + |
+
+ + Any type + + |
+
+ + The value to insert + + |
+
+insert(seq, p, t); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, containing + all the elements of seq, + in their original order, and a new element with the type and value of + t inserted at iterator + pos. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/insert.hpp> +#include <boost/fusion/include/insert.hpp> ++
+const vector<int,int> vec(1,2); +assert(insert(vec, next(begin(vec)), 3) == make_vector(1,3,2)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a new sequence with another sequence inserted at a specified + iterator. +
++template< + typename Sequence, + typename Pos, + typename Range + > +typename result_of::insert_range<Sequence const, Pos, Range>::type insert_range( + Sequence const& seq, Pos const& pos, Range const& range); ++
Table 1.66. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + pos + + |
+
+ + A model of Forward + Iterator + + |
+
+ + The position to insert at + + |
+
|
+ + range + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Range to insert + + |
+
+insert(seq, pos, range); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, containing + all the elements of seq, + and the elements of range + inserted at iterator pos. + All elements retaining their ordering from the orignal sequences. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/insert_range.hpp> +#include <boost/fusion/include/insert_range.hpp> ++
+const vector<int,int> vec(1,2); +assert(insert_range(vec, next(begin(vec)), make_vector(3,4)) == make_vector(1,3,4,2)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Takes 2 sequences and returns a sequence containing the elements of the + first followed by the elements of the second. +
++template< + typename LhSequence, + typename RhSequence> +typename result_of::join<LhSequence, RhSequence>::type join(LhSequence const& lhs, RhSequence const& rhs); ++
Table 1.67. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + lhs + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + rhs + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
+join(lhs, rhs); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence containing + all the elements of lhs + followed by all the elements of rhs. + The order of th elements is preserved. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/join.hpp> +#include <boost/fusion/include/join.hpp> ++
+vector<int,char> v1(1, 'a'); +vector<int,char> v2(2, 'b'); +assert(join(v1, v2) == make_vector(1,'a',2,'b')); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a new sequence, with the last element of the original removed. +
++template< + typename Sequence + > +typename result_of::pop_back<Sequence const>::type pop_back(Sequence const& seq); ++
Table 1.69. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
+pop_back(seq); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence containing + all the elements of seq, + except the last element. The elements in the new sequence are in the + same order as they were in seq. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/pop_back.hpp> +#include <boost/fusion/include/pop_back.hpp> ++
+assert(___pop_back__(make_vector(1,2,3)) == make_vector(1,2)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a new sequence, with the first element of the original removed. +
++template< + typename Sequence + > +typename result_of::pop_front<Sequence const>::type pop_front(Sequence const& seq); ++
Table 1.70. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
+pop_front(seq); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence containing + all the elements of seq, + except the first element. The elements in the new sequence are in the + same order as they were in seq. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/pop_front.hpp> +#include <boost/fusion/include/pop_front.hpp> ++
+assert(pop_front(make_vector(1,2,3)) == make_vector(2,3)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a new sequence with an element added at the end. +
++template< + typename Sequence, + typename T + > +typename result_of::push_back<Sequence, T>::type push_back( + Sequence const& seq, T const& t); ++
Table 1.71. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + t + + |
+
+ + Any type + + |
+
+ + The value to add to the end + + |
+
+push_back(seq, t); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, containing + all the elements of seq, + and new element t appended + to the end. The elements are in the same order as they were in seq. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/push_back.hpp> +#include <boost/fusion/include/push_back.hpp> ++
+assert(push_back(make_vector(1,2,3),4) == make_vector(1,2,3,4)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a new sequence with an element added at the beginning. +
++template< + typename Sequence, + typename T + > +typename result_of::push_front<Sequence, T>::type push_front( + Sequence const& seq, T const& t); ++
Table 1.72. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + t + + |
+
+ + Any type + + |
+
+ + The value to add to the beginning + + |
+
+push_back(seq, t); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, containing + all the elements of seq, + and new element t appended + to the beginning. The elements are in the same order as they were in + seq. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/push_front.hpp> +#include <boost/fusion/include/push_front.hpp> ++
+assert(push_front(make_vector(1,2,3),0) == make_vector(0,1,2,3)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a new sequence, with all the elements of the original sequence, + except those of a given type. +
++template< + typename T, + typename Sequence + > +typename result_of::remove<Sequence const, T>::type replace(Sequence const& seq); ++
Table 1.59. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + Type to remove + + |
+
+remove<T>(seq); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, containing + all the elements of seq, + in their original order, except those of type T. + Equivalent to remove_if<boost::is_same<_,T> >(seq). +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/remove.hpp> +#include <boost/fusion/include/remove.hpp> ++
+const vector<int,double> vec(1,2.0); +assert(remove<double>(vec) == make_vector(1)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a new sequence, containing all the elements of the original except + those where a given unary function object evaluates to true. +
++template< + typename Pred, + typename Sequence + > +typename result_of::remove_if<Sequence const, Pred>::type remove_if(Sequence const& seq); ++
Table 1.60. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + Pred + + |
+
+ + A model of unary MPL + Lambda Expression + + |
+
+ + Removal predicate + + |
+
+remove_if<Pred>(seq); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, containing + all the elements of seq, + in their original order, except those elements with types for which + Pred evaluates to boost::mpl::true_. Equivalent to filter<boost::mpl::not_<Pred> + >(seq). +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/remove_if.hpp> +#include <boost/fusion/include/remove_if.hpp> ++
+const vector<int,double> vec(1,2.0); +assert(remove_if<is_floating_point<mpl::_> >(vec) == make_vector(1)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Replaces each value within a sequence of a given type and value with + a new value. +
++template< + typename Sequence, + typename T + > +typename result_of::replace<Sequence const, T>::type replace( + Sequence const& seq, T const& old_value, T const& new_value); ++
Table 1.57. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence, e == old_value + is a valid expression, convertible to bool, + for each element e + in seq with type + convertible to T + + |
+
+ + Operation's argument + + |
+
|
+ + old_value + + |
+
+ + Any type + + |
+
+ + Value to replace + + |
+
|
+ + new_value + + |
+
+ + Any type + + |
+
+ + Replacement value + + |
+
+replace(seq, old_value, new_value); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence with + all the values of seq + with new_value assigned + to elements with the same type and equal to old_value. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/replace.hpp> +#include <boost/fusion/include/replace.hpp> ++
+assert(replace(make_vector(1,2), 2, 3) == make_vector(1,3)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Replaces each element of a given sequence for which an unary function + object evaluates to true + replaced with a new value. +
++template< + typename Sequence, + typename F, + typename T> +typename result_of::replace_if<Sequence const, F, T>::type replace_if( + Sequence const& seq, F f, T const& new_value); ++
Table 1.58. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + f + + |
+
+ + A function object for which f(e) is a valid expression, convertible + to bool, for each + element e in seq + + |
+
+ + Operation's argument + + |
+
|
+ + new_value + + |
+
+ + Any type + + |
+
+ + Replacement value + + |
+
+replace_if(seq, f, new_value); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence with + all the elements of seq, + with new_value assigned + to each element for which f + evaluates to true. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/replace_if.hpp> +#include <boost/fusion/include/replace_if.hpp> ++
+struct odd +{ + template<typename T> + bool operator()(T t) const + { + return t % 2; + } +}; +... +assert(replace_if(make_vector(1,2), odd(), 3) == make_vector(3,2)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a new sequence with the elements of the original in reverse order. +
++template< + typename Sequence + > +typename result_of::reverse<Sequence const>::type reverse(Sequence const& seq); ++
Table 1.61. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Bidirectional + Sequence + + |
+
+ + Operation's argument + + |
+
+reverse(seq); ++
+ Return type: A model of Bidirectional + Sequence. +
++ Semantics: Returns a new sequence containing + all the elements of seq + in reverse order. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/reverse.hpp> +#include <boost/fusion/include/reverse.hpp> ++
+assert(reverse(make_vector(1,2,3)) == make_vector(3,2,1)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ For a sequence seq and + function object or function pointer f, + transform returns a new + sequence with elements created by applying f(e) to each element of e + of seq. +
++template< + typename Sequence, + typename F + > +typename result_of::transform<Sequence const, F>::type transform( + Sequence const& seq, F f); ++
Table 1.55. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + f + + |
+
+ + f(e) + is a valid expression for each element e + of seq. boost::result_of<F(E)>::type is the return type of f when called with a value of + each element type E. + + |
+
+ + Transformation function + + |
+
+transform(seq, f); ++
+ Return type: A model of Forward + Sequence +
++ Semantics: Returns a new sequence, containing + the return values of f(e) for each element e + within seq. +
++template< + typename Sequence1, + typename Sequence2, + typename F + > +typename result_of::transform<Sequence1 const, Sequence2 const, F>::type transform( + Sequence1 const& seq1, Sequence2 const& seq2, F f); ++
Table 1.56. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq1 + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + seq2 + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + f + + |
+
+ + f(e1,e2) + is a valid expression for each pair of elements e1 + of seq1 and e2 of seq2. + boost::result_of<F(E1,E2)>::type is the return type of f when called with elements of + type E1 and E2 + + |
+
+ + Transformation function + + |
+
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, containing + the return values of f(e1, e2) for each pair of elements e1 and e2 + within seq1 and seq2 respectively. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/transform.hpp> +#include <boost/fusion/include/transform.hpp> ++
+struct triple +{ + typedef int result_type; + + int operator()(int t) const + { + return t * 3; + }; +}; +... +assert(transform(make_vector(1,2,3), triple()) == make_vector(3,6,9)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Zips sequences together to form a single sequence, whos members are tuples + of the members of the component sequences. +
++template< + typename Sequence1, + typename Sequence2, + ... + typename SequenceN + > +typename result_of::zip<Sequence1, Sequence2, ... SequenceN>::type +zip(Sequence1 const& seq1, Sequence2 const& seq2, ... SequenceN const& seqN); ++
Table 1.68. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq1 to seqN + + |
+
+ + Each sequence is a model of Forward + Sequence. + + |
+
+ + Operation's argument + + |
+
+zip(seq1, seq2, ... seqN); ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence containing + tuples of elements from sequences seq1 + to seqN. For example, + applying zip to tuples (1, 2, 3) + and ('a', 'b', + 'c') + would return ((1, 'a'),(2, 'b'),(3, + 'c')) +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/zip.hpp> +#include <boost/fusion/include/zip.hpp> ++
+vector<int,char> v1(1, 'a'); +vector<int,char> v2(2, 'b'); +assert(zip(v1, v2) == make_vector(make_vector(1, 2),make_vector('a', 'b')); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of clear, given the input sequence + type. +
++template< + typename Sequence + > +struct clear +{ + typedef unspecified type; +}; ++
Table 1.82. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + Any type + + |
+
+ + Operation's argument + + |
+
+result_of::clear<Sequence>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns an empty sequence. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/clear.hpp> +#include <boost/fusion/include/clear.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of erase, given the input sequence + and range delimiting iterator types. +
++template< + typename Sequence, + typename It1, + typename It2 = unspecified> +struct erase +{ + typedef unspecified type; +}; ++
Table 1.83. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + It1 + + |
+
+ + A model of Forward + Iterator + + |
+
+ + Operation's argument + + |
+
|
+ + It2 + + |
+
+ + A model of Forward + Iterator + + |
+
+ + Operation's argument + + |
+
+result_of::erase<Sequence, It1>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence with + the element at It1 removed. +
++result_of::erase<Sequence, It1, It2>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence with + the elements between It1 + and It2 removed. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/erase.hpp> +#include <boost/fusion/include/erase.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of erase_key, given the sequence + and key types. +
++template< + typename Sequence, + typename Key + > +struct erase_key +{ + typedef unspecified type; +}; ++
Table 1.84. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Associative + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + Key + + |
+
+ + Any type + + |
+
+ + Key type + + |
+
+result_of::erase_key<Sequence, Key>::type ++
+ Return type: A model of Associative + Sequence. +
++ Semantics: Returns a sequence with the + elements of Sequence, + except those with key Key. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/erase_key.hpp> +#include <boost/fusion/include/erase_key.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of filter given the sequence type + and type to retain. +
++template< + typename Sequence, + typename T + > +struct filter +{ + typedef unspecified type; +}; ++
Table 1.73. Parameter
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + Type to retain + + |
+
+result_of::filter<Sequence, T>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence containing + the elements of Sequence + that are of type T. Equivalent + to result_of::filter_if<Sequence, + boost::is_same<mpl::_, T> >::type. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/filter.hpp> +#include <boost/fusion/include/filter.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of filter_if given the sequence + and unary MPL + Lambda Expression predicate type. +
++template< + typename Sequence, + typename Pred + > +struct filter_if +{ + typedef unspecified type; +}; ++
Table 1.74. Parameter
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + Pred + + |
+
+ + A unary MPL + Lambda Expression + + |
+
+ + Type to retain + + |
+
+result_of::filter_if<Sequence, Pred>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence containing + the elements of Sequence + for which Pred evaluates + to boost::mpl::true_. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/filter_if.hpp> +#include <boost/fusion/include/filter_if.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of insert, given the sequence, + position iterator and insertion types. +
++template< + typename Sequence, + typename Position, + typename T + > +struct insert +{ + typedef unspecified type; +}; ++
Table 1.85. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + Position + + |
+
+ + A model of Forward + Iterator + + |
+
+ + Operation's argument + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + Operation's argument + + |
+
+result_of::insert<Sequence, Position, T>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence with an + element of type T inserted + at position Position + in Sequence. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/insert.hpp> +#include <boost/fusion/include/insert.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of insert_range, given the input + sequence, position iterator and insertion range types. +
++template< + typename Sequence, + typename Position, + typename Range + > +struct insert_range +{ + typedef unspecified type; +}; ++
Table 1.86. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + Position + + |
+
+ + A model of Forward + Iterator + + |
+
+ + Operation's argument + + |
+
|
+ + Range + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
+result_of::insert_range<Sequence, Position, Range>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence with the + elements of Range inserted + at position Position + into Sequence. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/insert_range.hpp> +#include <boost/fusion/include/insert_range.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result of joining 2 sequences, given the sequence types. +
++template< + typename LhSequence, + typename RhSequence + > +struct join +{ + typedef unspecified type; +}; ++
+result_of::join<LhSequence, RhSequence>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence containing + the elements of LhSequence + followed by the elements of RhSequence. + The order of the elements in the 2 sequences is preserved. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/join.hpp> +#include <boost/fusion/include/join.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of pop_back, given the input sequence + type. +
++template< + typename Sequence + > +struct pop_back +{ + typedef unspecified type; +}; ++
Table 1.87. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
+result_of::pop_back<Sequence>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence with all + the elements of Sequence + except the last element. +
++ Constant. +
++#include <boost/fusion/algorithm/tranformation/pop_back.hpp> +#include <boost/fusion/include/pop_back.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of pop_front, given the input sequence + type. +
++template< + typename Sequence + > +struct pop_front +{ + typedef unspecified type; +}; ++
Table 1.88. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
+result_of::pop_front<Sequence>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence with all + the elements of Sequence + except the first element. +
++ Constant. +
++ /algorithm/transformation/pop_front.hpp> +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of push_back, given the types of + the input sequence and element to push. +
++template< + typename Sequence, + typename T + > +struct push_back +{ + typedef unspecified type; +}; ++
Table 1.89. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + Operation's argument + + |
+
+result_of::push_back<Sequence, T>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence with the + elements of Sequence + and an element of type T + added to the end. +
++ Constant. +
++ /algorithm/transformation/push_back.hpp> +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of push_front, given the types + of the input sequence and element to push. +
++template< + typename Sequence, + typename T + > +struct push_front +{ + typedef unspecified type; +}; ++
Table 1.90. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + Operation's argument + + |
+
+result_of::push_front<Sequence, T>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence with the + elements of Sequence + and an element of type T + added to the beginning. +
++ Constant. +
++ /algorithm/transformation/push_front.hpp> +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of remove, given the sequence and + removal types. +
++template< + typename Sequence, + typename T + > +struct remove +{ + typedef unspecified type; +}; ++
Table 1.79. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + Remove elements of this type + + |
+
+result_of::remove<Sequence, T>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence containing + the elements of Sequence + not of type T. Equivalent + to result_of::replace_if<Sequence, + boost::is_same<mpl::_, T> >::type. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/remove.hpp> +#include <boost/fusion/include/remove.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of remove_if, given the input sequence + and unary MPL + Lambda Expression predicate types. +
++template< + typename Sequence, + typename Pred + > +struct remove_if +{ + typedef unspecified type; +}; ++
Table 1.80. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + Pred + + |
+
+ + A model of unary MPL + Lambda Expression + + |
+
+ + Remove elements which evaluate to boost::mpl::true_ + + |
+
+result_of::remove_if<Sequence, Pred>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a sequence containing + the elements of Sequence + for which Pred evaluates + to boost::mpl::false_. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/remove_if.hpp> +#include <boost/fusion/include/remove_if.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of replace, given the types of + the input sequence and element to replace. +
++template< + typename Sequence, + typename T + > +struct replace +{ + typedef unspecified type; +}; ++
Table 1.77. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + The type of the search and replacement objects + + |
+
+result_of::replace<Sequence,T>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns the return type of + replace. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/replace.hpp> +#include <boost/fusion/include/replace.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of replace_if, given the types + of the sequence, Polymorphic + Function Object predicate and replacement object. +
++template< + typename Sequence, + typename F, + typename T> +struct replace_if +{ + typedef unspecified type; +}; ++
Table 1.78. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + F + + |
+
+ + A model of unary Polymorphic + Function Object + + |
+
+ + Replacement predicate + + |
+
|
+ + T + + |
+
+ + Any type + + |
+
+ + The type of the replacement object + + |
+
+result_of::replace_if<Sequence,F,T>::type ++
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns the return type of + replace_if. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/replace_if.hpp> +#include <boost/fusion/include/replace_if.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of reverse, given the input sequence + type. +
++template< + typename Sequence + > +struct reverse +{ + typedef unspecified type; +}; ++
Table 1.81. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A model of Bidirectional + Sequence + + |
+
+ + Operation's argument + + |
+
+result_of::reverse<Sequence>::type ++
+ Return type: A model of Bidirectional + Sequence. +
++ Semantics: Returns a sequence with the + elements in the reverse order to Sequence. +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/reverse.hpp> +#include <boost/fusion/include/reverse.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ For a sequence seq and + function object or function pointer f, + transform returns a new + sequence with elements created by applying f(e) to each element of e + of seq. +
++template< + typename Sequence, + typename F + > +typename result_of::transform<Sequence const, F>::type transform( + Sequence const& seq, F f); ++
Table 1.75. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + f + + |
+
+ + f(e) + is a valid expression for each element e + of seq. boost::result_of<F(E)>::type is the return type of f when called with a value of + each element type E. + + |
+
+ + Transformation function + + |
+
+transform(seq, f); ++
+ Return type: A model of Forward + Sequence +
++ Semantics: Returns a new sequence, containing + the return values of f(e) for each element e + within seq. +
++template< + typename Sequence1, + typename Sequence2, + typename F + > +typename result_of::transform<Sequence1 const, Sequence2 const, F>::type transform( + Sequence1 const& seq1, Sequence2 const& seq2, F f); ++
Table 1.76. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq1 + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + seq2 + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Operation's argument + + |
+
|
+ + f + + |
+
+ + f(e1,e2) + is a valid expression for each pair of elements e1 + of seq1 and e2 of seq2. + boost::result_of<F(E1,E2)>::type is the return type of f when called with elements of + type E1 and E2 + + |
+
+ + Transformation function + + |
+
+ Return type: A model of Forward + Sequence. +
++ Semantics: Returns a new sequence, containing + the return values of f(e1, e2) for each pair of elements e1 and e2 + within seq1 and seq2 respectively. +
++ Constant. Returns a view which is lazily evaluated. +
++#include <boost/fusion/algorithm/transformation/transform.hpp> +#include <boost/fusion/include/transform.hpp> ++
+struct triple +{ + typedef int result_type; + + int operator()(int t) const + { + return t * 3; + }; +}; +... +assert(transform(make_vector(1,2,3), triple()) == make_vector(3,6,9)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Zips sequences together to form a single sequence, whos members are tuples + of the members of the component sequences. +
++template< + typename Sequence1, + typename Sequence2, + ... + typename SequenceN + > +struct zip +{ + typedef unspecified type; +}; ++
+result_of::zip<Sequence1, Sequence2, ... SequenceN>::type ++
+ Return type: A model of the most restrictive + traversal category of sequences Sequence1 + to SequenceN. +
++ Semantics: Return a sequence containing + tuples of elements from each sequence. For example, applying zip to tuples + (1, 2, + 3) + and ('a', 'b', + 'c') + would return ((1, 'a'),(2, 'b'),(3, + 'c')) +
++ Constant. +
++#include <boost/fusion/algorithm/transformation/zip.hpp> +#include <boost/fusion/include/zip.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ This section summarizes significant changes to the Fusion library. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Fusion provides a few predefined sequences out of the box. These containers + actually hold heterogenously typed data; unlike Views. + These containers are more or less counterparts of those in STL. +
++#include <boost/fusion/container.hpp> +#include <boost/fusion/include/container.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ cons is a simple Forward + Sequence. It is a lisp style recursive list structure where car is the head and + cdr is the tail: + usually another cons structure or nil: + the empty list. Fusion's list is built on top of this more + primitive data structure. It is more efficient than vector when the target sequence + is constructed piecemeal (a data at a time). The runtime cost of access to + each element is peculiarly constant (see Recursive + Inlined Functions). +
++#include <boost/fusion/container/list/cons.hpp> +#include <boost/fusion/include/cons.hpp> ++
+template <typename Car, typename Cdr = nil> +struct cons; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Car + + |
+
+ + Head type + + |
+
+ + + |
+
|
+ + Cdr + + |
+
+ + Tail type + + |
+
+ + nil + + |
+
Notation
++ An empty cons +
+ A cons type +
+ Instances of cons +
+ An arbitrary data +
+ Another cons list +
+ A Forward Sequence +
+ An MPL + Integral Constant +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Forward + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + nil() + + |
+
+ + Creates an empty list. + + |
+
|
+ + C() + + |
+
+ + Creates a cons with default constructed elements. + + |
+
|
+ + C(car) + + |
+
+ + Creates a cons with car + head and default constructed tail. + + |
+
|
+ + C(car, + cdr) + + |
+
+ + Creates a cons with car + head and cdr tail. + + |
+
|
+ + C(s) + + |
+
+ + Copy constructs a cons from a Forward + Sequence, s. + + |
+
|
+ + l = + s + + |
+
+ + Assigns to a cons, l, + from a Forward + Sequence, s. + + |
+
|
+ + at<N>(l) + + |
+
+ + The Nth element from the beginning of the sequence; see at. + + |
+
+ 
at<N>(l) is provided
+ for convenience and compatibility with the original Boost.Tuple
+ library, despite cons being
+ a Forward Sequence
+ only (at is supposed to be
+ a Random
+ Access Sequence requirement). The runtime complexity of at is constant (see Recursive
+ Inlined Functions).
+
+cons<int, cons<float> > l(12, cons<float>(5.5f)); +std::cout << at_c<0>(l) << std::endl; +std::cout << at_c<1>(l) << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ All fusion sequences can be converted to one of the Container + types using one of these conversion functions. +
++#include <boost/fusion/include/convert.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Convert a fusion sequence to a list. +
++template <typename Sequence> +typename result_of::as_list<Sequence>::type +as_list(Sequence& seq); + +template <typename Sequence> +typename result_of::as_list<Sequence const>::type +as_list(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + An instance of Sequence + + |
+
+ + The sequence to convert. + + |
+
+as_list(seq); ++
+ Return type: result_of::as_list<Sequence>::type +
++ Semantics: Convert a fusion sequence, + seq, to a list. +
++#include <boost/fusion/container/list/convert.hpp> +#include <boost/fusion/include/as_list.hpp> ++
+as_list(make_vector('x', 123, "hello")) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Convert a fusion sequence to a map. +
++template <typename Sequence> +typename result_of::as_map<Sequence>::type +as_map(Sequence& seq); + +template <typename Sequence> +typename result_of::as_map<Sequence const>::type +as_map(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + An instance of Sequence + + |
+
+ + The sequence to convert. + + |
+
+as_map(seq); ++
+ Return type: result_of::as_map<Sequence>::type +
++ Semantics: Convert a fusion sequence, + seq, to a map. +
++ Precondition: The elements of the sequence + are assumed to be __fusionpair_s. + There may be no duplicate fusion::pair key types. +
++#include <boost/fusion/container/map/convert.hpp> +#include <boost/fusion/include/as_map.hpp> ++
+as_map(make_vector( + make_pair<int>('X') + , make_pair<double>("Men"))) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Convert a fusion sequence to a set. +
++template <typename Sequence> +typename result_of::as_set<Sequence>::type +as_set(Sequence& seq); + +template <typename Sequence> +typename result_of::as_set<Sequence const>::type +as_set(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + An instance of Sequence + + |
+
+ + The sequence to convert. + + |
+
+as_set(seq); ++
+ Return type: result_of::as_set<Sequence>::type +
++ Semantics: Convert a fusion sequence, + seq, to a set. +
++ Precondition: There may be no duplicate + key types. +
++#include <boost/fusion/container/set/convert.hpp> +#include <boost/fusion/include/as_set.hpp> ++
+as_set(make_vector('x', 123, "hello")) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Convert a fusion sequence to a vector. +
++template <typename Sequence> +typename result_of::as_vector<Sequence>::type +as_vector(Sequence& seq); + +template <typename Sequence> +typename result_of::as_vector<Sequence const>::type +as_vector(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + An instance of Sequence + + |
+
+ + The sequence to convert. + + |
+
+as_vector(seq); ++
+ Return type: result_of::as_vector<Sequence>::type +
++ Semantics: Convert a fusion sequence, + seq, to a vector. +
++#include <boost/fusion/container/vector/convert.hpp> +#include <boost/fusion/include/as_vector.hpp> ++
+as_vector(make_list('x', 123, "hello")) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of as_list. +
++template <typename Sequence> +struct as_list; ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A fusion Sequence + + |
+
+ + The sequence type to convert. + + |
+
+result_of::as_list<Sequence>::type; ++
+ Return type: A list with same elements as the + input sequence, Sequence. +
++ Semantics: Convert a fusion sequence, + Sequence, to a list. +
++#include <boost/fusion/container/list/convert.hpp> +#include <boost/fusion/include/as_list.hpp> ++
+result_of::as_list<vector<char, int> >::type ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of as_map. +
++template <typename Sequence> +struct as_map; ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A fusion Sequence + + |
+
+ + The sequence to convert. + + |
+
+result_of::as_map<Sequence>::type; ++
+ Return type: A map with same elements as the + input sequence, Sequence. +
++ Semantics: Convert a fusion sequence, + Sequence, to a map. +
++ Precondition: The elements of the sequence + are assumed to be __fusionpair_s. + There may be no duplicate fusion::pair key types. +
++#include <boost/fusion/container/map/convert.hpp> +#include <boost/fusion/include/as_map.hpp> ++
+result_of::as_map<vector< + fusion::pair<int, char> + , fusion::pair<double, std::string> > >::type ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of as_set. +
++template <typename Sequence> +struct as_set; ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A fusion Sequence + + |
+
+ + The sequence to convert. + + |
+
+result_of::as_set<Sequence>::type; ++
+ Return type: A set with same elements as the + input sequence, Sequence. +
++ Semantics: Convert a fusion sequence, + Sequence, to a set. +
++ Precondition: There may be no duplicate + key types. +
++#include <boost/fusion/container/set/convert.hpp> +#include <boost/fusion/include/as_set.hpp> ++
+result_of::as_set<vector<char, int> >::type ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of as_vector. +
++template <typename Sequence> +struct as_vector; ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A fusion Sequence + + |
+
+ + The sequence to convert. + + |
+
+result_of::as_vector<Sequence>::type; ++
+ Return type: A vector with same elements as + the input sequence, Sequence. +
++ Semantics: Convert a fusion sequence, + Sequence, to a vector. +
++#include <boost/fusion/container/vector/convert.hpp> +#include <boost/fusion/include/as_vector.hpp> ++
+result_of::as_vector<list<char, int> >::type ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ These are the functions that you can use to generate various forms of Container from elemental values. +
++#include <boost/fusion/container/generation.hpp> +#include <boost/fusion/include/generation.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Constructs a tie using a list sequence. +
++template <typename T0, typename T1,... typename TN> +list<T0&, T1&,... TN&> +list_tie(T0& x0, T1& x1... TN& xN); ++
+ The variadic function accepts 0 + to FUSION_MAX_LIST_SIZE + elements, where FUSION_MAX_LIST_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_LIST_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_LIST_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + x0, + x1,... + xN + + |
+
+ + Instances of T0, T1,... TN + + |
+
+ + The arguments to list_tie + + |
+
+list_tie(x0, x1,... xN); ++
+ Return type: list<T0&, T1&,... + TN&> +
++ Semantics: Create a list of references from x0, x1,... xN. +
++#include <boost/fusion/container/generation/list_tie.hpp> +#include <boost/fusion/include/list_tie.hpp> ++
+int i = 123; +double d = 123.456; +list_tie(i, d) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Create a cons + from car (head) + and optional cdr (tail). +
++template <typename Car> +typename result_of::make_cons<Car>::type +make_cons(Car const& car); + +template <typename Car, typename Cdr> +typename result_of::make_cons<Car, Cdr>::type +make_cons(Car const& car, Cdr const& cdr); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + car + + |
+
+ + Instance of Car + + |
+
+ + The list's head + + |
+
|
+ + cdr + + |
+
+ + Instance of Cdr + + |
+
+ + The list's tail (optional) + + |
+
+make_cons(car, cdr); ++
+ Return type: result_of::make_cons<Car, Cdr>::type or result_of::make_cons<Car>::type +
++ Semantics: Create a cons from car + (head) and optional cdr + (tail). +
++#include <boost/fusion/container/generation/make_cons.hpp> +#include <boost/fusion/include/make_cons.hpp> ++
+make_cons('x', make_cons(123)) ++
+ boost::ref +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Create a list + from one or more values. +
++template <typename T0, typename T1,... typename TN> +typename result_of::make_list<T0, T1,... TN>::type +make_list(T0 const& x0, T1 const& x1... TN const& xN); ++
+ The variadic function accepts 0 + to FUSION_MAX_LIST_SIZE + elements, where FUSION_MAX_LIST_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_LIST_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_LIST_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + x0, + x1,... + xN + + |
+
+ + Instances of T0, T1,... TN + + |
+
+ + The arguments to make_list + + |
+
+make_list(x0, x1,... xN); ++
+ Return type: result_of::make_list<T0, T1,... TN>::type +
++ Semantics: Create a list from x0, x1,... xN. +
++#include <boost/fusion/container/generation/make_list.hpp> +#include <boost/fusion/include/make_list.hpp> ++
+make_list(123, "hello", 12.5) ++
+ boost::ref +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Create a map + from one or more key/data pairs. +
++template < + typename K0, typename K1,... typename KN + , typename T0, typename T1,... typename TN> +typename result_of::make_map<K0, K0,... KN, T0, T1,... TN>::type +make_map(T0 const& x0, T1 const& x1... TN const& xN); ++
+ The variadic function accepts 0 + to FUSION_MAX_VECTOR_SIZE + [9] + elements, where FUSION_MAX_VECTOR_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_VECTOR_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_VECTOR_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + K0, + K1,... + KN + + |
+
+ + The key types + + |
+
+ + Keys associated with x0, x1,... xN + + |
+
|
+ + x0, + x1,... + xN + + |
+
+ + Instances of T0, T1,... TN + + |
+
+ + The arguments to make_map + + |
+
+make_map<K0, K1,... KN>(x0, x1,... xN); ++
+ Return type: result_of::make_map<K0, K0,... KN, T0, T1,... TN>::type +
++ Semantics: Create a map from K0, K1,... KN + keys and x0, + x1,... + xN data. +
++ Precondition: There may be no duplicate + key types. +
++#include <boost/fusion/container/generation/make_map.hpp> +#include <boost/fusion/include/make_map.hpp> ++
+make_map( + make_pair<int>('X') + , make_pair<double>("Men")) ++
+ boost::ref, + fusion::pair +
+[9] + map is implemented + in terms of the vector. That is why we reuse FUSION_MAX_VECTOR_SIZE +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Create a set + from one or more values. +
++template <typename T0, typename T1,... typename TN> +typename result_of::make_set<T0, T1,... TN>::type +make_set(T0 const& x0, T1 const& x1... TN const& xN); ++
+ The variadic function accepts 0 + to FUSION_MAX_VECTOR_SIZE + [8] + elements, where FUSION_MAX_VECTOR_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_VECTOR_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_VECTOR_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + x0, + x1,... + xN + + |
+
+ + Instances of T0, T1,... TN + + |
+
+ + The arguments to make_set + + |
+
+make_set(x0, x1,... xN); ++
+ Return type: result_of::make_set<T0, T1,... TN>::type +
++ Semantics: Create a set from x0, x1,... xN. +
++ Precondition: There may be no duplicate + key types. +
++#include <boost/fusion/container/generation/make_set.hpp> +#include <boost/fusion/include/make_set.hpp> ++
+make_set(123, "hello", 12.5) ++
+ boost::ref +
+[8] + set is implemented + in terms of the vector. That is why we reuse FUSION_MAX_VECTOR_SIZE +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Create a vector + from one or more values. +
++template <typename T0, typename T1,... typename TN> +typename result_of::make_vector<T0, T1,... TN>::type +make_vector(T0 const& x0, T1 const& x1... TN const& xN); ++
+ The variadic function accepts 0 + to FUSION_MAX_VECTOR_SIZE + elements, where FUSION_MAX_VECTOR_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_VECTOR_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_VECTOR_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + x0, + x1,... + xN + + |
+
+ + Instances of T0, T1,... TN + + |
+
+ + The arguments to make_vector + + |
+
+make_vector(x0, x1,... xN); ++
+ Return type: result_of::make_vector<T0, T1,... TN>::type +
++ Semantics: Create a vector from x0, x1,... xN. +
++#include <boost/fusion/container/generation/make_vector.hpp> +#include <boost/fusion/include/make_vector.hpp> ++
+make_vector(123, "hello", 12.5) ++
+ boost::ref +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Constructs a tie using a map sequence. +
++template <typename K0, typename K1,... typename KN, typename D0, typename D1,... typename DN> +map<pair<K0, D0&>, pair<K1, D1&>,... pair<KN, DN&> > +map_tie(D0& d0, D1& d1... DN& dN); ++
+ The variadic function accepts 0 + to FUSION_MAX_MAP_SIZE + elements, where FUSION_MAX_MAP_SIZE + is a user definable predefined maximum that defaults to 10, and a corresponding number of key types. + You may define the preprocessor constant FUSION_MAX_MAP_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_MAP_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + K0, + K1,... + KN + + |
+
+ + Any type + + |
+
+ + The key types associated with each of the x1,x2,...,xN + values + + |
+
|
+ + x0, + x1,... + xN + + |
+
+ + Instances of T0, T1,... TN + + |
+
+ + The arguments to map_tie + + |
+
+map_tie<K0, K1,... KN>(x0, x1,... xN); ++
+ Return type: map<pair<K0, D0&>, pair<K1, + D1&>,... pair<KN, + DN&> > +
++ Semantics: Create a map of references from x0, x1,... xN with keys K0, K1,... KN +
++#include <boost/fusion/container/generation/map_tie.hpp> +#include <boost/fusion/include/map_tie.hpp> ++
+struct int_key; +struct double_key; +... +int i = 123; +double d = 123.456; +map_tie<int_key, double_key>(i, d) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Tiers are sequences, where all elements are non-const reference types. + They are constructed with a call to a couple of tie + function templates. The succeeding sections document the various tier + flavors. +
++ Example: +
++int i; char c; double d; + ... +vector_tie(i, c, a); ++
+ The vector_tie function creates + a vector + of type vector<int&, char&, double&>. The same result could be achieved + with the call make_vector(ref(i), ref(c), ref(a)) + [10] + . +
++ A tie can be used to 'unpack' another tuple into + variables. E.g.: +
++int i; char c; double d; +vector_tie(i, c, d) = make_vector(1,'a', 5.5); +std::cout << i << " " << c << " " << d; ++
+ This code prints 1 a 5.5 to the standard output stream. A sequence unpacking + operation like this is found for example in ML and Python. It is convenient + when calling functions which return sequences. +
++ There is also an object called ignore which allows + you to ignore an element assigned by a sequence. The idea is that a function + may return a sequence, only part of which you are interested in. For + example: +
++char c; +vector_tie(ignore, c) = make_vector(1, 'a'); ++ +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Constructs a tie using a vector sequence. +
++template <typename T0, typename T1,... typename TN> +vector<T0&, T1&,... TN&> +vector_tie(T0& x0, T1& x1... TN& xN); ++
+ The variadic function accepts 0 + to FUSION_MAX_VECTOR_SIZE + elements, where FUSION_MAX_VECTOR_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_VECTOR_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_VECTOR_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + x0, + x1,... + xN + + |
+
+ + Instances of T0, T1,... TN + + |
+
+ + The arguments to vector_tie + + |
+
+vector_tie(x0, x1,... xN); ++
+ Return type: vector<T0&, T1&,... + TN&> +
++ Semantics: Create a vector of references from x0, x1,... xN. +
++#include <boost/fusion/container/generation/vector_tie.hpp> +#include <boost/fusion/include/vector_tie.hpp> ++
+int i = 123; +double d = 123.456; +vector_tie(i, d) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of list_tie. +
++template <typename T0, typename T1,... typename TN> +struct list_tie; ++
+ The variadic function accepts 0 + to FUSION_MAX_LIST_SIZE + elements, where FUSION_MAX_LIST_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_LIST_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_LIST_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + T0, + T1,... + TN + + |
+
+ + Any type + + |
+
+ + The arguments to list_tie + + |
+
+result_of::list_tie<T0, T1,... TN>::type; ++
+ Return type: list<T0&, T1&,... + TN&> +
++ Semantics: Create a list of references from T0, T1,... TN. +
++#include <boost/fusion/container/generation/list_tie.hpp> +#include <boost/fusion/include/list_tie.hpp> ++
+result_of::list_tie<int, double>::type ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_cons. +
++template <typename Car, typename Cdr = nil> +struct make_cons; ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Car + + |
+
+ + Any type + + |
+
+ + The list's head type + + |
+
|
+ + Cdr + + |
+
+ + A cons + + |
+
+ + The list's tail type (optional) + + |
+
+result_of::make_cons<Car, Cdr>::type ++
+ Return type: A cons with head element, Car, of type converted following the + rules for element + conversion, and tail, Cdr. +
++ Semantics: Create a cons from Car + (head) and optional Cdr + (tail). +
++#include <boost/fusion/container/generation/make_cons.hpp> +#include <boost/fusion/include/make_cons.hpp> ++
+result_of::make_cons<char, result_of::make_cons<int>::type>::type ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_list. +
++template <typename T0, typename T1,... typename TN> +struct make_list; ++
+ The variadic function accepts 0 + to FUSION_MAX_LIST_SIZE + elements, where FUSION_MAX_LIST_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_LIST_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_LIST_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + T0, + T1,... + TN + + |
+
+ + Any type + + |
+
+ + Template arguments to make_list + + |
+
+result_of::make_list<T0, T1,... TN>::type ++
+ Return type: A list with elements of types + converted following the rules for element + conversion. +
++ Semantics: Create a list from T0, T1,... TN. +
++#include <boost/fusion/container/generation/make_list.hpp> +#include <boost/fusion/include/make_list.hpp> ++
+result_of::make_list<int, const char(&)[7], double>::type ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_map. +
++template < + typename K0, typename K1,... typename KN + , typename T0, typename T1,... typename TN> +struct make_map; ++
+ The variadic function accepts 0 + to FUSION_MAX_VECTOR_SIZE + [12] + elements, where FUSION_MAX_VECTOR_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_VECTOR_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_VECTOR_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + K0, + K1,... + KN + + |
+
+ + Any type + + |
+
+ + Keys associated with T0, T1,... TN + + |
+
|
+ + T0, + T1,... + TN + + |
+
+ + Any type + + |
+
+ + Data associated with keys K0, K1,... KN + + |
+
+resulf_of::make_map<K0, K1,... KN, T0, T1,... TN>::type; ++
+ Return type: result_of::make_map<K0, K0,... KN, T0, T1,... TN>::type +
++ Semantics: A map with fusion::pair elements where the second_type is converted following + the rules for element + conversion. +
++ Precondition: There may be no duplicate + key types. +
++#include <boost/fusion/container/generation/make_map.hpp> +#include <boost/fusion/include/make_map.hpp> ++
+result_of::make_map<int, double, char, double>::type ++
+ fusion::pair +
+[12] + map is implemented + in terms of the vector. That is why we reuse FUSION_MAX_VECTOR_SIZE +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_set. +
++template <typename T0, typename T1,... typename TN> +struct make_set; ++
+ The variadic function accepts 0 + to FUSION_MAX_VECTOR_SIZE + [11] + elements, where FUSION_MAX_VECTOR_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_VECTOR_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_VECTOR_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + T0, + T1,... + TN + + |
+
+ + Any type + + |
+
+ + The arguments to make_set + + |
+
+result_of::make_set<T0, T1,... TN>::type ++
+ Return type: A set with elements of types converted + following the rules for element + conversion. +
++ Semantics: Create a set from T0, T1,... TN. +
++ Precondition: There may be no duplicate + key types. +
++#include <boost/fusion/container/generation/make_set.hpp> +#include <boost/fusion/include/make_set.hpp> ++
+result_of::make_set<int, char, double>::type ++
[11] + set is implemented + in terms of the vector. That is why we reuse FUSION_MAX_VECTOR_SIZE +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_vector. +
++template <typename T0, typename T1,... typename TN> +struct make_vector; ++
+ The variadic function accepts 0 + to FUSION_MAX_VECTOR_SIZE + elements, where FUSION_MAX_VECTOR_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_VECTOR_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_VECTOR_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + T0, + T1,... + TN + + |
+
+ + Any type + + |
+
+ + Template arguments to make_vector + + |
+
+result_of::make_vector<T0, T1,... TN>::type ++
+ Return type: A vector with elements of types + converted following the rules for element + conversion. +
++ Semantics: Create a vector from T0, T1,... TN. +
++#include <boost/fusion/container/generation/make_list.hpp> +#include <boost/fusion/include/make_list.hpp> ++
+result_of::make_vector<int, const char(&)[7], double>::type ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of map_tie. +
++template <typename K0, typename K1,... typename KN, typename D0, typename D1,... typename DN> +struct map_tie; ++
+ The variadic function accepts 0 + to FUSION_MAX_MAP_SIZE + elements, where FUSION_MAX_MAP_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_MAP_SIZE before + including any Fusion header to change the default. Example: +
++#define FUSION_MAX_MAP_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + K0, + K1,... + KN + + |
+
+ + Any type + + |
+
+ + The key types for map_tie + + |
+
|
+ + D0, + D1,... + DN + + |
+
+ + Any type + + |
+
+ + The arguments types for map_tie + + |
+
+result_of::map_tie<K0, K1,... KN, D0, D1,... DN>::type; ++
+ Return type: map<pair<K0, D0&>, pair<K1, + D1&>,... pair<KN, + DN&> > +
++ Semantics: Create a map of references from D0, D1,... DN with keys K0, K1,... KN +
++#include <boost/fusion/container/generation/map_tie.hpp> +#include <boost/fusion/include/map_tie.hpp> ++
+struct int_key; +struct double_key; +... +result_of::map_tie<int_key, double_key, int, double>::type ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of vector_tie. +
++template <typename T0, typename T1,... typename TN> +struct vector_tie; ++
+ The variadic function accepts 0 + to FUSION_MAX_VECTOR_SIZE + elements, where FUSION_MAX_VECTOR_SIZE + is a user definable predefined maximum that defaults to 10. You may define the preprocessor constant + FUSION_MAX_VECTOR_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_VECTOR_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + T0, + T1,... + TN + + |
+
+ + Any type + + |
+
+ + The arguments to vector_tie + + |
+
+result_of::vector_tie<T0, T1,... TN>::type; ++
+ Return type: vector<T0&, T1&,... + TN&> +
++ Semantics: Create a vector of references from T0, T1,... TN. +
++#include <boost/fusion/container/generation/vector_tie.hpp> +#include <boost/fusion/include/vector_tie.hpp> ++
+result_of::vector_tie<int, double>::type ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ list is a Forward + Sequence of heterogenous typed data built on top of cons. It is more efficient than + vector + when the target sequence is constructed piecemeal (a data at a time). The + runtime cost of access to each element is peculiarly constant (see Recursive Inlined Functions). +
++#include <boost/fusion/container/list.hpp> +#include <boost/fusion/include/list.hpp> +#include <boost/fusion/container/list/list_fwd.hpp> +#include <boost/fusion/include/list_fwd.hpp> ++
+template < + typename T0 = unspecified + , typename T1 = unspecified + , typename T2 = unspecified + ... + , typename TN = unspecified +> +struct list; ++
+ The variadic class interface accepts 0 + to FUSION_MAX_LIST_SIZE elements, + where FUSION_MAX_LIST_SIZE + is a user definable predefined maximum that defaults to 10. + Example: +
++list<int, char, double> ++
+ You may define the preprocessor constant FUSION_MAX_LIST_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_LIST_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + T0...TN + + |
+
+ + Element types + + |
+
+ + unspecified-type + + |
+
Notation
++ A list type +
+ An instance of list +
+ Heterogeneous values +
+ A Forward Sequence +
+ An MPL + Integral Constant +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Forward + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + L() + + |
+
+ + Creates a list with default constructed elements. + + |
+
|
+ + L(e0, e1,... + en) + + |
+
+ + Creates a list with elements e0...en. + + |
+
|
+ + L(s) + + |
+
+ + Copy constructs a list from a Forward + Sequence, s. + + |
+
|
+ + l = + s + + |
+
+ + Assigns to a list, l, + from a Forward + Sequence, s. + + |
+
|
+ + at<N>(l) + + |
+
+ + The Nth element from the beginning of the sequence; see at. + + |
+
+ at<n>(l) is provided
+ for convenience and compatibility with the original Boost.Tuple
+ library, despite list being
+ a Forward Sequence
+ only (at is supposed to be a Random
+ Access Sequence requirement). The runtime complexity of at is constant (see Recursive
+ Inlined Functions).
+
+list<int, float> l(12, 5.5f); +std::cout << at_c<0>(l) << std::endl; +std::cout << at_c<1>(l) << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ map is an Associative + Sequence of heteregenous typed data elements. Each element is a key/data + pair (see fusion::pair) + where the key has no data (type only). Type identity is used to impose an + equivalence relation on keys. A map may contain at most one element for each + key. Membership testing and element key lookup has constant runtime complexity + (see Overloaded Functions). +
++#include <boost/fusion/container/map.hpp> +#include <boost/fusion/include/map.hpp> +#include <boost/fusion/container/map_fwd.hpp> +#include <boost/fusion/include/map_fwd.hpp> ++
+template < + typename T0 = unspecified + , typename T1 = unspecified + , typename T2 = unspecified + ... + , typename TN = unspecified +> +struct map; ++
+ The variadic class interface accepts 0 + to FUSION_MAX_MAP_SIZE elements, + where FUSION_MAX_MAP_SIZE + is a user definable predefined maximum that defaults to 10. + Example: +
++map<pair<int, char>, pair<char, char>, pair<double, char> > ++
+ You may define the preprocessor constant FUSION_MAX_MAP_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_MAP_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + T0...TN + + |
+
+ + Element types + + |
+
+ + unspecified-type + + |
+
Notation
++ A map type +
+ An instance of map +
+ Heterogeneous key/value pairs (see fusion::pair) +
+ A Forward Sequence +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Random + Access Sequence and Associative + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + M() + + |
+
+ + Creates a map with default constructed elements. + + |
+
|
+ + M(e0, e1,... + en) + + |
+
+ + Creates a map with element pairs e0...en. + + |
+
|
+ + M(s) + + |
+
+ + Copy constructs a map from a Forward + Sequence s. + + |
+
|
+ + m = + s + + |
+
+ + Assigns to a map, m, + from a Forward + Sequence s. + + |
+
+typedef map< + pair<int, char> + , pair<double, std::string> > +map_type; + +map_type m( + make_pair<int>('X') + , make_pair<double>("Men")); + +std::cout << at_key<int>(m) << std::endl; +std::cout << at_key<double>(m) << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ set is an Associative + Sequence of heteregenous typed data elements. Type identity is used + to impose an equivalence relation on keys. The element's type is its key. + A set may contain at most one element for each key. Membership testing and + element key lookup has constant runtime complexity (see Overloaded + Functions). +
++#include <boost/fusion/container/set.hpp> +#include <boost/fusion/include/set.hpp> +#include <boost/fusion/container/set_fwd.hpp> +#include <boost/fusion/include/set_fwd.hpp> ++
+template < + typename T0 = unspecified + , typename T1 = unspecified + , typename T2 = unspecified + ... + , typename TN = unspecified +> +struct set; ++
+ The variadic class interface accepts 0 + to FUSION_MAX_SET_SIZE elements, + where FUSION_MAX_SET_SIZE + is a user definable predefined maximum that defaults to 10. + Example: +
++set<int, char, double> ++
+ You may define the preprocessor constant FUSION_MAX_SET_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_SET_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + T0...TN + + |
+
+ + Element types + + |
+
+ + unspecified-type + + |
+
Notation
++ A set type +
+ An instance of set +
+ Heterogeneous values +
+ A Forward Sequence +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Random + Access Sequence and Associative + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + S() + + |
+
+ + Creates a set with default constructed elements. + + |
+
|
+ + S(e0, e1,... + en) + + |
+
+ + Creates a set with elements e0...en. + + |
+
|
+ + S(fs) + + |
+
+ + Copy constructs a set from a Forward + Sequence fs. + + |
+
|
+ + s = + fs + + |
+
+ + Assigns to a set, s, + from a Forward + Sequence fs. + + |
+
+typedef set<int, float> S; +S s(12, 5.5f); +std::cout << at_key<int>(s) << std::endl; +std::cout << at_key<float>(s) << std::endl; +std::cout << result_of::has_key<S, double>::value << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ vector is a Random + Access Sequence of heterogenous typed data structured as a simple + struct where each element is + held as a member variable. vector + is the simplest of the Fusion sequence container, and in many cases the most + efficient. +
++#include <boost/fusion/container/vector.hpp> +#include <boost/fusion/include/vector.hpp> +#include <boost/fusion/container/vector/vector_fwd.hpp> +#include <boost/fusion/include/vector_fwd.hpp> + +// numbered forms +#include <boost/fusion/container/vector/vector10.hpp> +#include <boost/fusion/include/vector10.hpp> +#include <boost/fusion/container/vector/vector20.hpp> +#include <boost/fusion/include/vector20.hpp> +#include <boost/fusion/container/vector/vector30.hpp> +#include <boost/fusion/include/vector30.hpp> +#include <boost/fusion/container/vector/vector40.hpp> +#include <boost/fusion/include/vector40.hpp> +#include <boost/fusion/container/vector/vector50.hpp> +#include <boost/fusion/include/vector50.hpp> ++
+ Numbered forms +
++template <> +struct vector0; + +template <typename T0> +struct vector1; + +template <typename T0, typename T1> +struct vector2; + +template <typename T0, typename T1, typename T2> +struct vector3; + +... + +template <typename T0, typename T1, typename T2..., typename TN> +struct vectorN; ++
+ Variadic form +
++template < + typename T0 = unspecified + , typename T1 = unspecified + , typename T2 = unspecified + ... + , typename TN = unspecified +> +struct vector; ++
+ The numbered form accepts the exact number of elements. Example: +
++vector3<int, char, double> ++
+ The variadic form accepts 0 to + FUSION_MAX_VECTOR_SIZE elements, + where FUSION_MAX_VECTOR_SIZE + is a user definable predefined maximum that defaults to 10. + Example: +
++vector<int, char, double> ++
+ You may define the preprocessor constant FUSION_MAX_VECTOR_SIZE + before including any Fusion header to change the default. Example: +
++#define FUSION_MAX_VECTOR_SIZE 20 ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + T0...TN + + |
+
+ + Element types + + |
+
+ + unspecified + + |
+
Notation
++ Instance of vector +
+ A vector type +
+ Heterogeneous values +
+ A Forward Sequence +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Random + Access Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + V() + + |
+
+ + Creates a vector with default constructed elements. + + |
+
|
+ + V(e0, e1,... + en) + + |
+
+ + Creates a vector with elements e0...en. + + |
+
|
+ + V(s) + + |
+
+ + Copy constructs a vector from a Forward + Sequence, s. + + |
+
|
+ + v = + s + + |
+
+ + Assigns to a vector, v, + from a Forward + Sequence, s. + + |
+
+vector<int, float> v(12, 5.5f); +std::cout << at_c<0>(v) << std::endl; +std::cout << at_c<1>(v) << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The Fusion library is designed to be extensible, new sequences types can + easily be added. In fact, the library support for std::pair, + boost::array and MPL + sequences is entirely provided using the extension mechanism. +
++ The process for adding a new sequence type to Fusion is: +
++ In order to illustrate enabling a new sequence type for use with Fusion, + we are going to use the type: +
++namespace example +{ + struct example_struct + { + std::string name; + int age; + example_struct( + const std::string& n, + int a) + : name(n), age(a) + {} + }; +} ++
+ We are going to pretend that this type has been provided by a 3rd party library, + and therefore cannot be modified. We shall work through all the necessary + steps to enable example_struct + to serve as an Associative + Sequence as described in the Quick + Start guide. +
++ The Fusion extensibility mechanism uses tag + dispatching to call the correct code for a given sequence + type. In order to exploit the tag dispatching mechanism we must first declare + a new tag type for the mechanism to use. For example: +
++namespace example { + struct example_sequence_tag; // Only definition needed +} ++
+ Next we need to enable the traits::tag_of + metafunction to return our newly chosen tag type for operations involving + our sequence. This is done by specializing traits::tag_of + for our sequence type. +
++#include <boost/fusion/support/tag_of_fwd.hpp> +#include <boost/fusion/include/tag_of_fwd.hpp> + +namespace boost { namespace fusion { namespace traits { + template<> + struct tag_of<example_struct> + { + typedef example::example_sequence_tag type; + }; +}}} ++
+ traits::tag_of also has a second template argument, + that can be used in conjuction with boost::enable_if + to provide tag support for groups of related types. This feature is not necessary + for our sequence, but for an example see the code in: +
++#include <boost/fusion/adapted/array/tag_of.hpp> +#include <boost/fusion/include/tag_of.hpp> ++
+ We need an iterator to describe positions, and provide access to the data + within our sequence. As it is straightforward to do, we are going to provide + a random access iterator in our example. +
++ We will use a simple design, in which the 2 members of example_struct + are given numbered indices, 0 for name + and 1 for age respectively. +
++template<typename Struct, int Pos> +struct example_struct_iterator + : boost::fusion::iterator_base<example_struct_iterator<Struct, Pos> > +{ + BOOST_STATIC_ASSERT(Pos >=0 && Pos < 3); + typedef Struct struct_type; + typedef boost::mpl::int_<Pos> index; + typedef boost::fusion::random_access_traversal_tag category; + + example_struct_iterator(Struct& str) + : struct_(str) {} + + Struct& struct_; +}; ++
+ A quick summary of the details of our iterator: +
++ We also need to enable tag + dispatching for our iterator type, with another specialization + of traits::tag_of. +
++ In isolation, the iterator implementation is pretty dry. Things should become + clearer as we add features to our implementation. +
++ To start with, we will get the result_of::value_of metafunction working. To + do this, we provide a specialization of the boost::fusion::extension::value_of_impl + template for our iterator's tag type. +
++template<> +struct value_of_impl<example::example_struct_iterator_tag> +{ + template<typename Iterator> + struct apply; + + template<typename Struct> + struct apply<example::example_struct_iterator<Struct, 0> > + { + typedef std::string type; + }; + + template<typename Struct> + struct apply<example::example_struct_iterator<Struct, 1> > + { + typedef int type; + }; +}; ++
+ The implementation itself is pretty simple, it just uses 2 partial specializations + to provide the type of the 2 different members of example_struct, + based on the index of the iterator. +
++ To understand how value_of_impl + is used by the library we will look at the implementation of value_of: +
++template <typename Iterator> +struct value_of + : extension::value_of_impl<typename detail::tag_of<Iterator>::type>:: + template apply<Iterator> +{}; ++
+ So value_of + uses tag dispatching + to select an MPL + Metafunction Class to provide its functionality. You will notice + this pattern throughout the implementation of Fusion. +
++ Ok, lets enable dereferencing of our iterator. In this case we must provide + a suitable specialization of deref_impl. +
++template<> +struct deref_impl<example::example_struct_iterator_tag> +{ + template<typename Iterator> + struct apply; + + template<typename Struct> + struct apply<example::example_struct_iterator<Struct, 0> > + { + typedef typename mpl::if_< + is_const<Struct>, std::string const&, std::string&>::type type; + + static type + call(example::example_struct_iterator<Struct, 0> const& it) + { + return it.struct_.name; + } + }; + + template<typename Struct> + struct apply<example::example_struct_iterator<Struct, 1> > + { + typedef typename mpl::if_< + is_const<Struct>, int const&, int&>::type type; + + static type + call(example::example_struct_iterator<Struct, 1> const& it) + { + return it.struct_.age; + } + }; + }; +} ++
+ The use of deref_impl is + very similar to that of value_of_impl, + but it also provides some runtime functionality this time via the call static member function. To see how + deref_impl is used, lets + have a look at the implementation of deref: +
++namespace result_of +{ + template <typename Iterator> + struct deref + : extension::deref_impl<typename detail::tag_of<Iterator>::type>:: + template apply<Iterator> + {}; +} + +template <typename Iterator> +typename result_of::deref<Iterator>::type +deref(Iterator const& i) +{ + typedef result_of::deref<Iterator> deref_meta; + return deref_meta::call(i); +} ++
+ So again result_of::deref uses tag + dispatching in exactly the same way as the value_of implementation. The runtime + functionality used by deref is provided by the call static function of the selected MPL + Metafunction Class. +
++ The actual implementation of deref_impl + is slightly more complex than that of value_of_impl. + We also need to implement the call + function, which returns a reference to the appropriate member of the underlying + sequence. We also require a little bit of metaprogramming to return const references if the underlying sequence + is const. +
+ |
+Note | +
|---|---|
+ Although there is a fair amount of left to do to produce a fully fledged + Fusion sequence, value_of and deref illustrate all the signficant + concepts required. The remainder of the process is very repetitive, simply + requiring implementation of a suitable xxxx_impl + for each feature xxxx. + | |
+ Ok, now we have seen the way value_of and deref work, everything else will + work in pretty much the same way. Lets start with forward iteration, by providing + a next_impl: +
++template<> +struct next_impl<example::example_struct_iterator_tag> +{ + template<typename Iterator> + struct apply + { + typedef typename Iterator::struct_type struct_type; + typedef typename Iterator::index index; + typedef example::example_struct_iterator<struct_type, index::value + 1> type; + + static type + call(Iterator const& i) + { + return type(i.struct_); + } + }; +}; ++
+ This should be very familiar from our deref_impl + implementation, we will be using this approach again and again now. Our design + is simply to increment the index + counter to move on to the next element. The various other iterator manipulations + we need to perform will all just involve simple calculations with the index variables. +
++ We also need to provide a suitable equal_to_impl + so that iterators can be correctly compared. A Bidirectional + Iterator will also need an implementation of prior_impl. + For a Random + Access Iterator distance_impl + and advance_impl also need + to be provided in order to satisfy the necessary complexity guarantees. As + our iterator is a Random + Access Iterator we will have to implement all of these functions. +
++ Full implementations of prior_impl, + advance_impl, distance_impl and equal_to_impl + are provided in the example code. +
++ In order that Fusion can correctly identify our sequence as a Fusion sequence, + we need to enable is_sequence + for our sequence type. As usual we just create an impl + type specialized for our sequence tag: +
++template<> +struct is_sequence_impl<example::example_sequence_tag> +{ + template<typename T> + struct apply : mpl::true_ {}; +}; ++
+ We've some similar formalities to complete, providing category_of_impl + so Fusion can correctly identify our sequence type, and is_view_impl + so Fusion can correctly identify our sequence as not being a View + type. Implementations are provide in the example code. +
++ Now we've completed some formalities, on to more interesting features. Lets + get begin working so that we can get + an iterator to start accessing the data in our sequence. +
++template<> +struct begin_impl<example::example_sequence_tag> +{ + template<typename Sequence> + struct apply + { + typedef example::example_struct_iterator<Sequence, 0> type; + + static type + call(Sequence& seq) + { + return type(seq); + } + }; +}; ++
+ The implementation uses the same ideas we have applied throughout, in this + case we are just creating one of the iterators we developed earlier, pointing + to the first element in the sequence. The implementation of end is very similar, and is provided + in the example code. +
++ For our Random + Access Sequence we will also need to implement size_impl, + value_at_impl and at_impl. +
++ In order for example_struct + to serve as an associative container, we need to enable 3 lookup features, + at_key, value_at_key and has_key. We also need to provide + an implementation of the is_associative + trait so that our sequence can be correctly identified as an associative + container. +
++ To implement at_key_impl + we need to associate the fields::age and + fields::age types described in the Quick + Start guide with the appropriate members of example_struct. + Our implementation is as follows: +
++template<> +struct at_key_impl<example::example_sequence_tag> +{ + template<typename Sequence, typename Key> + struct apply; + + template<typename Sequence> + struct apply<Sequence, fields::name> + { + typedef typename mpl::if_< + is_const<Sequence>, + std::string const&, + std::string&>::type type; + + static type + call(Sequence& seq) + { + return seq.name; + }; + }; + + template<typename Sequence> + struct apply<Sequence, fields::age> + { + typedef typename mpl::if_< + is_const<Sequence>, + int const&, + int&>::type type; + + static type + call(Sequence& seq) + { + return seq.age; + }; + }; +}; ++
+ Its all very similar to the implementations we've seen previously, such as + deref_impl and value_of_impl. Instead of identifying the + members by index or position, we are now selecting them using the types + fields::name and fields::age. + The implementations of value_at_key_impl + and has_key_impl are equally + straightforward, and are provided in the example code, along with an implementation + of is_associative_impl. +
++ We've now worked through the entire process for adding a new random access + sequence and we've also enabled our type to serve as an associative container. + The implementation was slightly longwinded, but followed a simple repeating + pattern. +
++ The support for std::pair, MPL + sequences, and boost::array all use the same approach, and provide + additional examples of the approach for a variety of types. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The iterator_facade + template provides an intrusive mechanism for producing a conforming Fusion + iterator. +
++template<typename Derived, typename TravesalTag> +struct iterator_facade; ++
+ The user of iterator_facade derives his iterator type from a specialization + of iterator_facade and passes the derived iterator type as the first template + parameter. The second template parameter should be the traversal category + of the iterator being implemented. +
++ The user must the implement the key expressions required by their iterator + type. +
+Table 1.93. Parameters
+|
+ + Name + + |
+
+ + Description + + |
+
|---|---|
|
+ + iterator, It, It1, + It2 + + |
+
+ + A type derived from iterator_facade + + |
+
|
+ + N + + |
+
+ + An MPL + Integral Constant + + |
+
Table 1.94. Key Expressions
+|
+ + Expression + + |
+
+ + Result + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + iterator::template value_of<It>::type + + |
+
+ + The element stored at iterator position It + + |
+
+ + None + + |
+
|
+ + iterator::template deref<It>::type + + |
+
+ + The type returned when dereferencing an iterator of type It + + |
+
+ + None + + |
+
|
+ + iterator::template deref<It>::call(it) + + |
+
+ + Dereferences iterator it + + |
+
+ + None + + |
+
|
+ + iterator::template next<It>::type + + |
+
+ + The type of the next element from It + + |
+
+ + None + + |
+
|
+ + iterator::template next<It>::call(it) + + |
+
+ + The next iterator after it + + |
+
+ + None + + |
+
|
+ + iterator::template prior<It>::type + + |
+
+ + The type of the next element from It + + |
+
+ + None + + |
+
|
+ + iterator::template prior<It>::call(it) + + |
+
+ + The next iterator after it + + |
+
+ + None + + |
+
|
+ + iterator::template advance<It, N>::type + + |
+
+ + The type of an iterator advanced N + elements from It + + |
+
+ + Implemented in terms of next + and prior + + |
+
|
+ + iterator::template advance<It, N>::call(it) + + |
+
+ + An iterator advanced N + elements from it + + |
+
+ + Implemented in terms of next + and prior + + |
+
|
+ + iterator::template distance<It1, It2>::type + + |
+
+ + The distance between iterators of type It1 + and It2 as an MPL + Integral Constant + + |
+
+ + None + + |
+
|
+ + iterator::template distance<It1, It2>::call(it1, it2) + + |
+
+ + The distance between iterator it1 + and it2 + + |
+
+ + None + + |
+
|
+ + iterator::template equal_to<It1, It2>::type + + |
+
+ + The distance between iterators of type It1 + and It2 + + |
+
+ + boost::same_type<It1, It2>::type + + |
+
|
+ + iterator::template equal_to<It1, It2>::call(it1, it2) + + |
+
+ + The distance between iterators it1 + and it2 + + |
+
+ + boost::same_type<It1, It2>::type() + + |
+
+#include <boost/fusion/iterator/iterator_facade.hpp> +#include <boost/fusion/include/iterator_facade.hpp> ++
+ A full worked example using iterator_facade is provided in triple.cpp + in the extension examples. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ BOOST_FUSION_ADAPT_ASSOC_STRUCT is a macro that can be used to generate + all the necessary boilerplate to make an arbitrary struct into a model + of Random + Access Sequence and Associative + Sequence. +
++BOOST_FUSION_ADAPT_ASSOC_STRUCT( + struct_name + (member_type0, member_name0, key_type0) + (member_type1, member_name1, key_type1) + ... + ) ++
+BOOST_FUSION_ADAPT_ASSOC_STRUCT( + struct_name + (member_type0, member_name0, key_type0) + (member_type1, member_name1, key_type1) + ... + ) ++
+ The above macro generates the necessary code to adapt struct_name + as a model of Random + Access Sequence and Associative + Sequence. The sequence of (member_typeN, + member_nameN, + key_typeN) + triples declare the type, name and key type of each of the struct members + that will be part of the sequence. +
++ The macro should be used at global scope, and struct_name + should be the fully namespace qualified name of the struct to be converted. +
++ /adapted/struct/adapt_assoc_struct.hpp> +
++namespace demo +{ + struct employee + { + std::string name; + int age; + }; +} + +namespace keys +{ + struct name; + struct age; +} + +// demo::employee is now a Fusion sequence +// It is also an associative sequence with +// keys keys::name and keys::age present. +BOOST_FUSION_ADAPT_ASSOC_STRUCT( + demo::employee + (std::string, name, keys::name) + (int, age, keys::age)) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ BOOST_FUSION_ADAPT_STRUCT is a macro that can be used to generate all the + necessary boilerplate to make an arbitrary struct into a Random + Access Sequence. +
++BOOST_FUSION_ADAPT_STRUCT( + struct_name + (member_type0, member_name0) + (member_type1, member_name1) + ... + ) ++
+BOOST_FUSION_ADAPT_STRUCT( + struct_name, + (member_type0, member_name0) + (member_type1, member_name1) + ... + ) ++
+ The above macro generates the necessary code to adapt struct_name + as a model of Random + Access Sequence. The sequence of (member_typeN, + member_nameN) + pairs declare the type and names of each of the struct members that will + be part of the sequence. +
++ The macro should be used at global scope, and struct_name + should be the fully namespace qualified name of the struct to be converted. +
++ /adapted/struct/adapt_struct.hpp> +
++namespace demo +{ + struct employee + { + std::string name; + int age; + }; +} + +// demo::employee is now a Fusion sequence +BOOST_FUSION_ADAPT_STRUCT( + demo::employee + (std::string, name) + (int, age)) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The sequence_facade + template provides an intrusive mechanism for producing a conforming Fusion + iterator. +
++template<typename Derived, typename TravesalTag, typename IsView = mpl::false_> +struct sequence_facade; ++
+ The user of sequence_facade derives his sequence + type from a specialization of sequence_facade and passes the derived + sequence type as the first template parameter. The second template parameter + should be the traversal category of the sequence being implemented. The 3rd + parameter should be set to mpl::true_ + if the sequence is a view. +
++ The user must the implement the key expressions required by their sequence + type. +
+Table 1.91. Parameters
+|
+ + Name + + |
+
+ + Description + + |
+
|---|---|
|
+ + sequence, Seq + + |
+
+ + A type derived from sequence_facade + + |
+
|
+ + N + + |
+
+ + An MPL + Integral Constant + + |
+
Table 1.92. Key Expressions
+|
+ + Expression + + |
+
+ + Result + + |
+
|---|---|
|
+ + sequence::template begin<Seq>::type + + |
+
+ + The type of an iterator to the beginning of a sequence of type Seq + + |
+
|
+ + sequence::template begin<Seq>::call(seq) + + |
+
+ + An iterator to the beginning of sequence seq + + |
+
|
+ + sequence::template end<Seq>::type + + |
+
+ + The type of an iterator to the end of a sequence of type Seq + + |
+
|
+ + sequence::template end<Seq>::call(seq) + + |
+
+ + An iterator to the end of sequence seq + + |
+
|
+ + sequence::template size<Seq>::type + + |
+
+ + The size of a sequence of type Seq + as an MPL + Integral Constant + + |
+
|
+ + sequence::template size<Seq>::call(seq) + + |
+
+ + The size of sequence seq + + |
+
|
+ + sequence::template at<Seq, N>::type + + |
+
+ + The type of element N + in a sequence of type Seq + + |
+
|
+ + sequence::template at<Seq, N>::call(seq) + + |
+
+ + Element N in sequence + seq + + |
+
|
+ + sequence::template value_at<Sequence, N>::type + + |
+
+ + The type of the Nth + element in a sequence of type Seq + + |
+
+#include <boost/fusion/sequence/sequence_facade.hpp> +#include <boost/fusion/include/sequence_facade.hpp> ++
+ A full worked example using sequence_facade is provided in triple.cpp + in the extension examples. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Components to call functions and function objects and to make Fusion code callable + through a function object interface. +
++ /functional.hpp> +
++ What is a function call? +
++f (a,b,c) ++
+ It is a name and a tuple written next to each other, left-to-right. +
++ Although the C++ syntax does not allow to replace (a,b,c) + with some Fusion Sequence, introducing + yet another function provides a solution: +
++invoke(f,my_sequence) ++
+ Alternatively it is possible to apply a simple transformation to f + in order to achieve the same effect: +
++f tuple <=> f' (tuple) ++
+ Now, f' is an unary function that takes the arguments to + f as a tuple; f' + is the fused form of f. + Reading the above equivalence right-to-left to get the inverse transformation, + f is the unfused + form of f'. +
++ Having generic C++ code call back arbitrary functions provided by the client + used to be a heavily repetitive task, as different functions can differ in + arity, invocation syntax and other properties that might be part of the type. + Transporting arguments as Fusion sequences and factoring out the invocation + makes Fusion algorithms applicable to function arguments and also reduces the + problem to one invocation syntax and a fixed arity (instead of an arbitrary + number of arbitrary arguments times several syntactic variants times additional + properties). +
++ Transforming an unfused function into its fused counterpart allows n-ary calls + from an algorithm that invokes an unary Polymorphic + Function Object with Sequence + arguments. +
++ The library provides several function templates to invoke different kinds of + functions and adapters to transform them into fused form, respectively. Every + variant has a corresponding generator function template that returns an adapter + instance for the given argument. +
++ Transforming a fused function into its unfused counterpart allows to create + function objects to accept arbitrary calls. In other words, an unary function + object can be implemented instead of (maybe heavily overloaded) function templates + or function call operators. +
++ The library provides several adapter variants that implement this transformation, + ranging from strictly typed to fully generic. The latter provides a reusable, + approximate solution to The + Forwarding Problem. Every generic variant has a corresponding generator + function template that returns an adapter instance for the given argument. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ An unary Polymorphic Function + Object adapter template for Deferred + Callable Object target functions. It takes a Forward + Sequence that contains the arguments for the target function. +
++ The type of the target function is allowed to be const qualified or a reference. + Const qualification is preserved and propagated appropriately (in other + words, only const versions of operator() can be used + for a target function object that is const or, if the target function object + is held by value, the adapter is const - these semantics have nothing to + do with the const qualification of a member function, which is referring + to the type of object pointed to by this which is specified + with the first element in the sequence passed to the adapter). +
++ If the target function is a pointer to a class members, the corresponding + object can be specified as a reference, pointer, or smart pointer. In case + of the latter, a freestanding get_pointer function must + be defined (Boost provides this function for std::auto_ptr + and boost::shared_ptr). +
++ /functional/adapter/fused.hpp> +
++template <typename Function> +class fused; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Function + + |
++ + | +
+ + + |
+
Notation
++ A possibly const qualified Deferred + Callable Object type or reference type thereof +
+ An object convertible to R +
+ A Sequence of arguments that + are accepted by r +
+ An instance of fused<R> +
|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + fused<R>(r) + + |
+
+ + Creates a fused function as described above, initializes the target + function with r. + + |
+
|
+ + fused<R>() + + |
+
+ + Creates a fused function as described above, attempts to use R's default constructor. + + |
+
|
+ + f(s) + + |
+
+ + Calls r with the + elements in s as + its arguments. + + |
+
+fused< std::plus<long> > f; +assert(f(make_vector(1,2l)) == 3l); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ An unary Polymorphic Function + Object adapter template for a Polymorphic + Function Object target function. It takes a Forward + Sequence that contains the arguments for the target function. +
++ The type of the target function is allowed to be const qualified or a reference. + Const qualification is preserved and propagated appropriately (in other + words, only const versions of operator() can be used + for an target function object that is const or, if the target function + object is held by value, the adapter is const). +
++ /functional/adapter/fused_function_object.hpp> +
++template <class Function> +class fused_function_object; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Function + + |
+
+ + Polymorphic Function + Object type + + |
+
+ + + |
+
Notation
++ A possibly const qualified Polymorphic + Function Object type or reference type thereof +
+ An object convertible to R +
+ A Sequence of arguments that + are accepted by r +
+ An instance of fused<R> +
|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + fused_function_object<R>(r) + + |
+
+ + Creates a fused function as described above, initializes the target + function with r. + + |
+
|
+ + fused_function_object<R>() + + |
+
+ + Creates a fused function as described above, attempts to use R's default constructor. + + |
+
|
+ + f(s) + + |
+
+ + Calls r with the + elements in s as + its arguments. + + |
+
+template<class SeqOfSeqs, class Func> +typename result_of::transform< zip_view<SeqOfSeqs> const, + fused_function_object<Func const &> >::type +n_ary_transform(SeqOfSeqs const & s, Func const & f) +{ + return transform(zip_view<SeqOfSeqs>(s), + fused_function_object<Func const &>(f)); +} + +struct sub +{ + template <typename Sig> + struct result; + + template <class Self, typename T> + struct result< Self(T,T) > + { typedef typename remove_reference<T>::type type; }; + + template<typename T> + T operator()(T lhs, T rhs) const + { + return lhs - rhs; + } +}; + +void try_it() +{ + vector<int,float> a(2,2.0f); + vector<int,float> b(1,1.5f); + vector<int,float> c(1,0.5f); + assert(c == n_ary_transform(vector_tie(a,b), sub())); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ An unary Polymorphic Function + Object adapter template for Callable + Object target functions. It takes a Forward + Sequence that contains the arguments for the target function. +
++ The result is discared and the adapter's return type is void. +
++ The type of the target function is allowed to be const qualified or a reference. + Const qualification is preserved and propagated appropriately (in other + words, only const versions of operator() can be used + for a target function object that is const or, if the target function object + is held by value, the adapter is const - these semantics have nothing to + do with the const qualification of a member function, which is referring + to the type of object pointed to by this which is specified + with the first element in the sequence passed to the adapter). +
++ If the target function is a pointer to a members function, the corresponding + object can be specified as a reference, pointer, or smart pointer. In case + of the latter, a freestanding get_pointer function must + be defined (Boost provides this function for std::auto_ptr + and boost::shared_ptr). +
++ The target function must not be a pointer to a member object (dereferencing + such a pointer without returning anything does not make sense, so this + case is not implemented). +
++ /functional/adapter/fused_procedure.hpp> +
++template <typename Function> +class fused_procedure; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Function + + |
+
+ + Callable Object + type + + |
+
+ + + |
+
Notation
++ A possibly const qualified Callable + Object type or reference type thereof +
+ An object convertible to R +
+ A Sequence of arguments that + are accepted by r +
+ An instance of fused<R> +
|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + fused_procedure<R>(r) + + |
+
+ + Creates a fused function as described above, initializes the target + function with r. + + |
+
|
+ + fused_procedure<R>() + + |
+
+ + Creates a fused function as described above, attempts to use R's default constructor. + + |
+
|
+ + f(s) + + |
+
+ + Calls r with the + elements in s as + its arguments. + + |
+
+template<class SequenceOfSequences, class Func> +void n_ary_for_each(SequenceOfSequences const & s, Func const & f) +{ + for_each(zip_view<SequenceOfSequences>(s), + fused_procedure<Func const &>(f)); +} + +void try_it() +{ + vector<int,float> a(2,2.0f); + vector<int,float> b(1,1.5f); + using namespace boost::lambda; + n_ary_for_each(vector_tie(a,b), _1 -= _2); + assert(a == make_vector(1,0.5f)); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ An n-ary Polymorphic Function + Object adapter template for an unary Polymorphic + Function Object target function. When called, its arguments are + bundled to a Random + Access Sequence of references that is passed to the target function. + Non-const LValue arguments are transported as references to non-const, + otherwise references to const are used. +
+
+ 
Detecting mutable LValues on a per-argument basis
+ is currently a compile time expensive operation (see The
+ Forwarding Problem for details). Therefore, there are two, lightweight
+ and more restricted variants of this class template, unfused_lvalue_args and unfused_rvalue_args.
+
+ The type of the target function is allowed to be const qualified or a reference. + Const qualification is preserved and propagated appropriately (in other + words, only const versions of operator() can be used + if the target function object is const - or, in case the target function + object is held by value, the adapter is const). +
++ /functional/adapter/unfused_generic.hpp> +
++template <class Function> +class unfused_generic; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Function + + |
+
+ + An unary Polymorphic + Function Object + + |
+
+ + + |
+
Notation
++ A possibly const qualified, unary Polymorphic + Function Object type or reference type thereof +
+ An object convertible to F +
+ The type unfused_generic<F> +
+ An instance of UG, + initialized with f +
+ Arguments to ug +
|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + UG(f) + + |
+
+ + Creates a fused function as described above, initializes the target + function with f. + + |
+
|
+ + UG() + + |
+
+ + Creates a fused function as described above, attempts to use F's default constructor. + + |
+
|
+ + ug(a0...aN) + + |
+
+ + Calls f with a + Sequence that contains references + to the arguments a0...aN. + + |
+
+template <typename Function, typename T> +class fused_bound_1st +{ + typename traits::deduce<Function>::type fnc_deferred; + typename traits::deduce<T>::type xxx_bound; +public: + + fused_bound_1st(Function deferred, T bound) + : fnc_deferred(deferred), xxx_bound(bound) + { } + + template <typename Sig> + struct result; + + template <class Self, class Seq> + struct result< Self(Seq) > + : result_of::invoke< Function, typename result_of::push_front< + typename remove_reference<Seq>::type, T>::type > + { }; + + template <class Seq> + typename result< void(Seq) >::type operator()(Seq const & s) const + { + return invoke(fnc_deferred, push_front(s,xxx_bound)); + } +}; + +template <typename Function, typename T> +unfused_generic< fused_bound_1st<Function,T> > +bind_1st(Function f, T const & x) +{ + return unfused_generic< fused_bound_1st<Function,T> >( + fused_bound_1st<Function,T>(f,x) ); +} + +int test_func(int a, int b, int c) +{ + return a+b+c; +} + +void try_it() +{ + assert(bind_1st(& test_func,3)(-2,-1) == 0); + assert(bind_1st(std::plus<float>(), 1)(0.5f) == 1.5f); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ An n-ary Polymorphic Function + Object adapter template for an unary Polymorphic + Function Object target function. When called, its arguments are + bundled to a Random + Access Sequence of references that is passed to the target function + object. Only LValue arguments are accepted. +
++ The type of the target function is allowed to be const qualified or a reference. + Const qualification is preserved and propagated appropriately (in other + words, only const versions of operator() can be used + if the target function object is const - or, in case the target function + object is held by value, the adapter is const). +
++ /functional/adapter/unfused_lvalue_args.hpp> +
++template <class Function> +class unfused_lvalue_args; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Function + + |
+
+ + A unary Polymorphic + Function Object + + |
+
+ + + |
+
Notation
++ A possibly const qualified, unary Polymorphic + Function Object type or reference type thereof +
+ An object convertible to F +
+ The type unfused_lvalue_args<F> +
+ An instance of UL, + initialized with f +
+ Arguments to ul +
|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + UL(f) + + |
+
+ + Creates a fused function as described above, initializes the target + function with f. + + |
+
|
+ + UL() + + |
+
+ + Creates a fused function as described above, attempts to use F's default constructor. + + |
+
|
+ + ul(a0...aN) + + |
+
+ + Calls f with a + Sequence that contains references + to the arguments a0...aN. + + |
+
+struct fused_incrementer +{ + template <class Seq> + struct result + { + typedef void type; + }; + + template <class Seq> + void operator()(Seq const & s) const + { + for_each(s,++boost::lambda::_1); + } +}; + +void try_it() +{ + unfused_lvalue_args<fused_incrementer> increment; + int a = 2; char b = 'X'; + increment(a,b); + assert(a == 3 && b == 'Y'); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ An n-ary Polymorphic Function + Object adapter template for an unary Polymorphic + Function Object target function. When called, its arguments are + bundled to a Random + Access Sequence of references that is passed to the target function + object. All referenced objects in the sequence are const qualified. +
++ The type of the target function is allowed to be const qualified or a reference. + Const qualification is preserved and propagated appropriately (in other + words, only const versions of operator() can be used + if the target function object is const - or, in case the target function + object is held by value, the adapter is const). +
++ /functional/adapter/unfused_rvalue_args.hpp> +
++template <class Function> +class unfused_rvalue_args; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Function + + |
+
+ + A unary Polymorphic + Function Object + + |
+
+ + + |
+
Notation
++ A possibly const qualified, unary Polymorphic + Function Object type or reference type thereof +
+ An object convertible to F +
+ The type unfused_rvalue_args<F> +
+ An instance of UR, + initialized with f +
+ Arguments to ur +
|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + UR(f) + + |
+
+ + Creates a fused function as described above, initializes the target + function with f. + + |
+
|
+ + UR() + + |
+
+ + Creates a fused function as described above, attempts to use F's default constructor. + + |
+
|
+ + ur(a0...aN) + + |
+
+ + Calls f with a + Sequence that contains references + to the arguments a0...aN. + + |
+
+struct sequence_printer +{ + template <class Seq> + struct result + { + typedef void type; + }; + + template <class Seq> + void operator()(Seq const & s) const + { + std::cout << s << std::endl; + } +}; + +void try_it() +{ + unfused_rvalue_args<sequence_printer> print; + print(24,"bottles of beer in",'a',"box."); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ An n-ary Polymorphic Function + Object adapter template for an unary Polymorphic + Function Object target function. When called, its arguments are + bundled to a Random + Access Sequence that is passed to the target function object. +
++ The call operators of esulting function objects are strictly typed (in + other words, non-templatized) with the types from a Sequence. +
++ The type of the target function is allowed to be const qualified or a reference. + Const qualification is preserved and propagated appropriately (in other + words, only const versions of operator() can be used + if the target function object is const - or, in case the target function + object is held by value, the adapter is const). +
+
+ 
For Microsoft Visual C++ 7.1 (Visual Studio 2003)
+ the detection of the Function Object's const qualification easily causes
+ an internal error. Therefore the adapter is always treated as if it was
+ const.
+
+ If the type sequence passed to this template contains
+ non-reference elements, the element is copied only once - the call operator's
+ signature is optimized automatically to avoid by-value parameters.
+
+ /functional/adapter/unfused_typed.hpp> +
++template <class Function, class Sequence> +class unfused_typed; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Function + + |
+
+ + A unary Polymorphic + Function Object + + |
+
+ + + |
+
|
+ + Sequence + + |
+
+ + A Sequence + + |
+
+ + + |
+
Notation
++ A possibly const qualified, unary Polymorphic + Function Object type or reference type thereof +
+ An object convertible to F +
+ A Sequence of parameter types +
+ The type unfused_typed<F,S> +
+ An instance of UT, + initialized with f +
+ Arguments to ut, convertible + to the types in S +
|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + UT(f) + + |
+
+ + Creates a fused function as described above, initializes the target + function with f. + + |
+
|
+ + UT() + + |
+
+ + Creates a fused function as described above, attempts to use F's default constructor. + + |
+
|
+ + ut(a0...aN) + + |
+
+ + Calls f with an + instance of S (or + a subsequence of S + starting at the first element, if fewer arguments are given and + the overload hasn't been disabled) initialized with a0...aN. + + |
+
+struct add_assign // applies operator+= +{ + typedef void result_type; // for simplicity + + template <typename T> + void operator()(T & lhs, T const & rhs) const + { + lhs += rhs; + } +}; + +template <class Tie> +class fused_parallel_adder +{ + Tie tie_dest; +public: + explicit fused_parallel_adder(Tie const & dest) + : tie_dest(dest) + { } + + typedef void result_type; + + template <class Seq> + void operator()(Seq const & s) const + { + for_each( zip(tie_dest,s), fused<add_assign>() ); + } +}; + +// accepts a tie and creates a typed function object from it +struct fused_parallel_adder_maker +{ + template <typename Sig> + struct result; + + template <class Self, class Seq> + struct result< Self(Seq) > + { + typedef typename remove_reference<Seq>::type seq; + + typedef unfused_typed< fused_parallel_adder<seq>, + typename mpl::transform<seq, remove_reference<_> >::type > type; + }; + + template <class Seq> + typename result< void(Seq) >::type operator()(Seq const & tie) + { + return typename result< void(Seq) >::type( + fused_parallel_adder<Seq>(tie) ); + } +}; +unfused_lvalue_args<fused_parallel_adder_maker> parallel_add; + +void try_it() +{ + int a = 2; char b = 'X'; + // the second call is strictly typed with the types deduced from the + // first call + parallel_add(a,b)(3,2); + parallel_add(a,b)(3); + parallel_add(a,b)(); + assert(a == 8 && b == 'Z'); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A pointer to a function, a pointer to member function, a pointer to member + data, or a class type whose objects can appear immediately to the left + of a function call operator. +
++& a_free_function +& a_class::a_static_member_function +& a_class::a_nonstatic_data_member +& a_class::a_nonstatic_member_function +std::less<int>() +// using namespace boost; +bind(std::less<int>(), _1, 5) +lambda::_1 += lambda::_2; +fusion::make_fused_function_object(std::less<int>()) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Callable Object + types that work with Boost.ResultOf + to determine the result of a call. +
+Notation
++ A possibly const qualified Deferred Callable Object type +
+ Argument types +
+ Objects or references to objects with types A1 + ...AN +
+ Ti is Ai & + if ai is an LValue, + same as Ai, otherwise +
|
+ + Expression + + |
+
+ + Type + + |
+
|---|---|
|
+ + boost::result_of< F(T1 + ...TN) >::type + + |
+
+ + Result of a call with A1 + ...AN-typed + arguments + + |
+
+& a_free_function +& a_class::a_static_member_function +& a_class::a_nonstatic_data_member +& a_class::a_nonstatic_member_function +std::less<int>() +// using namespace boost; +bind(std::less<int>(), _1, 5) +// Note: Boost.Lambda expressions don't work with __boost_result_of__ +fusion::make_fused_function_object(std::less<int>()) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A non-member-pointer Deferred + Callable Object type. +
+Notation
++ A possibly const-qualified Polymorphic Function Object type +
+ An object or reference to an object of type F +
+ Argument types +
+ Objects or references to objects with types A1 + ...AN +
+ Ti is Ai & + if ai is an LValue, + same as Ai, otherwise +
|
+ + Expression + + |
+
+ + Return Type + + |
+
+ + Runtime Complexity + + |
+
|---|---|---|
|
+ + f(a1, + ...aN) + + |
+
+ + result_of< + F(T1, + ...TN) >::type + + |
+
+ + Unspecified + + |
+
+& a_free_function +& a_class::a_static_member_function +std::less<int>() +// using namespace boost; +bind(std::less<int>(), _1, 5) +// Note: Boost.Lambda expressions don't work with __boost_result_of__ +fusion::make_fused_function_object(std::less<int>()) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A non-member-pointer Callable + Object type: A pointer to a function or a class type whose objects + can appear immediately to the left of a function call operator. +
+Notation
++ A possibly const qualified Deferred Callable Object type +
+ An object or reference to an object of type F +
+ Argument types +
+ Objects or references to objects with types A1 + ...AN +
|
+ + Expression + + |
+
+ + Return Type + + |
+
+ + Runtime Complexity + + |
+
|---|---|---|
|
+ + f(a1, + ...aN) + + |
+
+ + Unspecified + + |
+
+ + Unspecified + + |
+
+& a_free_function +& a_class::a_static_member_function +std::less<int>() +// using namespace boost; +bind(std::less<int>(), _1, 5) +lambda::_1 += lambda::_2; +fusion::make_fused_function_object(std::less<int>()) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Creates a fused adapter for a given Deferred Callable Object. + The usual element + conversion is applied to the target function. +
++template <typename F> +inline typename make_fused<F>::type +make_fused(F const & f); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + f + + |
+
+ + Model of Deferred + Callable Object + + |
+
+ + The function to transform. + + |
+
+make_fused(f); ++
+ Return type: A specialization of fused. +
++ Semantics: Returns a fused adapter for f. +
++#include <boost/fusion/functional/generation/make_fused.hpp> +#include <boost/fusion/include/make_fused.hpp> ++
+float sub(float a, float b) { return a - b; } + +void try_it() +{ + vector<int,float> a(2,2.0f); + vector<int,float> b(1,1.5f); + vector<float,float> c(1.0f,0.5f); + assert(c == transform(zip(a,b), make_fused(& sub))); + assert(c == transform(zip(a,b), make_fused(std::minus<float>()))); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Creates a fused_function_object adapter + for a given Deferred + Callable Object. The usual element + conversion is applied to the target function. +
++template <typename F> +inline typename make_fused_function_object<F>::type +make_fused_function_object(F const & f); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + f + + |
+
+ + Model of Polymorphic + Function Object + + |
+
+ + The function to transform. + + |
+
+make_fused_function_object(f); ++
+ Return type: A specialization of fused_function_object. +
++ Semantics: Returns a fused_function_object adapter + for f. +
++#include <boost/fusion/functional/generation/make_fused_function_object.hpp> +#include <boost/fusion/include/make_fused_function_object.hpp> ++
+struct sub +{ + template <typename Sig> + struct result; + + template <class Self, typename T> + struct result< Self(T,T) > + { typedef typename remove_reference<T>::type type; }; + + template<typename T> + T operator()(T lhs, T rhs) const + { + return lhs - rhs; + } +}; + +void try_it() +{ + vector<int,float> a(2,2.0f); + vector<int,float> b(1,1.5f); + vector<int,float> c(1,0.5f); + assert(c == transform(zip(a,b), make_fused_function_object(sub()))); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Creates a fused_procedure adapter for + a given Deferred + Callable Object. The usual element + conversion applied to the target function. +
++template <typename F> +inline typename make_fused_procedure<F>::type +make_fused_procedure(F const & f); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + f + + |
+
+ + Model of Callable + Object + + |
+
+ + The function to transform. + + |
+
+make_fused_procedure(f); ++
+ Return type: A specialization of fused_procedure. +
++ Semantics: Returns a fused_procedure adapter for + f. +
++#include <boost/fusion/functional/generation/make_fused_procedure.hpp> +#include <boost/fusion/include/make_fused_procedure.hpp> ++
+vector<int,int,int> v(1,2,3); +using namespace boost::lambda; +make_fused_procedure(_1 += _2 - _3)(v); +assert(front(v) == 0); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Creates a unfused_generic adapter for + a given, unary Polymorphic + Function Object. The usual element + conversion is applied to the target function. +
++template <typename F> +inline typename make_unfused_generic<F>::type +make_unfused_generic(F const & f); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + f + + |
+
+ + Model of Polymorphic + Function Object + + |
+
+ + The function to transform. + + |
+
+make_unfused_generic(f); ++
+ Return type: A specialization of unfused_generic. +
++ Semantics: Returns a unfused_generic adapter for + f. +
++#include <boost/fusion/functional/generation/make_unfused_generic.hpp> +#include <boost/fusion/include/make_unfused_generic.hpp> ++
+struct bottles_song +{ + typedef void result_type; + + template<class Seq> + void operator()(Seq & s) const + { + typename result_of::at_c<Seq,0>::type n = at_c<0>(s); + typename result_of::at_c<Seq,1>::type what = at_c<1>(s); + + std::cout + << n << " bottles of " << what << " on the wall.\n" + << n << " bottles of " << what << "!\n" + << "Take one down - pass it around.\n"; + + n -= 1; // glug glug... + + std::cout + << n << " bottles of " << what << " on the wall.\n" + << std::endl; + } +}; + +void try_it() +{ + unsigned n_milk = 99; + for(int i = 0; i < 3; ++i) + make_unfused_generic(bottles_song())(n_milk,"milk"); + // 96 bottles left for me +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Creates a unfused_lvalue_args adapter + for a given, unary Polymorphic + Function Object. The usual element + conversion is applied to the target function. +
++template <typename F> +inline typename make_unfused_lvalue_args<F>::type +make_unfused_lvalue_args(F const & f); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + f + + |
+
+ + Model of Polymorphic + Function Object + + |
+
+ + The function to transform. + + |
+
+make_unfused_lvalue_args(f); ++
+ Return type: A specialization of unfused_lvalue_args. +
++ Semantics: Returns a unfused_lvalue_args adapter + for f. +
++#include <boost/fusion/functional/generation/make_unfused_lvalue_args.hpp> +#include <boost/fusion/include/make_unfused_lvalue_args.hpp> ++
+struct fused_incrementer +{ + template <class Seq> + struct result + { + typedef void type; + }; + + template <class Seq> + void operator()(Seq const & s) const + { + for_each(s,++boost::lambda::_1); + } +}; + +void try_it() +{ + int a = 2; char b = 'X'; + make_unfused_lvalue_args(fused_incrementer())(a,b); + assert(a == 3 && b == 'Y'); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Creates a unfused_rvalue_args adapter + for a given, unary Polymorphic + Function Object. The usual element + conversion is applied to the target function. +
++template <typename F> +inline typename make_unfused_rvalue_args<F>::type +make_unfused_rvalue_args(F const & f); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + f + + |
+
+ + Model of Polymorphic + Function Object + + |
+
+ + The function to transform. + + |
+
+make_unfused_rvalue_args(f); ++
+ Return type: A specialization of unfused_rvalue_args. +
++ Semantics: Returns a unfused_rvalue_args adapter + for f. +
++#include <boost/fusion/functional/generation/make_unfused_rvalue_args.hpp> +#include <boost/fusion/include/make_unfused_rvalue_args.hpp> ++
+struct sequence_printer +{ + template <class Seq> + struct result + { + typedef void type; + }; + + template <class Seq> + void operator()(Seq const & s) const + { + std::cout << s << std::endl; + } +}; + +void try_it() +{ + make_unfused_rvalue_args(sequence_printer()) + (24,"bottles of beer in",'a',"box."); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_fused. +
++#include <boost/fusion/functional/generation/make_fused.hpp> +#include <boost/fusion/include/make_fused.hpp> ++
+namespace result_of +{ + template<typename Function> + struct make_fused + { + typedef unspecified type; + }; +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_fused_function_object. +
++#include <boost/fusion/functional/generation/make_fused_function_object.hpp> +#include <boost/fusion/include/make_fused_function_object.hpp> ++
+namespace result_of +{ + template<typename Function> + struct make_fused_function_object + { + typedef unspecified type; + }; +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_fused_procedure. +
++#include <boost/fusion/functional/generation/make_fused_procedure.hpp> +#include <boost/fusion/include/make_fused_procedure.hpp> ++
+namespace result_of +{ + template<typename Function> + struct make_fused_procedure + { + typedef unspecified type; + }; +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_unfused_generic. +
++#include <boost/fusion/functional/generation/make_unfused_generic.hpp> +#include <boost/fusion/include/make_unfused_generic.hpp> ++
+namespace result_of +{ + template<typename Function> + struct make_unfused_generic + { + typedef unspecified type; + }; +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_unfused_lvalue_args. +
++#include <boost/fusion/functional/generation/make_unfused_lvalue_args.hpp> +#include <boost/fusion/include/make_unfused_lvalue_args.hpp> ++
+namespace result_of +{ + template<typename Function> + struct make_unfused_lvalue_args + { + typedef unspecified type; + }; +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of make_unfused_rvalue_args. +
++#include <boost/fusion/functional/generation/make_unfused_rvalue_args.hpp> +#include <boost/fusion/include/make_unfused_rvalue_args.hpp> ++
+namespace result_of +{ + template<typename Function> + struct make_unfused_rvalue_args + { + typedef unspecified type; + }; +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Calls a Deferred + Callable Object with the arguments from a Sequence. +
++ The first template parameter can be specialized explicitly to avoid copying + and/or to control the const qualification of a function object. +
++ If the target function is a pointer to a class members, the corresponding + object can be specified as a reference, pointer, or smart pointer. In + case of the latter, a freestanding get_pointer function + must be defined (Boost provides this function for std::auto_ptr + and boost::shared_ptr). +
++template< + typename Function, + class Sequence + > +typename result_of::invoke<Function, Sequence>::type +invoke(Function f, Sequence & s); + +template< + typename Function, + class Sequence + > +typename result_of::invoke<Function, Sequence const>::type +invoke(Function f, Sequence const & s); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + f + + |
++ + | +
+ + The function to call. + + |
+
|
+ + s + + |
+
+ + A Forward + Sequence + + |
+
+ + The arguments. + + |
+
+invoke(f,s); ++
+ Return type: Return type of f when invoked with the elements in + s as its arguments. +
++ Semantics: Invokes f + with the elements in s + as arguments and returns the result of the call expression. +
++ /functional/invocation/invoke.hpp> +
++std::plus<int> add; +assert(invoke(add,make_vector(1,1)) == 2); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Calls a Polymorphic Function + Object with the arguments from a Sequence. +
++ The first template parameter can be specialized explicitly to avoid copying + and/or to control the const qualification of a function object. +
++template< + typename Function, + class Sequence + > +typename result_of::invoke_function_object<Function, Sequence>::type +invoke_function_object(Function f, Sequence & s); + +template< + typename Function, + class Sequence + > +typename result_of::invoke_function_object<Function, Sequence const>::type +invoke_function_object(Function f, Sequence const & s); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + f + + |
+
+ + Model of Polymorphic + Function Object + + |
+
+ + The function object to call. + + |
+
|
+ + s + + |
+
+ + Model of Forward + Sequence + + |
+
+ + The arguments. + + |
+
+invoke_function_object(f,s); ++
+ Return type: Return type of f when invoked with the elements in + s as its arguments. +
++ Semantics: Invokes f + with the elements in s + as arguments and returns the result of the call expression. +
++ /functional/invocation/invoke_function_object.hpp> +
++struct sub +{ + template <typename Sig> + struct result; + + template <class Self, typename T> + struct result< Self(T,T) > + { typedef typename remove_reference<T>::type type; }; + + template<typename T> + T operator()(T lhs, T rhs) const + { + return lhs - rhs; + } +}; + +void try_it() +{ + sub f; + assert(f(2,1) == invoke_function_object(f,make_vector(2,1))); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Calls a Callable + Object with the arguments from a Sequence. + The result of the call is ignored. +
++ The first template parameter can be specialized explicitly to avoid copying + and/or to control the const qualification of a function object. +
++ For pointers to class members corresponding object can be specified as + a reference, pointer, or smart pointer. In case of the latter, a freestanding + get_pointer function must be defined (Boost provides + this function for std::auto_ptr and boost::shared_ptr). +
++ The target function must not be a pointer to a member object (dereferencing + such a pointer without returning anything does not make sense, so it + isn't implemented). +
++template< + typename Function, + class Sequence + > +typename result_of::invoke_procedure<Function, Sequence>::type +invoke_procedure(Function f, Sequence & s); + +template< + typename Function, + class Sequence + > +typename result_of::invoke_procedure<Function, Sequence const>::type +invoke_procedure(Function f, Sequence const & s); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + f + + |
+
+ + Model of Callable + Object + + |
+
+ + The function to call. + + |
+
|
+ + s + + |
+
+ + Model of Forward + Sequence + + |
+
+ + The arguments. + + |
+
+invoke_procedure(f,s); ++
+ Return type: void +
++ Semantics: Invokes f + with the elements in s + as arguments. +
++ /functional/invocation/invoke_procedure.hpp> +
++vector<int,int> v(1,2); +using namespace boost::lambda; +invoke_procedure(_1 += _2, v); +assert(front(v) == 3); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of invoke. +
++namespace result_of +{ + template< + typename Function, + class Sequence + > + struct invoke + { + typedef unspecified type; + }; +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of invoke_function_object. +
++namespace result_of +{ + template< + class Function, + class Sequence + > + struct invoke_function_object + { + typedef unspecified type; + }; +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of invoke_procedure. +
++namespace result_of +{ + template< + typename Function, + class Sequence + > + struct invoke_procedure + { + typedef unspecified type; + }; +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ An advantage other languages such as Python and Lisp/ Scheme, ML and Haskell, + etc., over C++ is the ability to have heterogeneous containers that can hold + arbitrary element types. All the containers in the standard library can only + hold a specific type. A vector<int> + can only hold ints. A list<X> can + only hold elements of type X, + and so on. +
++ True, you can use inheritance to make the containers hold different types, + related through subclassing. However, you have to hold the objects through + a pointer or smart reference of some sort. Doing this, you'll have to rely + on virtual functions to provide polymorphic behavior since the actual type + is erased as soon as you store a pointer to a derived class to a pointer to + its base. The held objects must be related: you cannot hold objects of unrelated + types such as char, int, class + X, float, + etc. Oh sure you can use something like Boost.Any + to hold arbitrary types, but then you pay more in terms of runtime costs and + due to the fact that you practically erased all type information, you'll have + to perform dangerous casts to get back the original type. +
++ The Boost.Tuple + library written by Jaakko + Jarvi provides heterogeneous containers in C++. The tuple + is a basic data structure that can hold heterogeneous types. It's a good first + step, but it's not complete. What's missing are the algorithms. It's nice that + we can store and retrieve data to and from tuples, pass them around as arguments + and return types. As it is, the Boost.Tuple + facility is already very useful. Yet, as soon as you use it more often, usage + patterns emerge. Eventually, you collect these patterns into algorithm libraries. +
++ Hmmm, kinda reminds us of STL right? Right! Can you imagine how it would be + like if you used STL without the algorithms? Everyone will have to reinvent + their own algorithm wheels. +
++ Fusion is a library and a framework similar to both STL + and the boost MPL. + The structure is modeled after MPL, + which is modeled after STL. + It is named "fusion" because the library is reminiscent of the "fusion" + of compile time meta-programming with runtime programming. The library inherently + has some interesting flavors and characteristics of both MPL + and STL. + It lives in the twilight zone between compile time meta-programming and run + time programming. STL + containers work on values. MPL containers work on types. Fusion containers + work on both types and values. +
++ Unlike MPL, Fusion + algorithms are lazy and non sequence-type preserving. What does that mean? + It means that when you operate on a sequence through a Fusion algorithm that + returns a sequence, the sequence returned may not be of the same class as the + original. This is by design. Runtime efficiency is given a high priority. Like + MPL, and unlike + STL, + fusion algorithms are functional in nature such that algorithms are non mutating + (no side effects). However, due to the high cost of returning full sequences + such as vectors and lists, Views are returned from Fusion + algorithms instead. For example, the transform algorithm does not actually + return a transformed version of the original sequence. transform returns a transform_view. This view holds a + reference to the original sequence plus the transform function. Iteration over + the transform_view + will apply the transform function over the sequence elements on demand. This + lazy evaluation scheme allows us to chain as many algorithms + as we want without incurring a high runtime penalty. +
++ The lazy evaluation scheme where algorithms return views + allows operations such as push_back to be totally generic. In + Fusion, push_back is actually a generic algorithm + that works on all sequences. Given an input sequence s + and a value x, Fusion's push_back algorithm simply returns + a joint_view: + a view that holds a reference to the original sequence s + and the value x. Functions + that were once sequence specific and need to be implemented N times over N + different sequences are now implemented only once. +
++ Fusion provides full round compatibility with MPL. + Fusion sequences are fully conforming MPL + sequences and MPL + sequences are fully compatible with Fusion. You can work with Fusion sequences + on MPL if you + wish to work solely on types. In MPL, + Fusion sequences follow MPL's + sequence-type preserving semantics (i.e. algorithms preserve the original sequence + type. e.g. transforming a vector returns a vector). You can also convert from + an MPL sequence + to a Fusion sequence. For example, there are times when it is convenient to + work solely on MPL + using pure MPL + sequences, then, convert them to Fusion sequences as a final step before actual + instantiation of real runtime objects with data. You have the best of both + worlds. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Like MPL and + STL, + iterators are a fundamental concept in Fusion. As with MPL + and STL + iterators describe positions, and provide access to data within an underlying + Sequence. +
++ /iterator.hpp> +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Fusion iterators are divided into different traversal categories. Forward + Iterator is the most basic concept. Bidirectional + Iterator is a refinement of Forward + Iterator. Random + Access Iterator is a refinement of Bidirectional + Iterator. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A Bidirectional Iterator traverses a Sequence + allowing movement in either direction one element at a time. +
+Notation
++ A Bidirectional Iterator +
+ A Bidirectional Iterator type +
+ An MPL + integral constant +
+ An integral constant +
+ Forward Iterator +
++ In addition to the requirements defined in Forward + Iterator, the following expressions must be valid: +
+|
+ + Expression + + |
+
+ + Return type + + |
+
+ + Runtime Complexity + + |
+
|---|---|---|
|
+ + next(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + prior(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + advance_c<N>(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + advance<M>(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + Expression + + |
+
+ + Compile Time Complexity + + |
+
|---|---|
|
+ + result_of::prior<I>::type + + |
+
+ + Amortized constant time + + |
+
+ The semantics of an expression are defined only where they differ from, + or are not defined in Forward + Iterator +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + prior(i) + + |
+
+ + An iterator to the element preceding i + + |
+
+ In addition to the invariants of Forward + Iterator, the following invariants always hold: +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A Forward Iterator traverses a Sequence + allowing movement in only one direction through it's elements, one element + at a time. +
+Notation
++ Forward Iterators +
+ Forward Iterator types +
+ An MPL + integral constant +
+ An integral constant +
+ A type models Forward Iterator if, in addition to being CopyConstructable, + the following expressions are valid: +
+|
+ + Expression + + |
+
+ + Return type + + |
+
+ + Runtime Complexity + + |
+
|---|---|---|
|
+ + next(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + i == + j + + |
+
+ + Convertible to bool + + |
+
+ + Constant + + |
+
|
+ + i != + j + + |
+
+ + Convertible to bool + + |
+
+ + Constant + + |
+
|
+ + advance_c<N>(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + advance<M>(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + distance(i, + j) + + |
+
+ + result_of::distance<I, + J>::type + + |
+
+ + Constant + + |
+
|
+ + deref(i) + + |
+
+ + result_of::deref<I>::type + + |
+
+ + Constant + + |
+
|
+ + *i + + |
+
+ + result_of::deref<I>::type + + |
+
+ + Constant + + |
+
|
+ + Expression + + |
+
+ + Compile Time Complexity + + |
+
|---|---|
|
+ + result_of::next<I>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::equal_to<I, + J>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::advance_c<I, + N>::type + + |
+
+ + Linear + + |
+
|
+ + result_of::advance<I ,M>::type + + |
+
+ + Linear + + |
+
|
+ + result_of::distance<I ,J>::type + + |
+
+ + Linear + + |
+
|
+ + result_of::deref<I>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::value_of<I>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + next(i) + + |
+
+ + An iterator to the element following i + + |
+
|
+ + i == + j + + |
+
+ + Iterator equality comparison + + |
+
|
+ + i != + j + + |
+
+ + Iterator inequality comparison + + |
+
|
+ + advance_c<N>(i) + + |
+
+ + An iterator n elements after i + in the sequence + + |
+
|
+ + advance<M>(i) + + |
+
+ + Equivalent to advance_c<M::value>(i) + + |
+
|
+ + distance(i, + j) + + |
+
+ + The number of elements between i + and j + + |
+
|
+ + deref(i) + + |
+
+ + The element at positioni + + |
+
|
+ + *i + + |
+
+ + Equivalent to deref(i) + + |
+
+ The following invariants always hold: +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A Random Access Iterator traverses a Sequence + moving in either direction, permitting efficient arbitrary distance movements + back and forward through the sequence. +
+Notation
++ Random Access Iterators +
+ Random Access Iterator types +
+ An MPL + integral constant +
+ An integral constant +
+ In addition to the requirements defined in Bidirectional + Iterator, the following expressions must be valid: +
+|
+ + Expression + + |
+
+ + Return type + + |
+
+ + Runtime Complexity + + |
+
|---|---|---|
|
+ + next(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + prior(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + advance_c<N>(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + advance<M>(i) + + |
++ + | +
+ + Constant + + |
+
|
+ + Expression + + |
+
+ + Compile Time Complexity + + |
+
|---|---|
|
+ + result_of::advance_c<I, + N>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::advance<I, + M>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::distance<I ,J>::type + + |
+
+ + Amortized constant time + + |
+
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Fusion provides functions for manipulating iterators, analogous to the similar + functions from the MPL + library. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Moves an iterator by a specified distance. +
++template< + typename I, + typename M + > +typename result_of::advance<I, M>::type advance(I const& i); ++
Table 1.6. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + i + + |
+
+ + Model of Forward + Iterator + + |
+
+ + Iterator to move relative to + + |
+
|
+ + N + + |
+
+ + An MPL + Integral Constant + + |
+
+ + Number of positions to move + + |
+
+advance<M>(i); ++
+ Return type: A model of the same iterator + concept as i. +
++ Semantics: Returns an iterator to the + element M positions from + i. If i + is a Bidirectional + Iterator then M + may be negative. +
++ /iterator/advance.hpp> +
++typedef vector<int,int,int> vec; + +vec v(1,2,3); +assert(deref(advance<mpl::int_<2> >(begin(v))) == 3); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Moves an iterator by a specified distance. +
++template< + typename I, + int N + > +typename result_of::advance_c<I, N>::type advance_c(I const& i); ++
Table 1.7. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + i + + |
+
+ + Model of Forward + Iterator + + |
+
+ + Iterator to move relative to + + |
+
|
+ + N + + |
+
+ + Integer constant + + |
+
+ + Number of positions to move + + |
+
+advance_c<N>(i); ++
+ Return type: A model of the same iterator + concept as i. +
++ Semantics: Returns an iterator to the + element N positions from + i. If i + is a Bidirectional + Iterator then N + may be negative. +
++ /iterator/advance.hpp> +
++typedef vector<int,int,int> vec; + +vec v(1,2,3); +assert(deref(advance_c<2>(begin(v))) == 3); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Deferences an iterator. +
++template< + typename I + > +typename result_of::deref<I>::type deref(I const& i); ++
Table 1.2. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + i + + |
+
+ + Model of Forward + Iterator + + |
+
+ + Operation's argument + + |
+
+deref(i); ++
+ Return type: result_of::deref<I>::type +
++ Semantics: Dereferences the iterator + i. +
++ /iterator/deref.hpp> +
++typedef vector<int,int&> vec; + +int i(0); +vec v(1,i); +assert(deref(begin(v)) == 1); +assert(deref(next(begin(v))) == 0); +assert(&(deref(next(begin(v)))) == &i); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the distance between 2 iterators. +
++template< + typename I, + typename J + > +typename result_of::distance<I, J>::type distance(I const& i, J const& j); ++
Table 1.5. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + i, j + + |
+
+ + Models of Forward + Iterator into the same sequence + + |
+
+ + The start and end points of the distance to be measured + + |
+
+distance(i,j); ++
+ Return type: int +
++ Semantics: Returns the distance between + iterators i and j. +
++ /iterator/distance.hpp> +
++typedef vector<int,int,int> vec; + +vec v(1,2,3); +assert(distance(begin(v), next(next(begin(v)))) == 2); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Moves an iterator 1 position forwards. +
++template< + typename I + > +typename result_of::next<I>::type next(I const& i); ++
Table 1.3. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + i + + |
+
+ + Model of Forward + Iterator + + |
+
+ + Operation's argument + + |
+
+next(i); ++
+ Return type: A model of the same iterator + concept as i. +
++ Semantics: Returns an iterator to the + next element after i. +
++ /iterator/next.hpp> +
++typedef vector<int,int,int> vec; + +vec v(1,2,3); +assert(deref(begin(v)) == 1); +assert(deref(next(begin(v))) == 2); +assert(deref(next(next(begin(v)))) == 3); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Moves an iterator 1 position backwards. +
++template< + typename I + > +typename result_of::prior<I>::type prior(I const& i); ++
Table 1.4. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + i + + |
+
+ + Model of Bidirectional + Iterator + + |
+
+ + Operation's argument + + |
+
+prior(i); ++
+ Return type: A model of the same iterator + concept as i. +
++ Semantics: Returns an iterator to the + element prior to i. +
++ /iterator/prior.hpp> +
++typedef vector<int,int> vec; + +vec v(1,2); +assert(deref(next(begin(v))) == 2); +assert(deref(prior(next(begin(v)))) == 1); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Moves an iterator a specified distance. +
++template< + typename I, + typename M + > +struct advance +{ + typedef unspecified type; +}; ++
Table 1.17. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + I + + |
+
+ + Model of Forward + Iterator + + |
+
+ + Iterator to move relative to + + |
+
|
+ + M + + |
+
+ + Model of MPL + Integral Constant + + |
+
+ + Number of positions to move + + |
+
+result_of::advance<I,M>::type ++
+ Return type: A model of the same iterator + concept as I. +
++ Semantics: Returns an iterator a distance + M from I. + If I is a Bidirectional + Iterator then M + may be negative. +
++ /iterator/advance.hpp> +
++typedef vector<int,double,char> vec; +typedef result_of::begin<vec>::type first; +typedef result_of::next<first>::type second; +typedef result_of::next<second>::type third; + +BOOST_MPL_ASSERT((result_of::equal_to<result_of::advance<first, boost::mpl::int_<2> >::type, third>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Moves an iterator by a specified distance. +
++template< + typename I, + int N + > +struct advance_c +{ + typedef unspecified type; +}; ++
Table 1.18. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + I + + |
+
+ + Model of Forward + Iterator + + |
+
+ + Iterator to move relative to + + |
+
|
+ + N + + |
+
+ + Integer constant + + |
+
+ + Number of positions to move + + |
+
+result_of::advance_c<I, N>::type ++
+ Return type: A model of the same iterator + concept as I. +
++ Semantics: Returns an iterator a distance + N from I. + If I is a Bidirectional + Iterator then N + may be negative. Equivalent to result_of::advance<I, boost::mpl::int_<N> >::type. +
++ /iterator/advance.hpp> +
++typedef vector<int,double,char> vec; +typedef result_of::begin<vec>::type first; +typedef result_of::next<first>::type second; +typedef result_of::next<second>::type third; + +BOOST_MPL_ASSERT((result_of::equal_to<result_of::advance_c<first, 2>::type, third>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the type that will be returned by dereferencing an iterator. +
++template< + typename I + > +struct deref +{ + typedef unspecified type; +}; ++
Table 1.12. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + I + + |
+
+ + Model of Forward + Iterator + + |
+
+ + Operation's argument + + |
+
+result_of::deref<I>::type ++
+ Return type: Any type +
++ Semantics: Returns the result of dereferencing + an iterator of type I. +
++ /iterator/deref.hpp> +
++typedef vector<int,int&> vec; +typedef const vec const_vec; +typedef result_of::begin<vec>::type first; +typedef result_of::next<first>::type second; + +typedef result_of::begin<const_vec>::type const_first; +typedef result_of::next<const_first>::type const_second; + +BOOST_MPL_ASSERT((boost::is_same<result_of::deref<first>::type, int&>)); +BOOST_MPL_ASSERT((boost::is_same<result_of::deref<second>::type, int&>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the distance between two iterators. +
++template< + typename I, + typename J + > +struct distance +{ + typedef unspecified type; +}; ++
Table 1.16. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + I, J + + |
+
+ + Models of Forward + Iterator into the same sequence + + |
+
+ + The start and end points of the distance to be measured + + |
+
+result_of::distance<I, J>::type ++
+ Return type: A model of MPL + Integral Constant. +
++ Semantics: Returns the distance between + iterators of types I and + J. +
++ /iterator/distance.hpp> +
++typedef vector<int,double,char> vec; +typedef result_of::begin<vec>::type first; +typedef result_of::next<first>::type second; +typedef result_of::next<second>::type third; +typedef result_of::distance<first,third>::type dist; + +BOOST_MPL_ASSERT_RELATION(dist::value, ==, 2); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a true-valued MPL + Integral Constant if I + and J are equal. +
++template< + typename I, + typename J + > +struct equal_to +{ + typedef unspecified type; +}; ++
Table 1.15. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + I, J + + |
+
+ + Any fusion iterators + + |
+
+ + Operation's arguments + + |
+
+result_of::equal_to<I, J>::type ++
+ Return type: A model of MPL + Integral Constant. +
++ Semantics: Returns boost::mpl::true_ + if I and J are iterators to the same position. + Returns boost::mpl::false_ otherwise. +
++ /iterator/equal_to.hpp> +
++typedef vector<int,double> vec; +typedef result_of::begin<vec>::type first; +typedef result_of::end<vec>::type last; +BOOST_MPL_ASSERT((result_of::equal_to<first, first>)); +BOOST_MPL_ASSERT_NOT((result_of::equal_to<first,last>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the type of the next iterator in a sequence. +
++template< + typename I + > +struct next +{ + typedef unspecified type; +}; ++
Table 1.13. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + I + + |
+
+ + Model of Forward + Iterator + + |
+
+ + Operation's argument + + |
+
+result_of::next<I>::type ++
+ Return type: A model of the same iterator + concept as I. +
++ Semantics: Returns an iterator to the + next element in the sequence after I. +
++ /iterator/next.hpp> +
++typedef vector<int,double> vec; +typedef result_of::next<result_of::begin<vec>::type>::type second; + +BOOST_MPL_ASSERT((boost::is_same<result_of::value_of<second>::type, double>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the type of the previous iterator in a sequence. +
++template< + typename I + > +struct prior +{ + typedef unspecified type; +}; ++
Table 1.14. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + I + + |
+
+ + Model of Bidirectional + Iterator + + |
+
+ + Operation's argument + + |
+
+result_of::prior<I>::type ++
+ Return type: A model of the same iterator + concept as I. +
++ Semantics: Returns an iterator to the + previous element in the sequence before I. +
++ /iterator/prior.hpp> +
++typedef vector<int,double> vec; +typedef result_of::next<result_of::begin<vec>::type>::type second; + +BOOST_MPL_ASSERT((boost::is_same<result_of::value_of<second>::type, double>)); + +typedef result_of::prior<second>::type first; +BOOST_MPL_ASSERT((boost::is_same<result_of::value_of<first>::type, int>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the type stored at the position of an iterator. +
++template< + typename I + > +struct value_of +{ + typedef unspecified type; +}; ++
Table 1.11. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + I + + |
+
+ + Model of Forward + Iterator + + |
+
+ + Operation's argument + + |
+
+result_of::value_of<I>::type ++
+ Return type: Any type +
++ Semantics: Returns the type stored in + a sequence at iterator position I. +
++ /iterator/value_of.hpp> +
++typedef vector<int,int&,const int&> vec; +typedef result_of::begin<vec>::type first; +typedef result_of::next<first>::type second; +typedef result_of::next<second>::type third; + +BOOST_MPL_ASSERT((boost::is_same<result_of::value_of<first>::type, int>)); +BOOST_MPL_ASSERT((boost::is_same<result_of::value_of<second>::type, int&>)); +BOOST_MPL_ASSERT((boost::is_same<result_of::value_of<third>::type, const int&>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Overloaded operators are provided to provide a more natural syntax for dereferencing + iterators, and comparing them for equality. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Compares 2 iterators for equality. +
++template< + typename I, + typename J + > +unspecified operator==(I const& i, J const& i); ++
Table 1.9. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + i, j + + |
+
+ + Any fusion iterators + + |
+
+ + Operation's arguments + + |
+
+i == j ++
+ Return type: Convertible to bool. +
++ Semantics: Equivalent to result_of::equal_to<I,J>::value + where I and J are the types of i + and j respectively. +
++ /iterator/equal_to.hpp> +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Compares 2 iterators for inequality. +
++template< + typename I, + typename J + > +unspecified operator==(I const& i, J const& i); ++
Table 1.10. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + i, j + + |
+
+ + Any fusion iterators + + |
+
+ + Operation's arguments + + |
+
+ Return type: Convertible to bool. +
++ Semantics: Equivalent to !result_of::equal_to<I,J>::value + where I and J are the types of i + and j respectively. +
++ /iterator/equal_to.hpp> +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Dereferences an iterator. +
++template< + typename I + > +typename result_of::deref<I>::type operator*(unspecified<I> const& i); ++
Table 1.8. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + i + + |
+
+ + Model of Forward + Iterator + + |
+
+ + Operation's argument + + |
+
+*i ++
+ Return type: Equivalent to the return + type of deref(i). +
++ Semantics: Equivalent to deref(i). +
++ /iterator/deref.hpp> +
++typedef vector<int,int&> vec; + +int i(0); +vec v(1,i); +assert(*begin(v) == 1); +assert(*next(begin(v)) == 0); +assert(&(*next(begin(v))) == &i); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ An interesting peculiarity of functions like at when applied to a Forward + Sequence like list + is that what could have been linear runtime complexity effectively becomes + constant O(1) due to compiler optimization of C++ inlined functions, however + deeply recursive (up to a certain compiler limit of course). Compile time complexity + remains linear. +
++ Associative sequences use function overloading to implement membership testing + and type associated key lookup. This amounts to constant runtime and amortized + constant compile time complexities. There is an overloaded function, f(k), for each key type k. The compiler chooses the appropriate function + given a key, k. +
++ Tag dispatching is a generic programming technique for selecting template specializations. + There are typically 3 components involved in the tag dispatching mechanism: +
++ For example, the fusion result_of::begin metafunction + is implemented as follows: +
++template <typename Sequence> +struct begin +{ + typedef typename + result_of::begin_impl<typename traits::tag_of<Sequence>::type>:: + template apply<Sequence>::type + type; +}; ++
+ In the case: +
++ Unlike MPL, there + is no extensibe sequence concept in fusion. This does not mean that Fusion + sequences are not extensible. In fact, all Fusion sequences are inherently + extensible. It is just that the manner of sequence extension in Fusion is diferent + from both STL + and MPL on account + of the lazy nature of fusion Algorithms. + STL + containers extend themselves in place though member functions such as push_back and insert. MPL + sequences, on the other hand, are extended through "intrinsic" functions + that actually return whole sequences. MPL + is purely functional and can not have side effects. For example, MPL's + push_back does not actually + mutate an mpl::vector. It can't do that. Instead, it returns + an extended mpl::vector. +
++ Like MPL, Fusion + too is purely functional and can not have side effects. With runtime efficiency + in mind, Fusion sequences are extended through generic functions that return + Views. Views + are sequences that do not actually contain data, but instead impart an alternative + presentation over the data from one or more underlying sequences. Views + are proxies. They provide an efficient yet purely functional way to work on + potentially expensive sequence operations. For example, given a vector, Fusion's push_back returns a joint_view, instead of an actual extended + vector. + A joint_view + holds a reference to the original sequence plus the appended data --making + it very cheap to pass around. +
++ Functions that take in elemental values to form sequences (e.g. make_list) convert their arguments + to something suitable to be stored as a sequence element. In general, the element + types are stored as plain values. Example: +
++make_list(1, 'x') ++
+ returns a list<int, + char>. +
++ There are a few exceptions, however. +
++ Arrays: +
++ Array arguments are deduced to reference to const types. For example + [14] + : +
++make_list("Donald", "Daisy") ++
+ creates a list + of type +
++list<const char (&)[7], const char (&)[6]> ++
+ Function pointers: +
++ Function pointers are deduced to the plain non-reference type (i.e. to plain + function pointer). Example: +
++void f(int i); + ... +make_list(&f); ++
+ creates a list + of type +
++list<void (*)(int)> ++
+ Fusion's generation functions (e.g. make_list) by default stores the element + types as plain non-reference types. Example: +
++void foo(const A& a, B& b) { + ... + make_list(a, b) ++
+ creates a list + of type +
++list<A, B> ++
+ Sometimes the plain non-reference type is not desired. You can use boost::ref + and boost::cref to store references or const references + (respectively) instead. The mechanism does not compromise const correctness + since a const object wrapped with ref results in a tuple element with const + reference type (see the fifth code line below). Examples: +
++ For example: +
++A a; B b; const A ca = a; +make_list(cref(a), b); // creates list<const A&, B> +make_list(ref(a), b); // creates list<A&, B> +make_list(ref(a), cref(b)); // creates list<A&, const B&> +make_list(cref(ca)); // creates list<const A&> +make_list(ref(ca)); // creates list<const A&> ++
+ See Boost.Ref for + details. +
+[14] + Note that the type of a string literal is an array of const characters, + not const char*. To get make_list to create a list with an element of a non-const + array type one must use the ref + wrapper (see boost::ref). +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The library is organized into layers of modules, with each module addressing + a particular area of responsibility. A module may not depend on modules in + higher layers. +
++ The library is organized in three layers: +
+++
++
++
+
+
+ The entire library is found in the "boost/fusion" + directory. Modules are organized in directories. Each module has its own header + file placed in the same directory with the actual module-directory. For example, + there exists "boost/fusion/support.hpp" + in the same directory as "boost/fusion/support". Everything, except + those found inside "detail" directories, is public. +
++ There is also a "boost/fusion/include/" + directory that contains all the headers to all the components and modules. + If you are unsure where to find a specific component or module, or don't want + to fuss with hierarchy and nesting, use this. +
++ The library is header-only. There is no need to build object files to link + against. +
++ If, for example, you want to use list, + depending on the granularity that you desire, you may do so by including one + of +
++#include <boost/fusion/container.hpp> +#include <boost/fusion/include/container.hpp> +#include <boost/fusion/container/list.hpp> +#include <boost/fusion/include/list.hpp> ++
+ The first includes all containers The second includes only list + [3] + . +
+[3] + Modules may contain smaller components. Header file information for each + component will be provided as part of the component's documentation. +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+++
++ “Algorithms + Data Structures = Programs.” +
++
+
++
++ --Niklaus Wirth +
++
+
+ Fusion is a library for working with heterogenous collections of data, commonly + referred to as tuples. A set of containers (vector, list, set and map) is provided, + along with views that provide a transformed presentation of their underlying + data. Collectively the containers and views are referred to as sequences, and + Fusion has a suite of algorithms that operate upon the various sequence types, + using an iterator concept that binds everything together. +
++ The architecture is modeled after MPL + which in turn is modeled after STL. + It is named "fusion" because the library is a "fusion" + of compile time metaprogramming with runtime programming. +
++ Tuples are powerful beasts. After having developed two significant projects + (Spirit and Phoenix) + that relied heavily metaprogramming, it became apparent that tuples are a powerful + means to simplify otherwise tricky tasks; especially those that require a combination + of metaprogramming and manipulation of heterogenous data types with values. + While MPL is + an extremely powerful metaprogramming tool, MPL + focuses on type manipulation only. Ultimately, you'll have to map these types + to real values to make them useful in the runtime world where all the real + action takes place. +
++ As Spirit and Phoenix + evolved, patterns and idioms related to tuple manipulation emerged. Soon, it + became clear that those patterns and idioms were best assembled in a tuples + algorithms library. David + Abrahams outlined such a scheme in 2002. At that time, it just so happened + that Spirit and Phoenix + had an adhoc collection of tuple manipulation and traversal routines. It was + an instant AHA! moment. +
++ Some icons are used to mark certain topics indicative of their relevance. These + icons precede some text to indicate: +
+Table 1.1. Icons
+|
+ + Icon + + |
+
+ + Name + + |
+
+ + Meaning + + |
+
|---|---|---|
|
+
+ |
+
+ + Note + + |
+
+ + Information provided is auxiliary but will give the reader a deeper insight + into a specific topic. May be skipped. + + |
+
|
+
+ |
+
+ + Alert + + |
+
+ + Information provided is of utmost importance. + + |
+
|
+
+ |
+
+ + Caution + + |
+
+ + A mild warning. + + |
+
|
+
+ |
+
+ + Tip + + |
+
+ + A potentially useful and helpful piece of information. + + |
+
+ This documentation is automatically generated by Boost QuickBook documentation + tool. QuickBook can be found in the Boost + Tools. +
++ Please direct all questions to Spirit's mailing list. You can subscribe to + the Spirit + Mailing List. The mailing list has a searchable archive. A search link + to this archive is provided in Spirit's + home page. You may also read and post messages to the mailing list through + Spirit General + NNTP news portal (thanks to Gmane). + The news group mirrors the mailing list. Here is a link to the archives: http://news.gmane.org/gmane.comp.parsers.spirit.general. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ I assume the reader is already familiar with tuples (Boost.Tuple) + and its ancestor std::pair. The tuple is a generalization of std::pair + for multiple heterogeneous elements (triples, quadruples, etc.). The tuple + is more or less a synonym for fusion's vector. +
++ For starters, we shall include all of Fusion's Sequence(s) + [1] + : +
++#include <boost/fusion/sequence.hpp> +#include <boost/fusion/include/sequence.hpp> ++
+ Let's begin with a vector + [2] + : +
++vector<int, char, std::string> stuff(1, 'x', "howdy"); +int i = at_c<0>(stuff); +char ch = at_c<1>(stuff); +std::string s = at_c<2>(stuff); ++
+ Just replace tuple for vector + and get for at_c and this is exactly like + Boost.Tuple. + Actually, either names can be used interchangeably. Yet, the similarity ends + there. You can do a lot more with Fusion vector or tuple. + Let's see some examples. +
++ First, let's include the algorithms: +
++#include <boost/fusion/algorithm.hpp> +#include <boost/fusion/include/algorithm.hpp> ++
+ Now, let's write a function object that prints XML of the form <type>data</type> + for each member in the tuple. +
++struct print_xml +{ + template <typename T> + void operator()(T const& x) const + { + std::cout + << '<' << typeid(x).name() << '>' + << x + << "</" << typeid(x).name() << '>' + ; + } +}; ++
+ Now, finally: +
++for_each(stuff, print_xml()); ++
+ That's it! for_each is a fusion algorithm. + It is a generic algorithm similar to STL's. + It iterates over the sequence and calls a user supplied function. In our case, + it calls print_xml's operator() for + each element in stuff. +
+![[Caution]](../../../../../doc/html/images/caution.png) |
+Caution | +
|---|---|
+ The result of typeid(x).name() is platform specific. The code here is + just for exposition. Of course you already know that :-) + | |
+ for_each is generic. With + print_xml, you can use it to + print just about any Fusion Sequence. +
++ Let's get a little cleverer. Say we wish to write a generic + function that takes in an arbitrary sequence and XML prints only those elements + which are pointers. Ah, easy. First, let's include the is_pointer + boost type trait: +
++#include <boost/type_traits/is_pointer.hpp> ++
+ Then, simply: +
++template <typename Sequence> +void xml_print_pointers(Sequence const& seq) +{ + for_each(filter_if<boost::is_pointer<_> >(seq), print_xml()); +} ++
+ filter_if is another Fusion + algorithm. It returns a filter_view, a conforming Fusion sequence. + This view reflects only those elements that pass the given predicate. In this + case, the predicate is boost::is_pointer<_>. + This "filtered view" is then passed to the for_each algorithm, which then prints + the "filtered view" as XML. +
++ Easy, right? +
++ Ok, moving on... +
++ Apart from vector, + fusion has a couple of other sequence types to choose from. Each sequence has + its own characteristics. We have list, set, map, plus a multitude of views that provide various ways to present + the sequences. +
++ Fusion's map + associate types with elements. It can be used as a cleverer replacement of + the struct. Example: +
++namespace fields +{ + struct name; + struct age; +} + +typedef map< + fusion::pair<fields::name, std::string> + , fusion::pair<fields::age, int> > +person; ++
+ map + is an associative sequence. Its elements are Fusion pairs which differ somewhat + from std::pair. Fusion pairs only contain one member, + with the type of their second template parameter. The first type parameter + of the pair is used as an index to the associated element in the sequence. + For example, given a a_person + of type, person, you can do: +
++using namespace fields; +std::string person_name = at_key<name>(a_person); +int person_age = at_key<age>(a_person); ++
+ Why go through all this trouble, you say? Well, for one, unlike the struct, we are dealing with a generic data structure. + There are a multitude of facilities available at your disposal provided out + of the box with fusion or written by others. With these facilities, introspection + comes for free, for example. We can write one serialization function (well, + two, if you consider loading and saving) that will work for all your fusion + maps. + Example: +
++struct saver +{ + template <typename Pair> + void operator()(Pair const& data) const + { + some_archive << data.second; + } +}; + +template <typename Stuff> +void save(Stuff const& stuff) +{ + for_each(stuff, saver()); +} ++
+ The save function is generic + and will work for all types of stuff + regardless if it is a person, + a dog or a whole alternate_universe. +
++ And... we've barely scratched the surface! You can compose and expand the data + structures, remove elements from the structures, find specific data types, + query the elements, filter out types for inspection, transform data structures, + etc. What you've seen is just the tip of the iceberg. +
+[1] + There are finer grained header files available if you wish to have more + control over which components to include (see section Orgainization + for details). +
[2] + Unless otherwise noted, components are in namespace boost::fusion. + For the sake of simplicity, code in this quick start implies using directives for the fusion components + we will be using. +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Like MPL, the + Sequence is a fundamental concept in Fusion. A Sequence may or may not actually + store or contain data. Container are + sequences that hold data. Views, on the + other hand, are sequences that do not store any data. Instead, they are proxies + that impart an alternative presentation over another sequence. All models of + Sequence have an associated Iterator + type that can be used to iterate through the Sequence's elements. +
++#include <boost/fusion/sequence.hpp> +#include <boost/fusion/include/sequence.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Fusion Sequences are organized into a hierarchy of concepts. +
++ Fusion's sequence traversal related concepts parallel Fusion's Iterator + Concepts. Forward + Sequence is the most basic concept. Bidirectional + Sequence is a refinement of Forward + Sequence. Random + Access Sequence is a refinement of Bidirectional + Sequence. These concepts pertain to sequence traversal. +
++ The Associative + Sequence concept is orthogonal to traversal. An Associative Sequence + allows efficient retrieval of elements based on keys. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ An Associative Sequence allows efficient retrieval of elements based on + keys. Like associative sequences in MPL, + and unlike associative containers in STL, + Fusion associative sequences have no implied ordering relation. Instead, + type identity is used to impose an equivalence relation on keys, and the + order in which sequence elements are traversed during iteration is left + unspecified. In addition, unlike STL, + Associative Sequences have mutable iterators. This is due to the fact that + there is no associated ordering relation and the runtime value of the keys + themselves do not have any effect on the associativity of the sequence. +
+Notation
++ An Associative Sequence +
+ An Associative Sequence type +
+ An arbitrary key type +
+ An arbitrary object +
+ A Sequence element +
+ For any Associative Sequence the following expressions must be valid: +
+|
+ + Expression + + |
+
+ + Return type + + |
+
+ + Type Requirements + + |
+
+ + Runtime Complexity + + |
+
|---|---|---|---|
|
+ + has_key<K>(s) + + |
+
+ + MPL + Boolean Constant. Convertible to bool. + + |
+
+ + + |
+
+ + Constant + + |
+
|
+ + at_key<K>(s) + + |
+
+ + Any type + + |
+
+ + + |
+
+ + Constant + + |
+
|
+ + at_key<K>(s) + = o + + |
+
+ + Any type + + |
+
+ + s is mutable and + e = + o, where e is the first element in the + sequence, is a valid expression. + + |
+
+ + Constant + + |
+
|
+ + Expression + + |
+
+ + Compile Time Complexity + + |
+
|---|---|
|
+ + result_of::has_key<S, + K>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::at_key<S, + K>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::value_at_key<S, + K>::type + + |
+
+ + Amortized constant time + + |
+
+ result_of::at_key<S, K> returns the actual type returned by
+ at_key<K>(s). In
+ most cases, this is a reference. Hence, there is no way to know the exact
+ element type using result_of::at_key<S, K>.The element at K
+ may actually be a reference to begin with. For this purpose, you can use
+ result_of::value_at_key<S, N>.
+
|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + has_key<K>(s) + + |
+
+ + A boolean Integral Constant c + such that c::value == + true if and only if there + is one or more elements with the key k + in s; see has_key. + + |
+
|
+ + at_key<K>(s) + + |
+
+ + The element associated with the key K + in the sequence s; + see at. + + |
+
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A Bidirectional Sequence is a Forward + Sequence whose iterators model Bidirectional + Iterator. +
++ Forward Sequence +
+Notation
++ A Forward Sequence +
+ A Forward Sequence type +
+ An arbitrary object +
+ A Sequence element +
+ In addition to the requirements defined in Forward + Sequence, for any Bidirectional Sequence the following must be met: +
+|
+ + Expression + + |
+
+ + Return type + + |
+
+ + Type Requirements + + |
+
+ + Runtime Complexity + + |
+
|---|---|---|---|
|
+ + begin(s) + + |
++ + | +
+ + + |
+
+ + Constant + + |
+
|
+ + end(s) + + |
++ + | +
+ + + |
+
+ + Constant + + |
+
|
+ + back(s) + + |
+
+ + Any type + + |
+
+ + + |
+
+ + Constant + + |
+
|
+ + back(s) + = o + + |
+
+ + Any type + + |
+
+ + s is mutable and + e = + o, where e is the first element in the + sequence, is a valid expression. + + |
+
+ + Constant + + |
+
|
+ + Expression + + |
+
+ + Compile Time Complexity + + |
+
|---|---|
|
+ + result_of::begin<S>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::end<S>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::back<S>::type + + |
+
+ + Amortized constant time + + |
+
+ The semantics of an expression are defined only where they differ from, + or are not defined in Forward + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + back(s) + + |
+
+ + The last element in the sequence; see back. + + |
+
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A Forward Sequence is a Sequence whose elements are arranged in a definite + order. The ordering is guaranteed not to change from iteration to iteration. + The requirement of a definite ordering allows the definition of element-by-element + equality (if the container's element type is Equality Comparable) and of + lexicographical ordering (if the container's element type is LessThan Comparable). +
+Notation
++ A Forward Sequence +
+ A Forward Sequence type +
+ An arbitrary object +
+ A Sequence element +
+ For any Forward Sequence the following expressions must be valid: +
+|
+ + Expression + + |
+
+ + Return type + + |
+
+ + Type Requirements + + |
+
+ + Runtime Complexity + + |
+
|---|---|---|---|
|
+ + begin(s) + + |
++ + | +
+ + + |
+
+ + Constant + + |
+
|
+ + end(s) + + |
++ + | +
+ + + |
+
+ + Constant + + |
+
|
+ + size(s) + + |
+
+ + MPL + Integral Constant. Convertible to int. + + |
+
+ + + |
+
+ + Constant + + |
+
|
+ + empty(s) + + |
+
+ + MPL + Boolean Constant. Convertible to bool. + + |
+
+ + + |
+
+ + Constant + + |
+
|
+ + front(s) + + |
+
+ + Any type + + |
+
+ + + |
+
+ + Constant + + |
+
|
+ + front(s) + = o + + |
+
+ + Any type + + |
+
+ + s is mutable and + e = + o, where e is the first element in the + sequence, is a valid expression. + + |
+
+ + Constant + + |
+
|
+ + Expression + + |
+
+ + Compile Time Complexity + + |
+
|---|---|
|
+ + result_of::begin<S>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::end<S>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::size<S>::type + + |
+
+ + Unspecified + + |
+
|
+ + result_of::empty<S>::type + + |
+
+ + Constant time + + |
+
|
+ + result_of::front<S>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + begin(s) + + |
+
+ + An iterator to the first element of the sequence; see begin. + + |
+
|
+ + end(s) + + |
+
+ + A past-the-end iterator to the sequence; see end. + + |
+
|
+ + size(s) + + |
+
+ + The size of the sequence; see size. + + |
+
|
+ + empty(s) + + |
+
+ + A boolean Integral Constant c + such that c::value == + true if and only if the + sequence is empty; see empty. + + |
+
|
+ + front(s) + + |
+
+ + The first element in the sequence; see front. + + |
+
+ For any Forward Sequence s the following invariants always hold: +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A Random Access Sequence is a Bidirectional + Sequence whose iterators model Random + Access Iterator. It guarantees constant time access to arbitrary + sequence elements. +
+Notation
++ A Random Access Sequence +
+ A Random Access Sequence type +
+ An MPL + Integral Constant +
+ An arbitrary object +
+ A Sequence element +
+ In addition to the requirements defined in Bidirectional + Sequence, for any Random Access Sequence the following must be met: +
+|
+ + Expression + + |
+
+ + Return type + + |
+
+ + Type Requirements + + |
+
+ + Runtime Complexity + + |
+
|---|---|---|---|
|
+ + begin(s) + + |
++ + | +
+ + + |
+
+ + Constant + + |
+
|
+ + end(s) + + |
++ + | +
+ + + |
+
+ + Constant + + |
+
|
+ + at<N>(s) + + |
+
+ + Any type + + |
+
+ + + |
+
+ + Constant + + |
+
|
+ + at<N>(s) + = o + + |
+
+ + Any type + + |
+
+ + s is mutable and + e = + o, where e is the first element in the + sequence, is a valid expression. + + |
+
+ + Constant + + |
+
|
+ + Expression + + |
+
+ + Compile Time Complexity + + |
+
|---|---|
|
+ + result_of::begin<S>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::end<S>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::at<S, + N>::type + + |
+
+ + Amortized constant time + + |
+
|
+ + result_of::value_at<S, + N>::type + + |
+
+ + Amortized constant time + + |
+
+ result_of::at<S, N> returns the actual type returned by
+ at<N>(s). In
+ most cases, this is a reference. Hence, there is no way to know the exact
+ element type using result_of::at<S, N>.The element at N
+ may actually be a reference to begin with. For this purpose, you can use
+ result_of::value_at<S, N>.
+
+ The semantics of an expression are defined only where they differ from, + or are not defined in Bidirectional + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + at<N>(s) + + |
+
+ + The Nth element from the beginning of the sequence; see at. + + |
+
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Intrinsic form the essential interface of every Fusion Sequence. + STL + counterparts of these functions are usually implemented as member functions. + Intrinsic functions, unlike Algorithms, + are not generic across the full Sequence + repertoire. They need to be implemented for each Fusion Sequence + [4] + . +
++#include <boost/fusion/sequence/intrinsic.hpp> +#include <boost/fusion/include/intrinsic.hpp> ++
[4] + In practice, many of intrinsic functions have default implementations + that will work in majority of cases +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the N-th element from the beginning of the sequence. +
++template <typename N, typename Sequence> +typename result_of::at<Sequence, N>::type +at(Sequence& seq); + +template <typename N, typename Sequence> +typename result_of::at<Sequence const, N>::type +at(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + Model of Random + Access Sequence + + |
+
+ + The sequence we wish to investigate. + + |
+
|
+ + N + + |
+
+ + An MPL + Integral Constant + + |
+
+ + An index from the beginning of the sequence. + + |
+
+at<N>(seq); ++
+ Return type: Returns a reference to + the N-th element from the beginning of the sequence seq + if seq is mutable and + e = + o, where e + is the N-th element from the beginning of the sequence, is a valid expression. + Else, returns a type convertable to the N-th element from the beginning + of the sequence. +
++ Precondition: 0 + <= N::value < size(s) +
++ Semantics: Equivalent to +
++deref(advance<N>(begin(s))) ++
+#include <boost/fusion/sequence/intrinsic/at.hpp> +#include <boost/fusion/include/at.hpp> ++
+vector<int, int, int> v(1, 2, 3); +assert(at<mpl::int_<1> >(v) == 2); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the N-th element from the beginning of the sequence. +
++template <int N, typename Sequence> +typename result_of::at_c<Sequence, N>::type +at_c(Sequence& seq); + +template <int N, typename Sequence> +typename result_of::at_c<Sequence const, N>::type +at_c(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + Model of Random + Access Sequence + + |
+
+ + The sequence we wish to investigate. + + |
+
|
+ + N + + |
+
+ + An integral constant + + |
+
+ + An index from the beginning of the sequence. + + |
+
+at_c<N>(seq); ++
+ Return type: Returns a reference to + the N-th element from the beginning of the sequence seq + if seq is mutable and + e = + o, where e + is the N-th element from the beginning of the sequence, is a valid expression. + Else, returns a type convertable to the N-th element from the beginning + of the sequence. +
++ Precondition: 0 + <= N + < size(s) +
++ Semantics: Equivalent to +
++deref(advance<N>(begin(s))) ++
+#include <boost/fusion/sequence/intrinsic/at_c.hpp> +#include <boost/fusion/include/at_c.hpp> ++
+vector<int, int, int> v(1, 2, 3); +assert(at_c<1>(v) == 2); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the element associated with a Key from the sequence. +
++template <typename Key, typename Sequence> +typename result_of::at_key<Sequence, Key>::type +at_key(Sequence& seq); + +template <typename Key, typename Sequence> +typename result_of::at_key<Sequence const, Key>::type +at_key(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + Model of Associative + Sequence + + |
+
+ + The sequence we wish to investigate. + + |
+
|
+ + Key + + |
+
+ + Any type + + |
+
+ + The queried key. + + |
+
+at_key<Key>(seq); ++
+ Return type: Returns a reference to + the element associated with Key from the sequence seq + if seq is mutable and + e = + o, where e + is the element associated with Key, is a valid expression. Else, returns + a type convertable to the element associated with Key. +
++ Precondition: has_key<Key>(seq) == true +
++ Semantics: Returns the element associated + with Key. +
++#include <boost/fusion/sequence/intrinsic/at_key.hpp> +#include <boost/fusion/include/at_key.hpp> ++
+set<int, char, bool> s(1, 'x', true); +assert(at_key<char>(s) == 'x'); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the last element in the sequence. +
++template <typename Sequence> +typename result_of::back<Sequence>::type +back(Sequence& seq); + +template <typename Sequence> +typename result_of::back<Sequence const>::type +back(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + Model of Bidirectional + Sequence + + |
+
+ + The sequence we wish to investigate. + + |
+
+back(seq); ++
+ Return type: Returns a reference to + the last element in the sequence seq + if seq is mutable and + e = + o, where e + is the last element in the sequence, is a valid expression. Else, returns + a type convertable to the last element in the sequence. +
++ Precondition: empty(seq) == false +
++ Semantics: Returns the last element + in the sequence. +
++#include <boost/fusion/sequence/intrinsic/back.hpp> +#include <boost/fusion/include/back.hpp> ++
+vector<int, int, int> v(1, 2, 3); +assert(back(v) == 3); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns an iterator pointing to the first element in the sequence. +
++template <typename Sequence> +typename result_of::begin<Sequence>::type +begin(Sequence& seq); + +template <typename Sequence> +typename result_of::begin<Sequence const>::type +begin(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + Model of Forward + Sequence + + |
+
+ + The sequence we wish to get an iterator from. + + |
+
+begin(seq); ++
+ Return type: Forward + Iterator if seq + is a Forward + Sequence else, Bidirectional + Iterator if seq + is a Bidirectional + Sequence else, Random + Access Iterator if seq + is a Random + Access Sequence. +
++ Semantics: Returns an iterator pointing + to the first element in the sequence. +
++#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/include/begin.hpp> ++
+vector<int, int, int> v(1, 2, 3); +assert(deref(begin(v)) == 1); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a type convertible to bool + that evaluates to true if + the sequence is empty, else, evaluates to false. +
++template <typename Sequence> +typename result_of::empty<Sequence>::type +empty(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + Model of Forward + Sequence + + |
+
+ + The sequence we wish to investigate. + + |
+
+empty(seq); ++
+ Return type: Convertible to bool. +
++ Semantics: Evaluates to true if the sequence is empty, else, evaluates + to false. +
++#include <boost/fusion/sequence/intrinsic/empty.hpp> +#include <boost/fusion/include/empty.hpp> ++
+vector<int, int, int> v(1, 2, 3); +assert(empty(v) == false); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns an iterator pointing to one element past the end of the sequence. +
++template <typename Sequence> +typename result_of::end<Sequence>::type +end(Sequence& seq); + +template <typename Sequence> +typename result_of::end<Sequence const>::type +end(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + Model of Forward + Sequence + + |
+
+ + The sequence we wish to get an iterator from. + + |
+
+end(seq); ++
+ Return type: Forward + Iterator if seq + is a Forward + Sequence else, Bidirectional + Iterator if seq + is a Bidirectional + Sequence else, Random + Access Iterator if seq + is a Random + Access Sequence. +
++ Semantics: Returns an iterator pointing + to one element past the end of the sequence. +
++#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/include/end.hpp> ++
+vector<int, int, int> v(1, 2, 3); +assert(deref(prior(end(v))) == 3); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the first element in the sequence. +
++template <typename Sequence> +typename result_of::front<Sequence>::type +front(Sequence& seq); + +template <typename Sequence> +typename result_of::front<Sequence const>::type +front(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + Model of Forward + Sequence + + |
+
+ + The sequence we wish to investigate. + + |
+
+front(seq); ++
+ Return type: Returns a reference to + the first element in the sequence seq + if seq is mutable and + e = + o, where e + is the first element in the sequence, is a valid expression. Else, returns + a type convertable to the first element in the sequence. +
++ Precondition: empty(seq) == false +
++ Semantics: Returns the first element + in the sequence. +
++#include <boost/fusion/sequence/intrinsic/front.hpp> +#include <boost/fusion/include/front.hpp> ++
+vector<int, int, int> v(1, 2, 3); +assert(front(v) == 1); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a type convertible to bool + that evaluates to true if + the sequence contains an element associated with a Key, else, evaluates + to false. +
++template <typename Key, typename Sequence> +typename result_of::has_key<Sequence, Key>::type +has_key(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + Model of Associative + Sequence + + |
+
+ + The sequence we wish to investigate. + + |
+
|
+ + Key + + |
+
+ + Any type + + |
+
+ + The queried key. + + |
+
+has_key<Key>(seq); ++
+ Return type: Convertible to bool. +
++ Semantics: Evaluates to true if the sequence contains an element + associated with Key, else, evaluates to false. +
++#include <boost/fusion/sequence/intrinsic/has_key.hpp> +#include <boost/fusion/include/has_key.hpp> ++
+set<int, char, bool> s(1, 'x', true); +assert(has_key<char>(s) == true); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns a type convertible to int + that evaluates the number of elements in the sequence. +
++template <typename Sequence> +typename result_of::size<Sequence>::type +size(Sequence const& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq + + |
+
+ + Model of Forward + Sequence + + |
+
+ + The sequence we wish to investigate. + + |
+
+size(seq); ++
+ Return type: Convertible to int. +
++ Semantics: Returns the number of elements + in the sequence. +
++#include <boost/fusion/sequence/intrinsic/size.hpp> +#include <boost/fusion/include/size.hpp> ++
+vector<int, int, int> v(1, 2, 3); +assert(size(v) == 3); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Performs an element by element swap of the elements in 2 sequences. +
++template<typename Seq1, typename Seq2> +void swap(Seq1& seq1, Seq2& seq2); ++
|
+ + Parameters + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + seq1, seq2 + + |
+
+ + Models of Forward + Sequence + + |
+
+ + The sequences whos elements we wish to swap. + + |
+
+swap(seq1, seq2); ++
+ Return type: void +
++ Precondition: size(seq1) == size(seq2) +
++ Semantics: Calls swap(a1, b1) for corresponding elements in seq1 and seq2. +
++ /sequence/intrinsic/swap.hpp> +
++vector<int, std::string> v1(1, "hello"), v2(2, "world"); +swap(v1, v2); +assert(v1 == make_vector(2, "world")); +assert(v2 == make_vector(1, "hello")); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of at + [5] + . +
++template< + typename Seq, + typename N> +struct at +{ + typedef unspecified type; +}; ++
Table 1.25. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
|
+ + N + + |
+
+ + An MPL + Integral Constant + + |
+
+ + Index of element + + |
+
+result_of::at<Seq, N>::type ++
+ Return type: Any type. +
++ Semantics: Returns the result type of + using at to access the Nth element of Seq. +
++ /sequence/intrinsic/at.hpp> +
++typedef vector<int,float,char> vec; +BOOST_MPL_ASSERT((boost::is_same<result_of::at<vec, boost::mpl::int_<1> >::type, float&>)); ++
[5] + result_of::at reflects the actual return + type of the function at. Sequence(s) + typically return references to its elements via the at function. If you want + to get the actual element type, use result_of::value_at +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of at_c + [6] + . +
++template< + typename Seq, + int M> +struct at_c +{ + typedef unspecified type; +}; ++
Table 1.26. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
|
+ + M + + |
+
+ + Positive integer index + + |
+
+ + Index of element + + |
+
+result_of::at_c<Seq, M>::type ++
+ Return type: Any type +
++ Semantics: Returns the result type of + using at_c to access the Mth element of Seq. +
++ /sequence/intrinsic/at.hpp> +
++typedef vector<int,float,char> vec; +BOOST_MPL_ASSERT((boost::is_same<result_of::at_c<vec, 1>::type, float&>)); ++
[6] + result_of::at_c reflects the actual + return type of the function at_c. Sequence(s) + typically return references to its elements via the at_c function. If you want + to get the actual element type, use result_of::value_at_c +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of at_key + [7] + . +
++template< + typename Seq, + typename Key> +struct at_key +{ + typedef unspecified type; +}; ++
Table 1.30. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
|
+ + Key + + |
+
+ + Any type + + |
+
+ + Key type + + |
+
+result_of::at_key<Seq, Key>::type ++
+ Return type: Any type. +
++ Semantics: Returns the result of using + at_key to access the element + with key type Key in + Seq. +
++ /sequence/intrinsic/at_key.hpp> +
++typedef map<pair<int, char>, pair<char, char>, pair<double, char> > mymap; +BOOST_MPL_ASSERT((boost::is_same<result_of::at_key<mymap, int>::type, char&>)); ++
[7] + result_of::at_key reflects the actual + return type of the function at_key. _sequence_s + typically return references to its elements via the at_key function. If you + want to get the actual element type, use result_of::value_at_key +
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of back. +
++template<typename Seq> +struct back +{ + typedef unspecified type; +}; ++
Table 1.23. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
+result_of::back<Seq>::type ++
+ Return type: Any type +
++ Semantics: The type returned by dereferencing + an iterator to the last element in the sequence. Equivalent to result_of::deref<result_of::prior<result_of::end<Seq>::type>::type>::type. +
++ /sequence/intrinsic/back.hpp> +
++typedef vector<int,char> vec; +BOOST_MPL_ASSERT((boost::is_same<result_of::back<vec>::type, char&>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of begin. +
++template<typename Seq> +struct begin +{ + typedef unspecified type; +}; ++
Table 1.19. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
+result_of::begin<Seq>::type ++
+ Return type: An iterator modelling the + same traversal concept as Seq. +
++ Semantics: Returns the type of an iterator + to the first element of Seq. +
++ /sequence/intrinsic/begin.hpp> +
++typedef vector<int> vec; +typedef result_of::begin<vec>::type it; +BOOST_MPL_ASSERT((boost::is_same<result_of::deref<it>::type, int&>)) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of empty. +
++template<typename Seq> +struct empty +{ + typedef unspecified type; +}; ++
Table 1.21. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
+result_of::empty<Seq>::type ++
+ Return type: An MPL + Integral Constant +
++ Semantics: Returns mpl::true_ + if Seq has zero elements, + mpl::false_ otherwise. +
++ /sequence/intrinsic/empty.hpp> +
++typedef vector<> empty_vec; +typedef vector<int,float,char> vec; + +BOOST_MPL_ASSERT((result_of::empty<empty_vec>)); +BOOST_MPL_ASSERT_NOT((result_of::empty<vec>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of end. +
++template<typename Seq> +struct end +{ + typedef unspecified type; +}; ++
Table 1.20. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
+result_of::end<Seq>::type ++
+ Return type: A model of the same traversal + concept as Seq. +
++ Semantics: Returns the type of an iterator + one past the end of Seq. +
++ /sequence/intrinsic/end.hpp> +
++typedef vector<int> vec; +typedef result_of::prior<result_of::end<vec>::type>::type first; +BOOST_MPL_ASSERT((result_of::equal_to<first, result_of::begin<vec>::type>)) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of front. +
++template<typename Seq> +struct front +{ + typedef unspecified type; +}; ++
Table 1.22. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
+result_of::front<Seq>::type ++
+ Return type: Any type +
++ Semantics: The type returned by dereferencing + an iterator to the first element in Seq. + Equivalent to result_of::deref<result_of::begin<Seq>::type>::type. +
++ /sequence/intrinsic/front.hpp> +
++typedef vector<int,char> vec; +BOOST_MPL_ASSERT((boost::is_same<result_of::front<vec>::type, int&>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of has_key. +
++template< + typename Seq, + typename Key> +struct has_key +{ + typedef unspecified type; +}; ++
Table 1.29. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
|
+ + Key + + |
+
+ + Any type + + |
+
+ + Key type + + |
+
+result_of::has_key<Seq, Key>::type ++
+ Return type: An MPL + Integral Constant. +
++ Semantics: Returns mpl::true_ + if Seq contains an element + with key type Key, returns + mpl::false_ otherwise. +
++ /sequence/intrinsic/has_key.hpp> +
++typedef map<pair<int, char>, pair<char, char>, pair<double, char> > mymap; +BOOST_MPL_ASSERT((result_of::has_key<mymap, int>)); +BOOST_MPL_ASSERT_NOT((result_of::has_key<mymap, void*>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the result type of size. +
++template<typename Seq> +struct size +{ + typedef unspecified type; +}; ++
Table 1.24. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
+result_of::size<Seq>::type ++
+ Return type: An MPL + Integral Constant. +
++ Semantics: Returns the number of elements + in Seq. +
++ /sequence/intrinsic/size.hpp> +
++typedef vector<int,float,char> vec; +typedef result_of::size<vec>::type size_mpl_integral_constant; +BOOST_MPL_ASSERT_RELATION(size_mpl_integral_constant::value, ==, 3); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the return type of swap. +
++template<typename Seq1, typename Seq2> +struct swap +{ + typedef void type; +}; ++
Table 1.32. Parameters
+|
+ + Parameters + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq1, Seq2 + + |
+
+ + Models of Forward + Sequence + + |
+
+ + The sequences being swapped + + |
+
+result_of::swap<Seq1, Seq2>::type ++
+ Return type: void. +
++ Semantics: Always returns void. +
++ /sequence/intrinsic/swap.hpp> +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the actual type at a given index from the Sequence. +
++template< + typename Seq, + typename N> +struct value_at +{ + typedef unspecified type; +}; ++
Table 1.27. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
|
+ + N + + |
+
+ + An MPL + Integral Constant + + |
+
+ + Index of element + + |
+
+result_of::value_at<Seq, N>::type ++
+ Return type: Any type. +
++ Semantics: Returns the actual type at + the Nth element of Seq. +
++ /sequence/intrinsic/value_at.hpp> +
++typedef vector<int,float,char> vec; +BOOST_MPL_ASSERT((boost::is_same<result_of::value_at<vec, boost::mpl::int_<1> >::type, float>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the actual type at a given index from the Sequence. +
++template< + typename Seq, + int M> +struct value_at_c +{ + typedef unspecified type; +}; ++
Table 1.28. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
|
+ + M + + |
+
+ + Positive integer index + + |
+
+ + Index of element + + |
+
+result_of::value_at_c<Seq, M>::type ++
+ Return type: Any type +
++ Semantics: Returns the actual type at + the Mth element of Seq. +
++ /sequence/intrinsic/value_at.hpp> +
++typedef vector<int,float,char> vec; +BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_c<vec, 1>::type, float>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Returns the actual element type associated with a Key from the Sequence. +
++template< + typename Seq, + typename Key> +struct value_at_key +{ + typedef unspecified type; +}; ++
Table 1.31. Parameters
+|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + Seq + + |
+
+ + A model of Forward + Sequence + + |
+
+ + Argument sequence + + |
+
|
+ + Key + + |
+
+ + Any type + + |
+
+ + Key type + + |
+
+result_of::value_at_key<Seq, Key>::type ++
+ Return type: Any type. +
++ Semantics: Returns the actual element + type associated with key type Key + in Seq. +
++ /sequence/intrinsic/value_at_key.hpp> +
++typedef map<pair<int, char>, pair<char, char>, pair<double, char> > mymap; +BOOST_MPL_ASSERT((boost::is_same<result_of::at_key<mymap, int>::type, char>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ These operators, like the Algorithms, + work generically on all Fusion sequences. All conforming Fusion sequences + automatically get these operators for free. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The Comparison operators: ==, + !=, <, + <=, >= + and >= work generically + on all Fusion sequences. Comparison operators are "short- circuited": + elementary comparisons start from the first elements and are performed + only until the result is clear. +
++#include <boost/fusion/sequence/comparison.hpp> +#include <boost/fusion/include/comparison.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Compare two sequences for equality. +
++template <typename Seq1, typename Seq2> +bool +operator==(Seq1 const& a, Seq2 const& b); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + a, + b + + |
+
+ + Instances of Sequence + + |
+
+ + Sequence(s) to compare + + |
+
+a == b ++
+ Return type: bool +
++ Requirements: +
++ For each element, e1, + in sequence a, and for + each element, e2, in + sequence b, a == b is a valid expression returning a + type that is convertible to bool. +
++ An attempt to compare two Sequences of different lengths results in a + compile time error. +
++ Semantics: +
++ For each element, e1, + in sequence a, and for + each element, e2, in + sequence b, e1 == e2 returns true. For any 2 zero length + _sequence_s, e and f, e == f returns + true. +
++#include <boost/fusion/sequence/comparison/equal_to.hpp> +#include <boost/fusion/include/equal_to.hpp> ++
+vector<int, char> v1(5, 'a'); +vector<int, char> v2(5, 'a'); +assert(v1 == v2); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Lexicographically compare two sequences. +
++template <typename Seq1, typename Seq2> +bool +operator>(Seq1 const& a, Seq2 const& b); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + a, + b + + |
+
+ + Instances of Sequence + + |
+
+ + Sequence(s) to compare + + |
+
+a > b ++
+ Return type: bool +
++ Requirements: +
++ For each element, e1, + in sequence a, and for + each element, e2, in + sequence b, a < b is a valid expression returning a + type that is convertible to bool. +
++ An attempt to compare two Sequences of different lengths results in a + compile time error. +
++ Semantics: Returns b < a. +
++#include <boost/fusion/sequence/comparison/less_equal.hpp> +#include <boost/fusion/include/less_equal.hpp> ++
+vector<int, float> v1(4, 3.3f); +vector<short, float> v2(5, 3.3f); +vector<long, double> v3(5, 4.4); +assert(v2 > v1); +assert(v3 > v2); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Lexicographically compare two sequences. +
++template <typename Seq1, typename Seq2> +bool +operator>=(Seq1 const& a, Seq2 const& b); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + a, + b + + |
+
+ + Instances of Sequence + + |
+
+ + Sequence(s) to compare + + |
+
+a >= b ++
+ Return type: bool +
++ Requirements: +
++ For each element, e1, + in sequence a, and for + each element, e2, in + sequence b, a < b is a valid expression returning a + type that is convertible to bool. +
++ An attempt to compare two Sequences of different lengths results in a + compile time error. +
++ Semantics: Returns !(a < b). +
++#include <boost/fusion/sequence/comparison/greater_equal.hpp> +#include <boost/fusion/include/greater_equal.hpp> ++
+vector<int, float> v1(4, 3.3f); +vector<short, float> v2(5, 3.3f); +vector<long, double> v3(5, 4.4); +assert(v2 >= v1); +assert(v3 >= v2); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Lexicographically compare two sequences. +
++template <typename Seq1, typename Seq2> +bool +operator<(Seq1 const& a, Seq2 const& b); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + a, + b + + |
+
+ + Instances of Sequence + + |
+
+ + Sequence(s) to compare + + |
+
+a < b ++
+ Return type: bool +
++ Requirements: +
++ For each element, e1, + in sequence a, and for + each element, e2, in + sequence b, a < b is a valid expression returning a + type that is convertible to bool. +
++ An attempt to compare two Sequences of different lengths results in a + compile time error. +
++ Semantics: Returns the lexicographical + comparison of between a + and b. +
++#include <boost/fusion/sequence/comparison/less.hpp> +#include <boost/fusion/include/less.hpp> ++
+vector<int, float> v1(4, 3.3f); +vector<short, float> v2(5, 3.3f); +vector<long, double> v3(5, 4.4); +assert(v1 < v2); +assert(v2 < v3); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Lexicographically compare two sequences. +
++template <typename Seq1, typename Seq2> +bool +operator<=(Seq1 const& a, Seq2 const& b); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + a, + b + + |
+
+ + Instances of Sequence + + |
+
+ + Sequence(s) to compare + + |
+
+a <= b ++
+ Return type: bool +
++ Requirements: +
++ For each element, e1, + in sequence a, and for + each element, e2, in + sequence b, a < b is a valid expression returning a + type that is convertible to bool. +
++ An attempt to compare two Sequences of different lengths results in a + compile time error. +
++ Semantics: Returns !(b < a). +
++#include <boost/fusion/sequence/comparison/less_equal.hpp> +#include <boost/fusion/include/less_equal.hpp> ++
+vector<int, float> v1(4, 3.3f); +vector<short, float> v2(5, 3.3f); +vector<long, double> v3(5, 4.4); +assert(v1 <= v2); +assert(v2 <= v3); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Compare two sequences for inequality. +
++template <typename Seq1, typename Seq2> +bool +operator!=(Seq1 const& a, Seq2 const& b); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + a, + b + + |
+
+ + Instances of Sequence + + |
+
+ + Sequence(s) to compare + + |
+
+a != b ++
+ Return type: bool +
++ Requirements: +
++ For each element, e1, + in sequence a, and for + each element, e2, in + sequence b, a == b is a valid expression returning a + type that is convertible to bool. +
++ An attempt to compare two Sequences of different lengths results in a + compile time error. +
++ Semantics: +
++ Returns !(a == b). +
++#include <boost/fusion/sequence/comparison/not_equal_to.hpp> +#include <boost/fusion/include/not_equal_to.hpp> ++
+vector<int, char> v3(5, 'b'); +vector<int, char> t4(2, 'a'); +assert(v1 != v3); +assert(v1 != t4); +assert(!(v1 != v2)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The I/O operators: << + and >> work generically + on all Fusion sequences. The global operator<< has been overloaded for generic + output streams such that Sequence(s) + are output by recursively calling operator<< for each element. Analogously, + the global operator>> + has been overloaded to extract Sequence(s) + from generic input streams by recursively calling operator>> for each element. +
++ The default delimiter between the elements is space, and the Sequence + is enclosed in parenthesis. For Example: +
++vector<float, int, std::string> a(1.0f, 2, std::string("Howdy folks!"); +cout << a; ++
+ outputs the vector + as: (1.0 2 Howdy folks!) +
++ The library defines three manipulators for changing the default behavior: +
+Manipulators
++ Defines the character that is output before the first element. +
+ Defines the character that is output after the last element. +
+ Defines the delimiter character between elements. +
+ The argument to tuple_open, + tuple_close and tuple_delimiter may be a char, wchar_t, + a C-string, or a wide C-string. +
++ Example: +
++std::cout << tuple_open('[') << tuple_close(']') << tuple_delimiter(", ") << a; ++
+ outputs the same vector, a + as: [1.0, 2, Howdy folks!] +
++ The same manipulators work with operator>> and istream + as well. Suppose the std::cin + stream contains the following data: +
++(1 2 3) [4:5] ++
+ The code: +
++vector<int, int, int> i; +vector<int, int> j; + +std::cin >> i; +std::cin >> set_open('[') >> set_close(']') >> set_delimiter(':'); +std::cin >> j; ++
+ reads the data into the vector(s) i + and j. +
++ Note that extracting Sequence(s) + with std::string or C-style string elements does + not generally work, since the streamed Sequence + representation may not be unambiguously parseable. +
++#include <boost/fusion/sequence/io.hpp> +#include <boost/fusion/include/io.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Read a Sequence from an input + stream. +
++template <typename IStream, typename Sequence> +IStream& +operator>>(IStream& is, Sequence& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + is + + |
+
+ + An input stream. + + |
+
+ + Stream to extract information from. + + |
+
|
+ + seq + + |
+
+ + A Sequence. + + |
+
+ + The sequence to read. + + |
+
+is >> seq ++
+ Return type: IStream& +
++ Semantics: For each element, e, in sequence, seq, + call is >> + e. +
++#include <boost/fusion/sequence/io/in.hpp> +#include <boost/fusion/include/in.hpp> ++
+vector<int, std::string, char> v; +std::cin >> v; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Write a Sequence to an output + stream. +
++template <typename OStream, typename Sequence> +OStream& +operator<<(OStream& os, Sequence& seq); ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + os + + |
+
+ + An output stream. + + |
+
+ + Stream to write information to. + + |
+
|
+ + seq + + |
+
+ + A Sequence. + + |
+
+ + The sequence to write. + + |
+
+os << seq ++
+ Return type: OStream& +
++ Semantics: For each element, e, in sequence, seq, + call os << + e. +
++#include <boost/fusion/sequence/io/out.hpp> +#include <boost/fusion/include/out.hpp> ++
+std::cout << make_vector(123, "Hello", 'x') << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A couple of classes and metafunctions provide basic support for Fusion. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ A metafunction that establishes the conceptual classification of a particular + Sequence or Iterator + (see Iterator Concepts and + Sequence Concepts). +
++namespace traits +{ + template <typename T> + struct category_of + { + typedef unspecified type; + }; +} ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + T + + |
+
+ + Any type + + |
+
+ + The type to query. + + |
+
+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. +
++#include <boost/fusion/support/category_of.hpp> +#include <boost/fusion/include/category_of.hpp> ++
+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> )); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ 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 boost::ref). +
++#include <boost/fusion/support/deduce.hpp> +#include <boost/fusion/include/deduce.hpp> ++
+namespace traits +{ + template <typename T> + struct deduce + { + typedef unspecified type; + }; +} ++
+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); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ 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. +
++#include <boost/fusion/support/deduce_sequence.hpp> +#include <boost/fusion/include/deduce_sequence.hpp> ++
+namespace traits +{ + template <class Sequence> + struct deduce_sequence + { + typedef unspecified type; + }; +} ++
+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) ); +} ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ 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. +
++namespace traits +{ + template <typename T> + struct is_sequence + { + typedef unspecified type; + }; +} ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + T + + |
+
+ + Any type + + |
+
+ + The type to query. + + |
+
+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. +
++#include <boost/fusion/support/is_sequence.hpp> +#include <boost/fusion/include/is_sequence.hpp> ++
+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> > )); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ 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. +
++namespace traits +{ + template <typename T> + struct is_view + { + typedef unspecified type; + }; +} ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + T + + |
+
+ + Any type + + |
+
+ + The type to query. + + |
+
+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. +
++#include <boost/fusion/support/is_view.hpp> +#include <boost/fusion/include/is_view.hpp> ++
+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> )); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ 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. +
++template <typename First, typename Second> +struct pair; + +namespace result_of +{ + template <typename First, typename Second> + struct first; + + template <typename First, typename Second> + 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 &); ++
|
+ + Parameter + + |
+
+ + Description + + |
+
|---|---|
|
+ + First + + |
+
+ + The first type. This is purely a type. No data is held. + + |
+
|
+ + Second + + |
+
+ + The second type. This contains data. + + |
+
Notation
++ Fusion pair type +
+ Fusion pairs +
+ Arbitrary types +
+ Value of type S +
+ Output stream +
+ Input stream +
|
+ + 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 = + 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. + + |
+
+#include <boost/fusion/support/pair.hpp> +#include <boost/fusion/include/pair.hpp> ++
+pair<int, char> p('X'); +std::cout << p << std::endl; +std::cout << make_pair<int>('X') << std::endl; +assert((p == make_pair<int>('X'))); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ 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. +
++namespace traits +{ + template<typename Sequence> + struct tag_of + { + typedef unspecified type; + }; +} ++
|
+ + Parameter + + |
+
+ + Requirement + + |
+
+ + Description + + |
+
|---|---|---|
|
+ + T + + |
+
+ + Any type + + |
+
+ + The type to query. + + |
+
+typedef traits::tag_of<T>::type tag; ++
+ Return type: Any type. +
++ Semantics: Returns the tag type associated + with T. +
++#include <boost/fusion/support/tag_of.hpp> +#include <boost/fusion/include/tag_of.hpp> ++
+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>)); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The TR1 technical report describes extensions to the C++ standard library. + Many of these extensions will be considered for the next iteration of the C++ + standard. TR1 describes a tuple type, and support for treating std::pair + as a type of tuple. +
++ Fusion provides full support for the TR1 + Tuple interface, and the extended uses of std::pair described + in the TR1 document. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Fusion's implementation of the TR1 + Tuple is also a fusion Forward + Sequence. As such the fusion tuple type provides a lot of functionality + beyond that required by TR1. +
++ Currently tuple is basically a synonym for vector, although this may be changed + in future releases of fusion. +
++template< + typename T1 = unspecified, + typename T2 = unspecified, + ... + typename TN = unspecified> +class tuple; ++
+ /tuple.hpp> +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The TR1 + Tuple type provides a default constructor, a constructor that takes + initializers for all of its elements, a copy constructor, and a converting + copy constructor. The details of the various constructors are described + in this section. +
+Notation
++ Tuple element types +
+ Parameter types +
+ The type of the ith + element of a tuple +
+ The type of the ith + parameter +
+tuple(); ++
+ Requirements: Each Ti + is default constructable. +
++ Semantics: Default initializes each element + of the tuple. +
++tuple(P1,P2,...,PN); ++
+ Requirements: Each Pi + is Ti if Ti is a reference type, const Ti& otherwise. +
++ Semantics: Copy initializes each element + with the corresponding parameter. +
++tuple(const tuple& t); ++
+ Requirements: Each Ti + should be copy constructable. +
++ Semantics: Copy constructs each element + of *this + with the corresponding element of t. +
++template<typename U1, typename U2, ..., typename UN> +tuple(const tuple<U1, U2, ..., UN>& t); ++
+ Requirements: Each Ti + shall be constructible from the corresponding Ui. +
++ Semantics: Constructs each element of + *this + with the corresponding element of t. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The TR1 + Tuple provides the get + function to provide access to it's elements by zero based numeric index. +
++template<int I, T> +RJ get(T& t); ++
+ Requires: 0 + < I + <= N. + The program is ill formed if I + is out of bounds. T is + any fusion sequence type, including tuple. +
++ Return type: RJ + is equivalent to result_of::at_c<I,T>::type. +
++ Returns: A reference to the Ith element of T. +
++template<int I, typename T> +PJ get(T const& t); ++
+ Requires: 0 + < I + <= N. + The program is ill formed if I + is out of bounds. T is + any fusion sequence type, including tuple. +
++ Return type: PJ + is equivalent to result_of::at_c<I,T>::type. +
++ Returns: A const reference to the Ith element of T. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The TR1 + Tuple provides the standard boolean relational operators. +
+Notation
++ Tuple element types +
+ Parameter types +
+ The type of the ith + element of a tuple +
+ The type of the ith + parameter +
+template<typename T1, typename T2, ..., typename TN, + typename U1, typename U2, ..., typename UN> +bool operator==( + const tuple<T1, T2, ..., TN>& lhs, + const tuple<U1, U2, ..., UN>& rhs); ++
+ Requirements: For all i, + 1 <= + i < + N, get<i>(lhs) == get<i>(rhs) + is a valid expression returning a type that is convertible to bool. +
++ Semantics: Returns true + if and only if get<i>(lhs) == get<i>(rhs) + for all i. For any 2 zero + length tuples e and f, e + == f + returns true. +
++template<typename T1, typename T2, ..., typename TN, + typename U1, typename U2, ..., typename UN> +bool operator<( + const tuple<T1, T2, ..., TN>& lhs, + const tuple<U1, U2, ..., UN>& rhs); ++
+ Requirements: For all i, + 1 <= + i < + N, get<i>(lhs) < get<i>(rhs) + is a valid expression returning a type that is convertible to bool. +
++ Semantics: Returns the lexicographical + comparison of between lhs + and rhs. +
++template<typename T1, typename T2, ..., typename TN, + typename U1, typename U2, ..., typename UN> +bool operator!=( + const tuple<T1, T2, ..., TN>& lhs, + const tuple<U1, U2, ..., UN>& rhs); ++
+ Requirements: For all i, + 1 <= + i < + N, get<i>(lhs) == get<i>(rhs) + is a valid expression returning a type that is convertible to bool. +
++ Semantics: Returns !(lhs == rhs). +
++template<typename T1, typename T2, ..., typename TN, + typename U1, typename U2, ..., typename UN> +bool operator<=( + const tuple<T1, T2, ..., TN>& lhs, + const tuple<U1, U2, ..., UN>& rhs); ++
+ Requirements: For all i, + 1 <= + i < + N, get<i>(rhs) < get<i>(lhs) + is a valid expression returning a type that is convertible to bool. +
++ Semantics: Returns !(rhs < lhs) +
++template<typename T1, typename T2, ..., typename TN, + typename U1, typename U2, ..., typename UN> +bool operator>( + const tuple<T1, T2, ..., TN>& lhs, + const tuple<U1, U2, ..., UN>& rhs); ++
+ Requirements: For all i, + 1 <= + i < + N, get<i>(rhs) < get<i>(lhs) + is a valid expression returning a type that is convertible to bool. +
++ Semantics: Returns rhs + < lhs. +
++template<typename T1, typename T2, ..., typename TN, + typename U1, typename U2, ..., typename UN> +bool operator>=( + const tuple<T1, T2, ..., TN>& lhs, + const tuple<U1, U2, ..., UN>& rhs); ++
+ Requirements: For all i, + 1 <= + i < + N, get<i>(lhs) < get<i>(rhs) + is a valid expression returning a type that is convertible to bool. +
++ Semantics: Returns !(lhs < rhs). +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ TR1 describes 2 utility functions for creating _tr1tuple_s. make_tuple + builds a tuple out of it's argument list, and tie + builds a tuple of references to it's arguments. The details of these creation + functions are described in this section. +
++template<typename T1, typename T2, ..., typename TN> +tuple<V1, V2, ..., VN> make_tuple(const T1& t1, const T2& t2, ..., const TN& tn); ++
+ Where Vi is X& + if the cv-unqualified type Ti + is reference_wrapper<X>, + otherwise Vi is Ti. +
++ Returns: tuple<V1, V2, ..., VN>(t1, t2, ..., tN) +
++template<typename T1, typename T2, ..., typename TN> +tuple<T1&, T2&, ..., TN&> tie(T1& t1, T2& t2, ..., TN& tn); ++
+ Returns: tuple<T1&, T2&, ..., + TN&>(t1, t2, ..., tN). When argument ti + is ignore, assigning any + value to the corresponding tuple element has has no effect. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The TR1 + Tuple provides 2 helper traits, for compile time access to the + tuple size, and the element types. +
++tuple_size<T>::value ++
+ Requires: T + is any fusion sequence type, including tuple. +
++ Type: MPL + Integral Constant +
++ Value: The number of elements in the sequence. + Equivalent to result_of::size<T>::type. +
++tuple_element<I, T>::type ++
+ Requires: T + is any fusion sequence type, including tuple. + 0 <= + I < + N or the program is ill formed. +
++ Value: The type of the Ith + element of T. Equivalent + to result_of::value_at<I,T>::type. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The TR1 + Tuple interface is specified to provide uniform access to std::pair + as if it were a 2 element tuple. +
++tuple_size<std::pair<T1, T2> >::value ++
+ Type: An MPL + Integral Constant +
++ Value: Returns 2, the number of elements + in a pair. +
++tuple_element<0, std::pair<T1, T2> >::type ++
+ Type: T1 +
++ Value: Returns the type of the first element + of the pair +
++tuple_element<1, std::pair<T1, T2> >::type ++
+ Type: T2 +
++ Value: Returns thetype of the second element + of the pair +
++template<int I, typename T1, typename T2> +P& get(std::pair<T1, T2>& pr); + +template<int I, typename T1, typename T2> +const P& get(const std::pair<T1, T2>& pr); ++
+ Type: If I + == 0 + P is T1, + else if I == + 1 P + is T2 else the program is + ill-formed. +
++ Returns: pr.first + if I == + 0 else pr.second.[*Returns: + pr.first if I + == 0 + else pr.second. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ Views are sequences that do not actually contain data, but instead impart an + alternative presentation over the data from one or more underlying sequences. + Views are proxies. They provide an efficient yet purely functional way to work + on potentially expensive sequence operations. Views are inherently lazy. Their + elements are only computed on demand only when the elements of the underlying + sequence(s) are actually accessed. Views' lazy nature make them very cheap + to copy and be passed around by value. +
++#include <boost/fusion/view.hpp> +#include <boost/fusion/include/view.hpp> ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ filter_view is a view into + a subset of its underlying sequence's elements satisfying a given predicate + (an MPL metafunction). + The filter_view presents + only those elements for which its predicate evaluates to mpl::true_. +
++#include <boost/fusion/view/filter_view.hpp> +#include <boost/fusion/include/filter_view.hpp> ++
+template <typename Sequence, typename Pred> +struct filter_view; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A Forward + Sequence + + |
+
+ + + |
+
|
+ + Pred + + |
+
+ + Unary Metafunction returning an mpl::bool_ + + |
+
+ + + |
+
Notation
++ A filter_view type +
+ Instances of filter_view +
+ A Forward Sequence +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Forward + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + F(s) + + |
+
+ + Creates a filter_view + given a sequence, s. + + |
+
|
+ + F(f) + + |
+
+ + Copy constructs a filter_view + from another filter_view, + f. + + |
+
|
+ + f = + f2 + + |
+
+ + Assigns to a filter_view, + f, from another + filter_view, f2. + + |
+
+using boost::mpl::_; +using boost::mpl::not_; +using boost::is_class; + +typedef vector<std::string, char, long, bool, double> vector_type; + +vector_type v("a-string", '@', 987654, true, 6.6); +filter_view<vector_type const, not_<is_class<_> > > view(v); +std::cout << view << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ iterator_range presents a + sub-range of its underlying sequence delimited by a pair of iterators. +
++#include <boost/fusion/view/iterator_range.hpp> +#include <boost/fusion/include/iterator_range.hpp> ++
+template <typename First, typename Last> +struct iterator_range; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + First + + |
+
+ + A fusion Iterator + + |
+
+ + + |
+
|
+ + Last + + |
+
+ + A fusion Iterator + + |
+
+ + + |
+
Notation
++ An iterator_range type +
+ An instance of First +
+ An instance of Last +
+ Instances of iterator_range +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Forward + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + IR(f, l) + + |
+
+ + Creates an iterator_range + given iterators, f + and l. + + |
+
|
+ + IR(ir) + + |
+
+ + Copy constructs an iterator_range + from another iterator_range, + ir. + + |
+
|
+ + ir = + ir2 + + |
+
+ + Assigns to a iterator_range, + ir, from another + iterator_range, + ir2. + + |
+
+char const* s = "Ruby"; +typedef vector<int, char, double, char const*> vector_type; +vector_type vec(1, 'x', 3.3, s); + +typedef result_of::begin<vector_type>::type A; +typedef result_of::end<vector_type>::type B; +typedef result_of::next<A>::type C; +typedef result_of::prior<B>::type D; + +C c(vec); +D d(vec); + +iterator_range<C, D> range(c, d); +std::cout << range << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ joint_view presents a view + which is a concatenation of two sequences. +
++#include <boost/fusion/view/joint_view.hpp> +#include <boost/fusion/include/joint_view.hpp> ++
+template <typename Sequence1, typename Sequence2> +struct joint_view; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Sequence1 + + |
+
+ + A Forward + Sequence + + |
+
+ + + |
+
|
+ + Sequence2 + + |
+
+ + A Forward + Sequence + + |
+
+ + + |
+
Notation
++ A joint_view type +
+ An instance of Sequence1 +
+ An instance of Sequence2 +
+ Instances of joint_view +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Forward + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + JV(s1, s2) + + |
+
+ + Creates a joint_view + given sequences, s1 + and s2. + + |
+
|
+ + JV(jv) + + |
+
+ + Copy constructs a joint_view + from another joint_view, + jv. + + |
+
|
+ + jv = + jv2 + + |
+
+ + Assigns to a joint_view, + jv, from another + joint_view, jv2. + + |
+
+vector<int, char> v1(3, 'x'); +vector<std::string, int> v2("hello", 123); +joint_view< + vector<int, char> + , vector<std::string, int> +> view(v1, v2); +std::cout << view << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ reverse_view presents a reversed + view of underlying sequence. The first element will be its last and the last + element will be its first. +
++#include <boost/fusion/view/reverse_view.hpp> +#include <boost/fusion/include/reverse_view.hpp> ++
+template <typename Sequence> +struct reverse_view; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A Bidirectional + Sequence + + |
+
+ + + |
+
Notation
++ A reverse_view type +
+ An instance of Sequence +
+ Instances of reverse_view +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Bidirectional + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + RV(s) + + |
+
+ + Creates a unary reverse_view + given sequence, s. + + |
+
|
+ + RV(rv) + + |
+
+ + Copy constructs a reverse_view + from another reverse_view, + rv. + + |
+
|
+ + rv = + rv2 + + |
+
+ + Assigns to a reverse_view, + rv, from another + reverse_view, rv2. + + |
+
+typedef vector<int, short, double> vector_type; +vector_type vec(2, 5, 3.3); + +reverse_view<vector_type> reverse(vec); +std::cout << reverse << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ single_view is a view into + a value as a single element sequence. +
++#include <boost/fusion/view/single_view.hpp> +#include <boost/fusion/include/single_view.hpp> ++
+template <typename T> +struct single_view; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + T + + |
+
+ + Any type + + |
+
+ + + |
+
Notation
++ A single_view type +
+ Instances of single_view +
+ An instance of T +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Forward + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + S(x) + + |
+
+ + Creates a single_view + from x. + + |
+
|
+ + S(s) + + |
+
+ + Copy constructs a single_view + from another single_view, + s. + + |
+
|
+ + s = + s2 + + |
+
+ + Assigns to a single_view, + s, from another + single_view, s2. + + |
+
+single_view<int> view(3); +std::cout << view << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The unary version of transform_view + presents a view of its underlying sequence given a unary function object + or function pointer. The binary version of transform_view + presents a view of 2 underlying sequences, given a binary function object + or function pointer. The transform_view + inherits the traversal characteristics (see Sequence + Traversal Concept) of its underlying sequence or sequences. +
++#include <boost/fusion/view/transform_view.hpp> +#include <boost/fusion/include/transform_view.hpp> ++
+ Unary Version +
++template <typename Sequence, typename F1> +struct transform_view; ++
+ Binary Version +
++template <typename Sequence1, typename Sequence2, typename F2> +struct transform_view; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Sequence + + |
+
+ + A Forward + Sequence + + |
+
+ + + |
+
|
+ + Sequence1 + + |
+
+ + A Forward + Sequence + + |
+
+ + + |
+
|
+ + Sequence2 + + |
+
+ + A Forward + Sequence + + |
+
+ + + |
+
|
+ + F1 + + |
+
+ + A unary function object or function pointer. boost::result_of<F1(E)>::type is the return type of an instance + of F1 when called + with a value of each element type E + in the input sequence. + + |
+
+ + + |
+
|
+ + F2 + + |
+
+ + A binary function object or function pointer. boost::result_of<F2(E1, E2)>::type is the return type of an instance + of F2 when called + with a value of each corresponding pair of element type E1 and E2 + in the input sequences. + + |
+
+ + + |
+
Notation
++ A transform_view type +
+ A binary transform_view + type +
+ A unary transform_view + type +
+ An instance of F1 +
+ An instance of F2 +
+ An instance of Sequence +
+ An instance of Sequence1 +
+ An instance of Sequence2 +
+ Instances of transform_view +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Forward + Sequence, Bidirectional + Sequence or Random + Access Sequence depending on the traversal characteristics (see Sequence Traversal Concept) + of its underlying sequence or sequences. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + UTV(s, f1) + + |
+
+ + Creates a unary transform_view + given sequence, s + and unary function object or function pointer, f1. + + |
+
|
+ + BTV(s1, s2, f2) + + |
+
+ + Creates a binary transform_view + given sequences, s1 + and s2 and binary + function object or function pointer, f2. + + |
+
|
+ + TV(tv) + + |
+
+ + Copy constructs a transform_view + from another transform_view, + tv. + + |
+
|
+ + tv = + tv2 + + |
+
+ + Assigns to a transform_view, + tv, from another + transform_view, + tv2. + + |
+
+struct square +{ + template<typename Sig> + struct result; + + template<typename U> + struct result<square(U)> + : remove_reference<U> + {}; + + template <typename T> + T operator()(T x) const + { + return x * x; + } +}; + +typedef vector<int, short, double> vector_type; +vector_type vec(2, 5, 3.3); + +transform_view<vector_type, square> transform(vec, square()); +std::cout << transform << std::endl; ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ zip_view presents a view + which iterates over a collection of Sequence(s) + in parallel. A zip_view is + constructed from a Sequence of references + to the component _sequence_s. +
++#include <boost/fusion/view/zip_view.hpp> +#include <boost/fusion/include/zip_view.hpp> ++
+template <typename Sequences> +struct zip_view; ++
|
+ + Parameter + + |
+
+ + Description + + |
+
+ + Default + + |
+
|---|---|---|
|
+ + Sequences + + |
+
+ + A Forward + Sequence of references to other Fusion _sequence_s + + |
+
+ + + |
+
Notation
++ A joint_view type +
+ An instance of Sequences +
+ Instances of ZV +
+ Semantics of an expression is defined only where it differs from, or is not + defined in Forward + Sequence. +
+|
+ + Expression + + |
+
+ + Semantics + + |
+
|---|---|
|
+ + ZV(s) + + |
+
+ + Creates a zip_view + given a sequence of references to the component _sequence_s. + + |
+
|
+ + ZV(zv1) + + |
+
+ + Copy constructs a zip_view + from another zip_view, + zv. + + |
+
|
+ + zv1 = + zv2 + + |
+
+ + Assigns to a zip_view, + zv, from another + zip_view, zv2. + + |
+
+typedef vector<int,int> vec1; +typedef vector<char,char> vec2; +vec1 v1(1,2); +vec2 v2('a','b'); +typedef vector<vec1&, vec2&> sequences; +std::cout << zip_view<sequences>(sequences(v1, v2)) << std::endl; // ((1 a) (2 b)) ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
Copyright © 2001-2007 Joel de Guzman, Dan Marsden, Tobias + Schwinger
+ 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) +
+Table of Contents
+Last revised: November 14, 2007 at 10:10:22 GMT |
++ |
