boostorg/fusion
1
0
Fork 1
mirror of https://github.com/boostorg/fusion.git synced 2025-07-29 20:17:32 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'official/develop' into fusion_adapters

Browse Source 
Conflicts:
	test/sequence/adapt_struct.cpp
This commit is contained in:
Damien Buhl (alias daminetreg)
2015-02-02 07:06:52 +01:00
parent c6c9d872d3 af1bc25783
commit 73a5dde412
239 changed files with 8117 additions and 7205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
doc/algorithm.qbk
View File

@ -69,7 +69,7 @@ It is also used to convert sequence into other.
[heading Synopsis]
template <typename Seq1, typename Seq2>
void copy(Seq1 const& src, Seq2& dest);
typename __result_of_copy__<Seq1, Seq2>::type copy(Seq1 const& src, Seq2& dest);
[table Parameters
[[Parameter][Requirement][Description]]
@ -100,6 +100,121 @@ Linear, exactly `__result_of_size__<Sequence>::value`.
[endsect]
[section move]
[heading Description]
move a sequence `src` to a sequence `dest`.
It is also used to convert sequence into other.
[heading Synopsis]
template <typename Seq1, typename Seq2>
typename __result_of_move__<Seq1, Seq2>::type move(Seq1&& src, Seq2& dest);
[table Parameters
[[Parameter][Requirement][Description]]
[[`src`][A model of __forward_sequence__, all elements contained in the `src` sequence should be convertible into the element contained in the `dest` sequence.][Operation's argument]]
[[`dest`][A model of __forward_sequence__, `e2 = std::move(e1)` is valid expression for each pair of elements `e1` of `src` and `e2` of `dest`.][Operation's argument]]
]
[heading Expression Semantics]
__move__(src, dest);
[*Return type]: `void`
[*Semantics]: `e2 = std::move(e1)` for each element `e1` in `src` and `e2` in `dest`.
[heading Complexity]
Linear, exactly `__result_of_size__<Sequence>::value`.
[heading Header]
#include <boost/fusion/algorithm/auxiliary/move.hpp>
#include <boost/fusion/include/move.hpp>
[heading Example]
__vector__<int,int> vec(1,2);
__list__<int,int> ls;
__move__(std::move(vec), ls);
assert(ls == __make_list__(1,2));
[endsect]
[endsect]
[section Metafunctions]
[section copy]
[heading Description]
A metafunction returning the result type of applying __copy__, which is always `void`.
[heading Synopsis]
template <typename Seq1, typename Seq2>
struct copy
{
typedef void type;
};
[table Parameters
[[Parameter] [Requirement] [Description]]
[[`Seq1`] [A model of __forward_sequence__] [Operation's argument]]
[[`Seq2`] [A model of __forward_sequence__] [Operation's argument]]
]
[heading Expression Semantics]
result_of::copy<Seq1, Seq2>::type
[*Return type]: `void` iff both of `Seq1` and `Seq2` are sequence.
Otherwise, none.
[*Semantics]: Returns the return type of __copy__ for 2 sequences of types `Seq1` and `Seq2`.
[heading Complexity]
Constant.
[heading Header]
#include <boost/fusion/algorithm/auxiliary/copy.hpp>
#include <boost/fusion/include/copy.hpp>
[endsect]
[section move]
[heading Description]
A metafunction returning the result type of applying __move__, which is always `void`.
[heading Synopsis]
template <typename Seq1, typename Seq2>
struct move
{
typedef void type;
};
[table Parameters
[[Parameter] [Requirement] [Description]]
[[`Seq1`] [A model of __forward_sequence__] [Operation's argument]]
[[`Seq2`] [A model of __forward_sequence__] [Operation's argument]]
]
[heading Expression Semantics]
result_of::move<Seq1, Seq2>::type
[*Return type]: `void` iff both of `Seq1` and `Seq2` are sequence.
Otherwise, none.
[*Semantics]: Returns the return type of __move__ for 2 sequences of types `Seq1` and `Seq2`.
[heading Complexity]
Constant.
[heading Header]
#include <boost/fusion/algorithm/auxiliary/move.hpp>
#include <boost/fusion/include/move.hpp>
[endsect]
[endsect]
[endsect]
@ -536,13 +651,13 @@ Finds the first element of a given type within a sequence.
typename T,
typename Sequence
>
__unspecified__ find(Sequence const& seq);
typename __result_of_find__<Sequence const, T>::type find(Sequence const& seq);
template<
typename T,
typename Sequence
>
__unspecified__ find(Sequence& seq);
typename __result_of_find__<Sequence, T>::type find(Sequence& seq);
[table Parameters
[[Parameter][Requirement][Description]]
@ -574,23 +689,23 @@ Linear. At most `__result_of_size__<Sequence>::value` comparisons.
[endsect]
[section find_if]
Finds the first element within a sequence with a type for which a given __mpl_lambda_expression__ evaluates to
`boost::mpl::true_`.
[heading Description]
Finds the first element within a sequence with a type for which a given __mpl_lambda_expression__ evaluates to
`boost::mpl::true_`.
[heading Synopsis]
template<
typename F,
typename Sequence
>
__unspecified__ find_if(Sequence const& seq);
typename __result_of_find_if__<Sequence const, F>::type find_if(Sequence const& seq);
template<
typename F,
typename Sequence
>
__unspecified__ find_if(Sequence& seq);
typename __result_of_find_if__<Sequence, F>::type find_if(Sequence& seq);
[table Parameters
[[Parameter][Requirement][Description]]
@ -1329,7 +1444,7 @@ Constant. Returns a view which is lazily evaluated.
[heading Description]
Returns a new sequence with the elements of the original in reverse order.
[heading Synposis]
[heading Synopsis]
template<
typename Sequence
>
@ -1369,7 +1484,7 @@ Constant. Returns a view which is lazily evaluated.
[heading Description]
__clear__ returns an empty sequence.
[heading Synposis]
[heading Synopsis]
template<
typename Sequence
>
@ -1406,7 +1521,7 @@ Constant.
Returns a new sequence, containing all the elements of the original except those at a specified iterator, or
between two iterators.
[heading Synposis]
[heading Synopsis]
template<
typename Sequence,
typename First
@ -1467,11 +1582,11 @@ Constant. Returns a view which is lazily evaluated.
[section erase_key]
[heading Description]
For an [link fusion.sequence.concepts.associative_sequence associative]] __forward_sequence__ `seq`,
returns a [link fusion.sequence.concepts.associative_sequence associative]] __forward_sequence__ containing
For an [link fusion.sequence.concepts.associative_sequence associative] __forward_sequence__ `seq`,
returns a [link fusion.sequence.concepts.associative_sequence associative] __forward_sequence__ containing
all the elements of the original except those with a given key.
[heading Synposis]
[heading Synopsis]
template<
typename Key,
typename Sequence
@ -1510,7 +1625,7 @@ Constant. Returns a view which is lazily evaluated.
Returns a new sequence with all the elements of the original, an a new element inserted the
position described by a given iterator.
[heading Synposis]
[heading Synopsis]
template<
typename Sequence,
typename Pos,
@ -1527,7 +1642,7 @@ position described by a given iterator.
]
[heading Expression Semantics]
__insert__(seq, p, t);
__insert__(seq, pos, t);
[*Return type]:
@ -1555,7 +1670,7 @@ Constant. Returns a view which is lazily evaluated.
[heading Description]
Returns a new sequence with another sequence inserted at a specified iterator.
[heading Synposis]
[heading Synopsis]
template<
typename Sequence,
typename Pos,
@ -1580,7 +1695,7 @@ Returns a new sequence with another sequence inserted at a specified iterator.
* A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
[*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.
`range` inserted at iterator `pos`. All elements retaining their ordering from the original sequences.
[heading Complexity]
Constant. Returns a view which is lazily evaluated.
@ -1641,7 +1756,7 @@ Constant. Returns a view which is lazily evaluated.
[section zip]
[heading Description]
Zips sequences together to form a single sequence, whos members are tuples of the members of the component sequences.
Zips sequences together to form a single sequence, whose members are tuples of the members of the component sequences.
[heading Synopsis]
template<
@ -2471,7 +2586,7 @@ Returns the result of joining 2 sequences, given the sequence types.
[*Return type]:
* A model of __forward_sequence__.
* A model of __associative_sequence__ if `LhSequence` amd `RhSequence` implement the __associative_sequence__ model.
* A model of __associative_sequence__ if `LhSequence` and `RhSequence` implement the __associative_sequence__ model.
[*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.
@ -2488,7 +2603,7 @@ Constant.
[section zip]
[heading Description]
Zips sequences together to form a single sequence, whos members are tuples of the members of the component sequences.
Zips sequences together to form a single sequence, whose members are tuples of the members of the component sequences.
[heading Synopsis]
template<

47
doc/container.qbk
View File

@ -9,7 +9,7 @@
[section Container]
Fusion provides a few predefined sequences out of the box. These
/containers/ actually hold heterogenously typed data; unlike
/containers/ actually hold heterogeneously typed data; unlike
__views__. These containers are more or less counterparts of those in __stl__.
[heading Header]
@ -21,7 +21,7 @@ __views__. These containers are more or less counterparts of those in __stl__.
[heading Description]
`vector` is a __random_access_sequence__ of heterogenous typed data
`vector` is a __random_access_sequence__ of heterogeneous 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 (a
vector with N elements is just a struct with N members), and in many
@ -209,7 +209,7 @@ constant (see __recursive_inline__).]
[heading Description]
`list` is a __forward_sequence__ of heterogenous typed data built on top of
`list` is a __forward_sequence__ of heterogeneous 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_inline__).
@ -508,7 +508,7 @@ not defined in __bidirectional_sequence__.
[heading Description]
set is an __associative_sequence__ of heteregenous typed data elements.
set is an __associative_sequence__ of heterogeneous 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
@ -589,7 +589,7 @@ defined in __random_access_sequence__ and __associative_sequence__.
[heading Description]
map is an __associative_sequence__ of heteregenous typed data elements.
map is an __associative_sequence__ of heterogeneous 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
@ -846,7 +846,7 @@ Create a __deque__ from one or more values.
For C++11 compilers, the variadic function interface has no upper bound.
For C++11 compilers, the variadic function accepts `0` to
For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a
user definable predefined maximum that defaults to `10`. You may define
the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any
@ -950,7 +950,9 @@ Create a __map__ from one or more key/data pairs.
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_MAP_SIZE` elements,
For C++11 compilers, the variadic function interface has no upper bound.
For C++03 compilers, 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
@ -1468,6 +1470,10 @@ rules for __element_conversion__.
Returns the result type of __make_map__.
The implementation depends on the support of variadic templates.
When variadic templates are not supported, make_map is a metafunction of the form:
[heading Synopsis]
template <
@ -1475,7 +1481,9 @@ Returns the result type of __make_map__.
, typename T0, typename T1,... typename TN>
struct make_map;
The variadic function accepts `0` to `FUSION_MAX_MAP_SIZE` elements,
For C++11 compilers, the variadic function interface has no upper bound.
For C++03 compilers, 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
@ -1483,6 +1491,18 @@ default. Example:
#define FUSION_MAX_MAP_SIZE 20
When variadic templates are supported, make_map is a metafunction class of the form:
[heading Synopsis]
template <
typename K0, typename K1,... typename KN>
struct make_map
{
struct apply<
typename T0, typename T1,... typename TN>
};
[heading Parameters]
[table
@ -1493,9 +1513,16 @@ default. Example:
[heading Expression Semantics]
#if !defined(BOOST_FUSION_HAS_VARIADIC_MAP)
resulf_of::make_map<K0, K1,... KN, T0, T1,... TN>::type;
#else
resulf_of::make_map<K0, K1,... KN>::apply<T0, T1,... TN>::type;
#endif
[*Return type]: __result_of_make_map__`<K0, K0,... KN, T0, T1,... TN>::type`
when variadic templates are not supported, or
__result_of_make_map__`<K0, K0,... KN>::apply<T0, T1,... TN>::type`
when variadic templates are supported.
[*Semantics]: A __map__ with __fusion_pair__ elements where the
`second_type` is converted following the rules for __element_conversion__.
@ -1509,7 +1536,11 @@ default. Example:
[heading Example]
#if !defined(BOOST_FUSION_HAS_VARIADIC_MAP)
result_of::make_map<int, double, char, double>::type
#else
result_of::make_map<int, double>::apply<char, double>::type
#endif
[heading See also]

6
doc/extension.qbk
View File

@ -71,7 +71,7 @@ tag type for operations involving our sequence. This is done by specializing
}}}
`traits::tag_of` also has a second template argument,
that can be used in conjuction with `boost::enable_if` to provide tag
that can be used in conjunction 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:
@ -228,7 +228,7 @@ 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, __result_of_value_of__ and __deref__ illustrate all the signficant concepts
Fusion sequence, __result_of_value_of__ and __deref__ illustrate all the significant concepts
required. The remainder of the process is very repetitive, simply requiring
implementation of a suitable `xxxx_impl` for each feature `xxxx`.
]
@ -378,7 +378,7 @@ the example code.
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
sequence. The implementation was slightly longwinded, but followed
sequence. The implementation was slightly long-winded, but followed
a simple repeating pattern.
The support for `std::pair`, __mpl__ sequences, and `boost::array` all

6
doc/functional.qbk
View File

@ -364,7 +364,7 @@ implemented).
[heading Header]
#include <booost/fusion/functional/invocation/invoke_procedure.hpp>
#include <boost/fusion/functional/invocation/invoke_procedure.hpp>
[heading Example]
__vector__<int,int> v(1,2);
@ -644,7 +644,7 @@ An unary __poly_func_obj__ adapter template for __callable_obj__ 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 result is discarded 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
@ -922,7 +922,7 @@ An n-ary __poly_func_obj__ adapter template for an unary __poly_func_obj__
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
The call operators of resulting 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

13
doc/fusion.qbk
View File

@ -26,11 +26,11 @@
[def __caution__ [$images/caution.png]]
[def __spirit__ [@http://spirit.sourceforge.net Spirit]]
[def __phoenix__ [@http://boost.org/libs/spirit/phoenix/index.html Phoenix]]
[def __phoenix__ [@http://www.boost.org/libs/phoenix/index.html Phoenix]]
[def __mpl__ [@http://www.boost.org/libs/mpl/index.html MPL]]
[def __stl__ [@http://en.wikipedia.org/wiki/Standard_Template_Library STL]]
[def __tuple__ [@http://www.boost.org/libs/tuple/doc/tuple_users_guide.html Boost.Tuple]]
[def __tr1__tuple__ [@http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1403.pdf TR1 Tuple]]
[def __tr1__tuple__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1403.pdf TR1 Tuple]]
[def __boost_tools__ [@http://www.boost.org/tools/index.html Boost Tools]]
[def __spirit_list__ [@https://lists.sourceforge.net/lists/listinfo/spirit-general Spirit Mailing List]]
[def __spirit_general__ [@news://news.gmane.org/gmane.comp.spirit.general Spirit General NNTP news portal]]
@ -40,8 +40,8 @@
[def __david_abrahams__ [@http://www.boost.org/people/dave_abrahams.htm David Abrahams]]
[def __the_forwarding_problem__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm The Forwarding Problem]]
[def __boost_any__ [@http://boost.org/doc/html/any.html Boost.Any]]
[def __new_iterator_concepts__ [@http://boost.org/libs/iterator/doc/new-iter-concepts.html New Iterator Concepts]]
[def __boost_any__ [@http://www.boost.org/doc/html/any.html Boost.Any]]
[def __new_iterator_concepts__ [@http://www.boost.org/libs/iterator/doc/new-iter-concepts.html New Iterator Concepts]]
[def __boost_array_library__ [@http://www.boost.org/doc/html/array.html Boost.Array Library]]
[def __boost_variant_library__ [@http://www.boost.org/doc/html/variant.html Boost.Variant Library]]
[def __boost_tuple_library__ [@http://www.boost.org/libs/tuple/doc/tuple_users_guide.html Boost.Tuple Library]]
@ -178,6 +178,8 @@
[def __result_of_value_at__ [link fusion.sequence.intrinsic.metafunctions.value_at `result_of::value_at`]]
[def __result_of_value_at_c__ [link fusion.sequence.intrinsic.metafunctions.value_at_c `result_of::value_at_c`]]
[def __result_of_value_at_key__ [link fusion.sequence.intrinsic.metafunctions.value_at_key `result_of::value_at_key`]]
[def __swap__ [link fusion.sequence.intrinsic.functions.swap `swap`]]
[def __result_of_swap__ [link fusion.sequence.intrinsic.metafunctions.swap `result_of::swap`]]
[def __conversion__ [link fusion.container.conversion.functions Conversion]]
[def __result_of_conversion__ [link fusion.container.conversion.metafunctions Conversion Metafunctions]]
@ -226,6 +228,9 @@
[def __algorithm__ [link fusion.algorithm Algorithm]]
[def __algorithms__ [link fusion.algorithm Algorithms]]
[def __copy__ [link fusion.algorithm.auxiliary.functions.copy `copy`]]
[def __result_of_copy__ [link fusion.algorithm.auxiliary.metafunctions.copy `result_of::copy`]]
[def __move__ [link fusion.algorithm.auxiliary.functions.move `move`]]
[def __result_of_move__ [link fusion.algorithm.auxiliary.metafunctions.move `result_of::move`]]
[def __fold__ [link fusion.algorithm.iteration.functions.fold `fold`]]
[def __result_of_fold__ [link fusion.algorithm.iteration.metafunctions.fold `result_of::fold`]]
[def __reverse_fold__ [link fusion.algorithm.iteration.functions.reverse_fold `reverse_fold`]]

7
doc/html/index.html
View File

@ -126,6 +126,7 @@
<dd><dl>
<dt><span class="section"><a href="fusion/sequence/operator/i_o.html">I/O</a></span></dt>
<dt><span class="section"><a href="fusion/sequence/operator/comparison.html">Comparison</a></span></dt>
<dt><span class="section"><a href="fusion/sequence/operator/hashing.html">Hashing</a></span></dt>
</dl></dd>
</dl></dd>
<dt><span class="section"><a href="fusion/container.html">Container</a></span></dt>
@ -160,6 +161,7 @@
<dt><span class="section"><a href="fusion/view/reverse_view.html">reverse_view</a></span></dt>
<dt><span class="section"><a href="fusion/view/nview.html">nview</a></span></dt>
<dt><span class="section"><a href="fusion/view/repetitive_view.html">repetitive_view</a></span></dt>
<dt><span class="section"><a href="fusion/view/flatten_view.html">flatten_view</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="fusion/adapted.html">Adapted</a></span></dt>
<dd><dl>
@ -188,7 +190,10 @@
<dt><span class="section"><a href="fusion/algorithm.html">Algorithm</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="fusion/algorithm/auxiliary.html">Auxiliary</a></span></dt>
<dd><dl><dt><span class="section"><a href="fusion/algorithm/auxiliary/functions.html">Functions</a></span></dt></dl></dd>
<dd><dl>
<dt><span class="section"><a href="fusion/algorithm/auxiliary/functions.html">Functions</a></span></dt>
<dt><span class="section"><a href="fusion/algorithm/auxiliary/metafunctions.html">Metafunctions</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="fusion/algorithm/iteration.html">Iteration</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="fusion/algorithm/iteration/functions.html">Functions</a></span></dt>

19
doc/iterator.qbk
View File

@ -513,7 +513,7 @@ Deferences the data property associated with the element referenced by an associ
#include <boost/fusion/include/deref_data.hpp>
[heading Example]
typedef __map__<__pair__<float,int&> > map;
typedef __map__<__pair__<float, int&> > map;
int i(0);
map m(1.0f,i);
@ -677,7 +677,7 @@ Returns the type stored at the position of an iterator.
[heading Description]
Returns the type that will be returned by dereferencing an iterator.
[heading Synposis]
[heading Synopsis]
template<
typename I
>
@ -721,7 +721,7 @@ Returns the type that will be returned by dereferencing an iterator.
[heading Description]
Returns the type of the next iterator in a sequence.
[heading Synposis]
[heading Synopsis]
template<
typename I
>
@ -1044,7 +1044,7 @@ Returns the type of the data property associated with the element referenced by
[heading Description]
Returns the type that will be returned by dereferencing the data property referenced by an associative iterator.
[heading Synposis]
[heading Synopsis]
template<
typename I
>
@ -1066,18 +1066,17 @@ Returns the type that will be returned by dereferencing the data property refere
[*Semantics]: Returns the result of dereferencing the data property referenced by an associative iterator of type `I`.
[heading Header]
#include <boosta/fusion/iterator/deref_data.hpp>
#include <boost/fusion/iterator/deref_data.hpp>
#include <boost/fusion/include/deref_data.hpp>
[heading Example]
typedef __map__<__pair__<float,int> > map;
typedef __result_of_begin__<vec>::type first;
BOOST_MPL_ASSERT((boost::is_same<__result_of_deref_data__<first>::type, int&>));
typedef map<pair<float, int> > map_type;
typedef boost::fusion::result_of::begin<map_type>::type i_type;
typedef boost::fusion::result_of::deref_data<i_type>::type r_type;
BOOST_STATIC_ASSERT((boost::is_same<r_type, int&>::value));
[endsect]
[endsect]
[endsect]

4
doc/notes.qbk
View File

@ -58,10 +58,10 @@ In the case:
[heading Extensibility]
Unlike __mpl__, there is no extensibe sequence concept in fusion. This does
Unlike __mpl__, there is no extensible 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
extension in Fusion is different 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

4
doc/preface.qbk
View File

@ -13,7 +13,7 @@
[heading Description]
Fusion is a library for working with heterogenous collections of data,
Fusion is a library for working with heterogeneous 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
@ -31,7 +31,7 @@ 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
manipulation of heterogeneous 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

29
doc/sequence.qbk
View File

@ -541,7 +541,7 @@ Returns the first element in the sequence.
[*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 sequence, is a valid expression. Else, returns a type convertible to
the first element in the sequence.
[*Precondition]: `__empty__(seq) == false`
@ -589,7 +589,7 @@ Returns the last element in the sequence.
[*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
sequence, is a valid expression. Else, returns a type convertible to the
last element in the sequence.
[*Precondition]: `__empty__(seq) == false`
@ -680,7 +680,7 @@ Returns the M-th element from the beginning of the sequence.
[*Return type]: Returns a reference to the M-th element from the beginning
of the sequence `seq` if `seq` is mutable and `e = o`, where `e` is the M-th
element from the beginning of the sequence, is a valid expression. Else,
returns a type convertable to the M-th element from the beginning of the
returns a type convertible to the M-th element from the beginning of the
sequence.
[*Precondition]: `0 <= M::value < __size__(s)`
@ -733,7 +733,7 @@ Returns the N-th element from the beginning of the sequence.
[*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
returns a type convertible to the N-th element from the beginning of the
sequence.
[*Precondition]: `0 <= N < __size__(s)`
@ -828,7 +828,7 @@ Returns the element associated with a Key from the sequence.
[*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.
convertible to the element associated with Key.
[*Precondition]: `has_key<Key>(seq) == true`
@ -854,13 +854,14 @@ Performs an element by element swap of the elements in 2 sequences.
[heading Synopsis]
template<typename Seq1, typename Seq2>
void swap(Seq1& seq1, Seq2& seq2);
typename __result_of_swap__<Seq1, Seq2>::type
swap(Seq1& seq1, Seq2& seq2);
[heading Parameters]
[table
[[Parameters] [Requirement] [Description]]
[[`seq1`, `seq2`][Models of __forward_sequence__][The sequences whos elements we wish to swap.]]
[[`seq1`, `seq2`][Models of __forward_sequence__][The sequences whose elements we wish to swap.]]
]
[heading Expression Semantics]
@ -873,7 +874,10 @@ Performs an element by element swap of the elements in 2 sequences.
[*Semantics]: Calls `swap(a1, b1)` for corresponding elements in `seq1` and `seq2`.
/sequence/intrinsic/swap.hpp>
[heading Header]
#include <boost/fusion/sequence/intrinsic/swap.hpp>
#include <boost/fusion/include/swap.hpp>
[heading Example]
__vector__<int, std::string> v1(1, "hello"), v2(2, "world");
@ -1391,7 +1395,7 @@ Returns the actual element type associated with a Key from the __sequence__.
[heading Example]
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>));
BOOST_MPL_ASSERT((boost::is_same<__result_of_value_at_key__<mymap, int>::type, char>));
[endsect]
@ -1415,9 +1419,10 @@ Returns the return type of swap.
[heading Expression Semantics]
result_of::swap<Seq1, Seq2>::type
[*Return type]: `void`.
[*Return type]: `void` iff both of `Seq1` and `Seq2` are sequence.
Otherwise, none.
[*Semantics]: Always returns `void`.
[*Semantics]: Returns the return type of __swap__ for 2 sequences of types `Seq1` and `Seq2`.
[heading Header]
@ -1488,7 +1493,7 @@ The code:
__vector__<int, int> j;
std::cin >> i;
std::cin >> set_open('[') >> set_close(']') >> set_delimiter(':');
std::cin >> tuple_open('[') >> tuple_close(']') >> tuple_delimiter(':');
std::cin >> j;
reads the data into the __vector__(s) `i` and `j`.

6
doc/support.qbk
View File

@ -16,7 +16,7 @@ A couple of classes and metafunctions provide basic support for Fusion.
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.
specialized to accommodate clients which provide Fusion conforming sequences.
[heading Synopsis]
@ -70,7 +70,7 @@ 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.
may be specialized to accommodate clients providing Fusion conforming views.
[heading Synopsis]
@ -125,7 +125,7 @@ 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
This metafunction may be specialized to accommodate clients providing Fusion
conforming sequences.
[heading Synopsis]

29
doc/tuple.qbk
View File

@ -23,6 +23,21 @@ As such the fusion tuple type provides a lot of functionality beyond that requir
Currently tuple is basically a synonym for __vector__, although this may be changed
in future releases of fusion.
[heading Header]
#include <boost/fusion/tuple.hpp>
#include <boost/fusion/include/tuple.hpp>
#include <boost/fusion/tuple/tuple.hpp>
#include <boost/fusion/tuple/tuple_fwd.hpp>
#include <boost/fusion/include/tuple_fwd.hpp>
// for creation function
#include <boost/fusion/tuple/tuple_tie.hpp>
#include <boost/fusion/include/tuple_tie.hpp>
#include <boost/fusion/tuple/make_tuple.hpp>
#include <boost/fusion/include/make_tuple.hpp>
[heading Synopsis]
template<
typename T1 = __unspecified__,
@ -31,8 +46,6 @@ in future releases of fusion.
typename TN = __unspecified__>
class tuple;
/tuple.hpp>
[section Construction]
[heading Description]
@ -49,7 +62,7 @@ The __tr1__tuple__ type provides a default constructor, a constructor that takes
tuple();
[*Requirements]: Each `Ti` is default constructable.
[*Requirements]: Each `Ti` is default-constructible.
[*Semantics]: Default initializes each element of the tuple.
@ -61,7 +74,7 @@ The __tr1__tuple__ type provides a default constructor, a constructor that takes
tuple(const tuple& t);
[*Requirements]: Each `Ti` should be copy constructable.
[*Requirements]: Each `Ti` should be copy-constructible.
[*Semantics]: Copy constructs each element of `*this` with the corresponding element of `t`.
@ -77,19 +90,21 @@ The __tr1__tuple__ type provides a default constructor, a constructor that takes
[section Tuple creation functions]
[heading Description]
TR1 describes 2 utility functions for creating __tr1__tuple__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.
TR1 describes 2 utility functions for creating __tr1__tuple__. `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.
[heading Specification]
template<typename T1, typename T2, ..., typename TN>
tuple<V1, V2, ..., VN> make_tuple(const T1& t1, const T2& t2, ..., const TN& 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);
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 no effect.

14
doc/view.qbk
View File

@ -484,7 +484,7 @@ defined in the implemented models.
[heading Description]
`nview` presents a view which iterates over a given __sequence__ in a specified order.
An `nview` is constructed from an arbitrary __sequence__ and a list of indicies specifying
An `nview` is constructed from an arbitrary __sequence__ and a list of indices specifying
the elements to iterate over.
[heading Header]
@ -494,7 +494,7 @@ the elements to iterate over.
[heading Synopsis]
template <typename Sequence, typename Indicies>
template <typename Sequence, typename Indices>
struct nview;
template <typename Sequence, int I1, int I2 = -1, ...>
@ -507,7 +507,7 @@ the elements to iterate over.
[[Parameter] [Description] [Default]]
[[`Sequence`] [An arbitrary Fusion __forward_sequence__]
[]]
[[`Indicies`] [A `mpl::vector_c<int, ...>` holding the indicies defining
[[`Indices`] [A `mpl::vector_c<int, ...>` holding the indices defining
the required iteration order.] []]
[[`I1`, `I2`, `I3`...] [A list of integers specifying the required
iteration order.] [`INT_MAX` for `I2`, `I3`...]]
@ -530,7 +530,7 @@ defined in __random_access_sequence__.
[table
[[Expression] [Semantics]]
[[`NV(s)`] [Creates an `nview` given a sequence and a list of indicies.]]
[[`NV(s)`] [Creates an `nview` given a sequence and a list of indices.]]
[[`NV(nv1)`] [Copy constructs an `nview` from another `nview`, `nv1`.]]
[[`nv1 = nv2`] [Assigns to an `nview`, `nv1`, from another `nview`, `nv2`.]]
]
@ -540,11 +540,11 @@ of the original Fusion __sequence__
[heading Example]
typedef __vector__<int, char, double> vec;
typedef mpl::vector_c<int, 2, 1, 0, 2, 0> indicies;
typedef mpl::vector_c<int, 2, 1, 0, 2, 0> indices;
vec v1(1, 'c', 2.0);
std::cout << nview<vec, indicies>(v1) << std::endl; // (2.0 c 1 2.0 1)
std::cout << nview<vec, indices>(v1) << std::endl; // (2.0 c 1 2.0 1)
std::cout << as_nview<2, 1, 1, 0>(v1) << std::endl; // (2.0 c c 1)
[endsect]
@ -592,7 +592,7 @@ printing a `repetitive_view` to `std::cout` is not.
[[`RV(rv1)`] [] [Copy constructs an `repetitive_view` from another `repetitive_view`, `rv1`.]]
[[`rv1 = rv2`] [] [Assigns to a `repetitive_view`, `rv1`, from another `repetitive_view`, `rv2`.]]
[[`__begin__(rv)`] [__forward_iterator__] []]
[[`__end__(rv)`] [__forward_iterator__] [Creates an unreachable iterator (since the sequnce is infinite)]]
[[`__end__(rv)`] [__forward_iterator__] [Creates an unreachable iterator (since the sequence is infinite)]]
]
[heading Result Type Expressions]