Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r64609 - in sandbox/statistics/support/libs/assign/v2: . doc doc/html example src test test/anon test/chain test/detail test/put test/put_range test/ref test/type_traits test/unit_testing
From: erwann.rogard_at_[hidden]
Date: 2010-08-05 01:25:24

Next message: ghost_at_[hidden]: "[Boost-commit] svn:boost r64610 - in trunk/tools/build/v2: . build engine/src kernel test util"
Previous message: cppljevans_at_[hidden]: "[Boost-commit] svn:boost r64608 - sandbox/variadic_templates/boost/mpl"

Author: e_r
Date: 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
New Revision: 64609
URL: http://svn.boost.org/trac/boost/changeset/64609

Log:
Adding libs/assign/v2
Added:
   sandbox/statistics/support/libs/assign/v2/
   sandbox/statistics/support/libs/assign/v2/doc/
   sandbox/statistics/support/libs/assign/v2/doc/Jamfile.v2 (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/doc/boost_assign_v2.qbk (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/doc/html/
   sandbox/statistics/support/libs/assign/v2/doc/html/index.html (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/example/
   sandbox/statistics/support/libs/assign/v2/example/tutorial.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/example/tutorial.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/src/
   sandbox/statistics/support/libs/assign/v2/src/main.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/
   sandbox/statistics/support/libs/assign/v2/test/anon/
   sandbox/statistics/support/libs/assign/v2/test/anon/anon.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/anon/anon.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/chain/
   sandbox/statistics/support/libs/assign/v2/test/chain/chain.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/chain/chain.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/chain/convert.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/chain/convert.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/detail/
   sandbox/statistics/support/libs/assign/v2/test/detail/functor.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/detail/functor.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/put/
   sandbox/statistics/support/libs/assign/v2/test/put/modifier.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/put/modifier.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/put/put_wrapper.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/put/put_wrapper.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/put_range/
   sandbox/statistics/support/libs/assign/v2/test/put_range/convert.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/put_range/convert.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/
   sandbox/statistics/support/libs/assign/v2/test/ref/convert_traits.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/convert_traits.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/csv_anon.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/csv_anon.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/ext_anon.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/ext_anon.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/fusion_list.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/fusion_list.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/static_list.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/static_list.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/wrapper.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/ref/wrapper.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/type_traits/
   sandbox/statistics/support/libs/assign/v2/test/type_traits/has_push.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/type_traits/has_push.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/type_traits/has_static_size.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/type_traits/has_static_size.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/type_traits/has_value_type.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/type_traits/has_value_type.h (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/unit_testing/
   sandbox/statistics/support/libs/assign/v2/test/unit_testing/Jamfile.v2 (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/unit_testing/anon.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/unit_testing/chain.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/unit_testing/detail.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/unit_testing/put.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/unit_testing/put_range.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/unit_testing/ref.cpp (contents, props changed)
   sandbox/statistics/support/libs/assign/v2/test/unit_testing/type_traits.cpp (contents, props changed)

Added: sandbox/statistics/support/libs/assign/v2/doc/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/doc/Jamfile.v2 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,14 @@
+
+import boostbook : boostbook ;
+using quickbook ;
+
+boostbook boost_assign_v2
+ :
+ boost_assign_v2.qbk
+ :
+ <xsl:param>boost.max.id.length=1024
+ <xsl:param>toc.max.depth=4
+ <xsl:param>toc.section.depth=4
+ <xsl:param>chunk.section.depth=2
+ <xsl:param>html.stylesheet="/usr/local/trunk/libs/non_parametric/doc/boostbook.css"
+ ;

Added: sandbox/statistics/support/libs/assign/v2/doc/boost_assign_v2.qbk
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/doc/boost_assign_v2.qbk 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,1238 @@
+[library Boost.Assign
+ [quickbook 1.5]
+ [version 2.0]
+ [authors [Thorsten, Ottosen],[Rogard, Erwann]]
+ [copyright 2003-2004 Thorsten Ottosen, 2010 Erwann Rogard]
+ [dirname /libs/assign/v2/doc/]
+ [license
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ [@http://www.boost.org/LICENSE_1_0.txt])
+ ]
+ [id boost_assign_v2]
+]
+
+[/ External]
+
+[def __boost__ [@http://www.boost.org Boost]]
+[def __mpl__ [@http://www.boost.org/libs/mpl/index.html MPL]]
+[def __stl__ [@http://en.wikipedia.org/wiki/Standard_Template_Library STL]]
+[def __user_mailing_list__ [@http://www.boost.org/community/groups.html#users Boost Users Mailing List]]
+
+[def __concept_range__ [@http://www.boost.org/doc/libs/1_35_0/libs/range/doc/range.html Range]]
+[def __header_range__ [@http://www.boost.org/doc/libs/1_35_0/libs/range/doc/range.html #include <boost/range.hpp>]]
+
+[def __boost_lambda__ [@http://www.boost.org/doc/libs/release/libs/lambda boost::lambda]]
+
+[def __header_typeof__ [@http://www.boost.org/doc/libs/1_36_0/doc/html/typeof.html #include <boost/typeof/typeof.hpp>] ]
+[def __header_assert__ [@http://www.boost.org/doc/libs/release/libs/utility/assert.html #include <boost/assert.hpp>] ]
+
+[/ Internal]
+
+[def __boost_assign_v2__ Boost.Assign v2]
+
+[def __lvalue__ lvalue]
+[def __unspecified__ /unspecified/]
+[def __implementation_defined__ '''<replaceable>implementation-defined</replaceable>''']
+
+[def __TO__ [@http://www.boost.org/users/people/thorsten_ottosen.html TO]]
+[def __ER__ [@mailto:er.ci.2020_at_[hidden] ER]]
+
+[def __local_boost_dir__ boost/assign/v2]
+[def __local_libs_dir__ libs/assign/v2]
+[def __local_ns__ boost::assign::v2]
+
+[/ Templates]
+[def __type_ext__ _]
+[template tpl_join[a b][a][b]]
+[template tpl_typeof[object][tpl_join [object]..__type_ext__]]
+
+[/Use In principle use like this:
+inlined : tpl_typeof[`object`]
+code block: ``tpl_typeof[object]`` <--- TODO causes line breaks!!!
+but in practice define: [def __value___ [tpl_typeof __value__]] and use __value___
+]
+
+[template tpl_seq[index first last] [index] = [first], ..., [last]]
+[template tpl_sub[var index] [var]\[[index]\] ]
+[template tpl_sub_sub[var index1 index2] [var]\[[index1],[index2]\]]
+
+[/ Pertain to input --> fun --> output ]
+
+[def __container__ v]
+[def __container___ [tpl_typeof __container__]]
+[def __value__ t]
+[def __value___ [tpl_typeof __value__]]
+[def __f__ f]
+[def __f___ [tpl_typeof __f__]]
+[def __object__ object]
+[def __object___ [tpl_typeof __object__]]
+[def __range__ r]
+[def __range___ [tpl_typeof __range__]]
+[def __param__ p]
+[def __param___ [tpl_typeof __param__]]
+
+[def __arg__ x]
+[def __arg_0__ a]
+[def __arg_1__ b]
+[def __arg_2__ c]
+
+[/ Containers]
+[def __array__ [@http://www.boost.org/doc/html/array/reference.html array]]
+[def __array___ [tpl_typeof __array__]]
+[def __deque__ [@http://www.sgi.com/tech/stl/Deque.html deque]]
+[def __deque___ [tpl_typeof __deque__]]
+[def __list__ [@http://www.sgi.com/tech/stl/List.html list]]
+[def __list___ [tpl_typeof __list__]]
+[def __map__ [@http://www.sgi.com/tech/stl/Map.html map]]
+[def __map___ [tpl_typeof __map__]]
+[def __queue__ [@http://www.sgi.com/tech/stl/queue.html queue]]
+[def __queue___ [tpl_typeof __queue__]]
+[def __set__ [@http://www.sgi.com/tech/stl/set.html set]]
+[def __set___ [tpl_typeof __set__]]
+[def __stack__ [@http://www.sgi.com/tech/stl/stack.html stack]]
+[def __stack___ [tpl_typeof __stack__]]
+[def __tuple__ [@http://www.boost.org/libs/tuple/doc/tuple_users_guide.html tuple]]
+[def __tuple___ [tpl_typeof __tuple__]]
+[def __vec__ [@http://www.sgi.com/tech/stl/Vector.html vec]]
+[def __vec___ [tpl_typeof __vec__]]
+
+[/Indexes]
+[def __i__ i]
+[def __n__ n]
+[def __j__ j]
+[def __k__ k]
+
+[/ ---- Library components ---- ]
+
+[def __functor_form__ ['functor]]
+[def __csv_form__ ['csv]]
+
+[def __ref_wrapper__ w]
+[def __ref_wrapper___ [tpl_typeof __ref_wrapper__]]
+[def __AssignCopy__ AssignCopy]
+[def __AssignRebind__ AssignRebind]
+
+[/ PP constants]
+
+[def __pp_arity_bound__ BOOST_ASSIGN_V2_ARITY_BOUND]
+[def __pp_lvalue_const_arity_bound__ BOOST_ASSIGN_V2_LVALUE_CONST_ARITY_BOUND]
+[def __pp_csv_arity_bound__ BOOST_ASSIGN_V2_CSV_ARITY_BOUND]
+
+[/ Headers ]
+
+[def __header_tutorial__ #include <libs/assign/v2/example/tutorial.h>]
+[def __header_tutorial__ #include <libs/assign/v2/example/tutorial.h>]
+
+[def __header_anon__ #include <__local_boost_dir__/anon/anon.hpp>]
+[def __header_chain__ #include <__local_boost_dir__/chain/chain.hpp>]
+[def __header_arity_bound__ #include <boost/assign/v2/detail/config/arity_bound.hpp>]
+[def __header_functor_crtp__ #include <boost/assign/v2/detail/functor/crtp_unary_and_up.hpp>]
+[def __header_put__ #include <__local_boost_dir__/put/put.hpp>]
+[def __header_put_range__ #include <__local_boost_dir__/put/range.hpp>]
+[def __header_ref__ #include <__local_boost_dir__/ref/ref.hpp>]
+[def __header_keywords__ #include <__local_boost_dir__/detail/keywords/keywords.hpp>]
+
+[/ Tags ]
+
+[def __put_tag__ '''<replaceable>put-tag</replaceable>''']
+[def __ref_assign_tag__ '''<replaceable>ref-assign-tag</replaceable>''']
+
+[/ Namespace]
+
+[def __ref__ ref]
+[def __ref_assign_copy__ ref::assign_copy]
+[def __ref_assign_rebind__ ref::assign_rebind]
+[def __ns_put_tag__ put_tag]
+
+[/ Functions ]
+
+[def __anon__ anon]
+[def __anon_nil__ anon_nil]
+[def __chain__ chain]
+[def __constructor__ constructor]
+[def __convert__ convert]
+[def __csv__ csv]
+[def __csv_anon__ csv_anon]
+[def __put_wrapper__ put_wrapper]
+[def __put_range__ put_range]
+
+[/ Metafunctions]
+
+[def __result_of__ result_of]
+[def __nth_result_of__ nth_result_of]
+
+[/ Keywords]
+[def __nil__ _nil]
+[def __incr_lookup__ _incr_lookup]
+[def __repeat__ _repeat]
+[def __put_kwd__ _put_tag]
+[def __unwrap__ _unwrap]
+[def __deduce__ _deduce]
+[def __fun__ _fun]
+
+[section _][/ TODO remove this. For now, the formatting sucks w/o it]
+
+Question to QBK authors : Without this dummy enclosing section (_), layout is messy. Why?
+
+[section Introduction]
+
+This library offers a uniform interface for initializing or assigning containers, and working with
+collections of references. The relevant directory structure is rooted [^boost/assign/v2]. Each
+directory in this structure contains an [^.hpp] file by the same name which includes all its relevant files. We assume, throughout this documentation, that
+
+ __header_assert__
+ __header_range__
+ #include <__local_boost_dir__/v2.hpp>
+ using namespace __local_ns__;
+
+precedes all C++ statements.
+
+[endsect][/Introduction]
+[section Notation]
+
+To represent an `__object__` and its type, we use the convention that is implicit below:
+
+ __object___ __object__;
+
+[table Symbols
+ [[Symbol][Description]]
+ [
+ [`__container__`]
+ [ A container of unspecified type]
+ ]
+ [
+ [`__value__`]
+ [ Element in a container]
+ ]
+ [
+ [`__f__`]
+ [ A function ]
+ ]
+ [
+ [`__object__`]
+ [ An object returned by a function ]
+ ]
+ [
+ [`__param__`]
+ [ A parameter to an object ]
+ ]
+ [
+ [`__arg__`]
+ [ An argument to a function ]
+ ]
+ [
+ [`__arg_0__`]
+ [Argument in the first call to a function ]
+ ]
+ [
+ [`__arg_1__`]
+ [Argument in the second call to a function ]]
+ [
+ [`__arg_2__`]
+ [Argument in the third call to a function ]
+ ]
+]
+
+[table Expressions
+ [
+ [ Expression ]
+ [ Description]
+ ]
+ [
+ [ [^[tpl_seq __i__..0..__n__-1]] ]
+ [Indexes a sequences of `__value__`'s]
+ ]
+ [
+ [ [^[tpl_seq __j__..0..__k__-1]] ]
+ [Indexes arguments in a function call]
+ ]
+ [
+ [ [^[tpl_sub __k__..__i__]] ]
+ [Number of arguments of the __i__ th functional call]
+ ]
+ [
+ [ [^[tpl_sub_sub `__arg__`..__i__..__j__]] ]
+ [__j__ th argument of the __i__ th functional call]
+ ]
+ [
+ [ [^[tpl_sub `__arg_0__`..__j__]] ]
+ [ [^[tpl_sub_sub `__arg__`..0..__j__]] ]
+ ]
+ [
+ [ [^[tpl_sub `__arg_1__`..__j__]] ]
+ [ [^[tpl_sub_sub `__arg__`..1..__j__]] ]
+ ]
+ [
+ [ [^[tpl_sub `__arg_2__`..__j__]] ]
+ [ [^[tpl_sub_sub `__arg__`..2..__j__]] ]
+ ]
+]
+
+Note that if [^__k__ = 0], in the context of a function call, it means that `f()` is called. In
+the context of constructing `__value__`, `__value___()' is called.
+
+[endsect][/Notation]
+[section Tutorial]
+
+[section Putting elements into to a container]
+All three expressions in each row have the same side effect:
+[table Elementwise
+ [
+ [Expression1]
+ [Expression2]
+ [Expression3]
+ ]
+ [
+ [``
+ __queue__.push(__arg_0__);
+ __queue__.push( __value___() );
+ __queue__.push( __value__( __arg_2__[0], __arg_2__[1] ) );
+ ``]
+ [``
+ __put_wrapper__( __queue__ ).__csv__( __arg_0__ )( __value___() )( __value__( __arg_2__[0], __arg_2__[1] ) )
+ ``]
+ [``
+ __put_wrapper__( __queue__ )( __arg_0__ )()( __arg_2__[0], __arg_2__[1] );
+ ``]
+ ]
+ [
+ [``
+ __map__[ __arg_0__ ] +=2 ; ++__map__[ __arg_1__ ];
+ ``]
+ [``
+ ( __put_wrapper__( __map__ ) % __incr_lookup__).__csv__( __arg_0__, __arg_1__, __arg_0__ );
+ ``]
+ [``
+ ( __put_wrapper__( __map__ )( __arg_1__ ) % __incr_lookup__ % ( __repeat__ = 2 ) )( __arg_0__ );
+ ``]
+ ]
+ [
+ [``
+ __deque__.push_back( __tuple___( __arg_0__[0], __arg_0__[1] ) );
+ __deque__.push_back( __tuple___( __arg_1__[0], __arg_0__[1] ) );
+ __deque__.push_back( __tuple___( __arg_2__[0], __arg_0__[1]) );
+ ``]
+ [``
+ using namespace __boost_lambda__;
+ ( __put_wrapper__( __deque__ ) % ( _fun = bind<__tuple___>(
+ __constructor__<__tuple___>(), _1, __arg_0__[1] )
+ ) )( __arg_0__[0] )( __arg_1__[0] )( __arg_2__[0] );
+ ``]
+ [ __unspecified__ ]
+ ]
+
+]
+
+[important Elements are passed by reference. In the example involving a `__tuple__`, it may have,
+for example, an __lvalue__ and a `const` reference as its elements.]
+
+To pass a `__concept_range__`, `from`, to an arbitrary container, `to`,
+``
+ __put_range__( from, to );
+``
+To assign a `__concept_range__` to a container,
+``
+ to = __convert__<To>( from );
+``
+
+[endsect][/ Putting elements]
+[section Anonymous container (of values) ]
+
+An anonymous container is created by using the same interface as that of `__put_wrapper__` and
+has most of the functionality of `__deque___` plus the conversion (to an arbitrary container)
+capability:
+``
+ to = __anon__( __arg_0__ )( __arg_1__ )( __arg_2__ );
+``
+To copy-construct `to`,
+``
+ to = __anon__( __arg_0__ )( __arg_1__ )( __arg_2__ ).__convert__<To>();
+``
+To be able to use `operator%`,
+``
+ to = ( __anon__<__value___>( __nil__ ) % (__repeat__ = n ) )( a )( b )( c );
+``
+[endsect][/Anon]
+[section Anonymous container of references]
+
+An anonymous collection of references is created with a function with the same name as its
+value counterpart (above), `__anon__`, but in the nested `namespace` `__ref__`, and by specifying
+a __ref_assign_tag__ template argument:
+
+ using namespace __ref__;
+ __anon__<__ref_assign_tag__>( __arg_0__ )( __arg_1__ )( __arg_2__ );
+
+The resulting container holds references to the arguments. Clearly only unary function calls
+are allowed. The template argument __ref_assign_tag__ specifies how references are assigned :
+using copy semantics or rebind semantics. Finally, there is a __csv_form__ form as well. Rather
+than specifying __ref_assign_tag__, it is equivalent to use a dedicated `namespace`, in the
+example that follows, `__ref_assign_copy__`:
+
+``
+ using namespace __ref_assign_copy__;
+ boost::copy( v , boost::begin( __anon__( a )( b )( c ) ) );
+ BOOST_ASSERT( a == v[0] );
+ BOOST_ASSERT( c == v[2] );
+``
+
+This example illustrates both the __csv_form__ form and rebind semantics:
+``
+ __header_typeof__
+ using namespace __ref_assign_rebind__;
+ BOOST_AUTO( tmp, __csv_anon__( a , b ) );
+ tmp.assign( c );
+ BOOST_ASSERT( &tmp[ 0 ] == &c );
+ BOOST_ASSERT( &tmp[ 1 ] == &c );
+``
+[endsect][/ Anon refs]
+[section Chaining ranges]
+To assign from chained ranges:
+``
+ to = (r1 && r2 && r3).__convert__<To>();
+``
+Chaining is elementwise-__lvalue__ preserving:
+``
+ __header_typeof__
+ using namespace __ref_assign_copy__;
+ BOOST_AUTO( tmp, __anon__( a )( b ) );
+ copy( v , boost::begin( tmp && __anon__( c ) ) );
+ BOOST_ASSERT( a == __container__[0] );
+ BOOST_ASSERT( b == __container__[1] );
+ BOOST_ASSERT( c == __container__[2] );
+``
+The fact that `__anon__( c )`, above, returns an rvalue should underscore the significance of ['elementwise]
+in our previous statement.
+
+[endsect] [/chain]
+[section Running the code]
+
+The file below contains similar material,
+
+``
+ __header_tutorial__
+``
+
+and is be executed like this:
+
+``
+ __header_tutorial__
+ int main()
+ {
+ using namespace example_assign_v2;
+ xxx_tutorial::run();
+ return 0;
+ }
+``
+[endsect][/Run]
+[endsect][/Tutorial]
+[section Library interface and design]
+
+This section discusses general features of the interface and concerns the `__object__` s returned
+by
+
+* `anon()`
+* `put_wrapper()`
+* `ref::__anon__()`
+* `ref::csv_anon()`
+
+Functions are the primary interface by which the user interacts with the library. However,
+it is the object that they return that are responsible for performing the desired task. The
+relationship between a function and its resulting object can be formalized as follows, where
+both expressions have the same side effect:
+
+[table
+ [
+ [Expression1]
+ [Expression2]
+ ]
+ [
+ [``
+ fun( __arg_0__ )( __arg_1__ )( __arg_2__ );
+ ``]
+ [``
+ result_of::fun_nil<T>::type __object__ = fun<T>( __nil__ );
+ __object__( __arg_0__ )( __arg_1__ )( __arg_2__ );
+ ``]
+ ]
+]
+
+In `namespace` `__ref__` with `__anon__` as `fun`, this is exactly the representation that is used.
+In other segments of the library, however, although the interface may not match exactly that above,
+a similar idea is at work.
+
+To avoid passing to functions many, in fact any, parameters that would confuse the user and cause the developer a headache,
+the library usually deduces the parameters from its input using traits. Considering, for example,
+the `__put_wrapper__` functionality, the library, by default,
+
+* Calls a functor, `__constructor__<__value__>()`, which is overloaded on the number and
+ __lvalue__/`const`-ness of its arguments, and returns the type of the elements in the
+ destination container.
+* Another traits decides which modifier (such as `push_back()`) to use given certain properties
+ of the container. For example, if the container has `push()` it takes precedence over
+ `push_back()`.
+
+For example, the side effect of
+ ``
+ put_wrapper( map )( key1, a )( key2, b )( key3, c )
+``
+is identical to that of
+``
+ map.insert( make_pair( key1, a ) );
+ map.insert( make_pair( key2, b ) );
+ map.insert( make_pair( key3, c ) );
+``
+
+The deduced parameters that we have just discussed can be selectively overriden with `operator%`
+taking as its first argument the result of the function, and a ['keyword]. A keyword is a `const`
+object defined in an anonymous namespace whose identifier has prefix `_`. Here's the generic form
+``
+ __object__ % _keyword;
+``
+or
+``
+ __object__ % (_keyword = __param__);
+``
+Operators are usually composable e.g.
+``
+ object % _keyword1 % (_keyword2 = __param__);
+``
+In each case, the operation may return a reference to the same `__object__`, but with a different state,
+or a new object of a different type altogether, thereby modifying the semantics of
+subequent calls to the object. For example,
+``
+ (__put_wrapper__( __map__ ) % __incr_lookup__)( __arg_0__ )( __arg_1__ )( __arg_2__ )
+``
+
+is equivalent to
+
+``
+ ++ __map__ [ __arg_0__ ];
+ ++ __map__ [ __arg_1__ ];
+ ++ __map__ [ __arg_2__ ];
+``
+[endsect][/ Library interface and design]
+[section Reference]
+[section Overload resolution]
+
+This section concerns the `__object__` s returned by
+
+* `anon()`
+* `put_wrapper()`
+* `ref::__anon__()`
+* `ref::csv_anon()`
+
+[heading Headers]
+ __header_arity_bound__
+ __header_functor_crtp__
+
+[heading __functor_form__ and __csv_form__ forms]
+
+[table The functor and csv forms
+ [
+ [Syntax ]
+ [ Designation ]
+ ]
+ [
+ [``
+ __f__( __arg__[0,0], ..., __arg__[0,__k__(0)-1] ) ... ( __arg__[__n__-1,0], ..., __arg__[__n__-1,__k__(__n__-1)-1] )
+ ``]
+ [ __functor_form__ ]
+ ]
+ [
+ [``
+ f( __arg__[0], ..., __arg__[__n__-1] )
+ ``]
+ [ __csv_form__ ]
+ ]
+]
+
+[note The arguments are passed as references. ]
+[important The rules for `ref::__anon__()` are those of the __csv_form__.]
+
+[heading Arity]
+
+Let [^m] designates the constant under consideration in each row below:
+
+[table Preprocessor constants
+ [
+ [Name]
+ [ Relevant [br] form ]
+ [ User [br] definable ]
+ [ Implication ]
+ ]
+ [ [__pp_arity_bound__][ __functor_form__ ][ Yes ][ [^__k__ < m] ] ]
+ [ [__pp_lvalue_const_arity_bound__][ __functor_form__ ][ No ][ See below ] ]
+ [ [__pp_csv_arity_bound__][ __csv_form__ ][ Yes ][ [^__n__ < m] ] ]
+]
+
+Necessary and sufficient conditions for preserving __lvalue__-ness, for a given [^__j__], are
+[table
+ [ [Function ][ Condition ]]
+ [ [ [^__i__]th call to __functor_form__ ][ [^__k__(__i__) < m] or all of `__arg__[__i__,0]`,...,`__arg__[__i__,__k__(__i__)-1]` are __lvalue__ s ]]
+ [ [ __csv_form__ ][ All of `__arg__[0]`,...,`__arg__[__n__-1]` are __lvalue__ s ]]
+]
+where [^m] is as previously defined, looking at the second row of the preceding table. If the condition,
+in each row, is violated, the overload whose arguments are all `const` references is that which is
+resolved to.
+
+[endsect][/ overload resolution ]
+[section Keywords]
+[section __deduce__]
+[heading Expression Semantics]
+``
+ __object__ % deduce;
+``
+[*Return type] __implementation_defined__
+
+[*Semantics] __unspecified__
+
+[heading Header]
+``
+ __header_keywords__
+``
+[endsect][/deduce]
+[section __fun__]
+[heading Expression Semantics]
+``
+ __object__ % ( _fun = f);
+``
+
+[*Return type] __implementation_defined__
+
+[*Semantics] __unspecified__
+
+[heading Header]
+``
+ __header_keywords__
+``
+[endsect][/fun]
+[section __nil__]
+[heading Expression Semantics]
+``
+ f( _nil );
+``
+
+[*Return type] __implementation_defined__
+
+[*Semantics] __unspecified__
+
+[heading Header]
+``
+ __header_keywords__
+``
+[endsect][/nil ]
+[section __unwrap__]
+[heading Expression Semantics]
+``
+ __unspecified__
+``
+
+[*Return type] __implementation_defined__
+
+[*Semantics] __unspecified__
+
+[heading Header]
+``
+ __header_keywords__
+``
+[endsect][/unwrap ]
+[section __incr_lookup__]
+[heading Expression Semantics]
+``
+ __unspecified__
+``
+[*Return type] __implementation_defined__
+
+[*Semantics] __unspecified__
+
+[heading Header]
+``
+ __header_keywords__
+``
+[endsect][/incr_lookup ]
+[section __repeat__]
+[heading Expression Semantics]
+``
+ __object__ % (__repeat__ = n);
+``
+
+[*Return type] __implementation_defined__
+
+[*Semantics] __unspecified__
+
+[heading Header]
+``
+ __header_keywords__
+``
+[endsect][/repeat ]
+[section __put_kwd__]
+[heading Expression Semantics]
+``
+ __object__ % (__put_kwd__ = __put_tag__());
+``
+
+[*Return type] __implementation_defined__
+
+[*Semantics] Selects a container modifier.
+
+[table Candidate tags.
+ [[Name]]
+ [[`__ns_put_tag__::at_next`]]
+ [[`__ns_put_tag__::insert`]]
+ [[`__ns_put_tag__::push`]]
+ [[`__ns_put_tag__::push_back`]]
+]
+
+[heading Header]
+``
+ __header_put__
+``
+[header Example]
+``
+ __object__ % (__put_kwd__ = __ns_put_tag__::push());
+``
+[endsect][/put_tag ]
+[endsect][/Keywords]
+[section `__anon__`]
+[heading Description]
+
+Creates an anonymous container
+
+* With the same interface as `__put_wrapper__`
+* and converts to an arbitrary container
+
+[heading Synopsis]
+
+[table
+ [[Syntax][Designation]]
+ [
+ [``
+ template<typename T>
+ typename __result_of__::__anon__<T>::type
+ anon( keyword_aux::nil const& );
+ ``]
+ [ ['(1)] ]
+ ]
+ [
+ [``
+
+ template<typename T>
+ typename __result_of__::__anon__<T>::type
+ anon( T& );
+ ``]
+ [ ['(2)] ]
+ ]
+ [
+ [``
+
+ template<typename T>
+ typename __result_of__::__anon__<T const>::type
+ anon( T const& );
+ ``]
+ ]
+]
+[heading Parameters]
+
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[T] [__unspecified__] [Value of argument to `__anon__`]]
+]
+
+[heading Expression Semantics]
+
+[table
+ [[Expression][Designation]]
+ [
+ [``
+ anon<T>( __nil__ );
+ ``]
+ [ ['(1) ] ]
+ ]
+ [
+ [``
+ anon( __value__ );
+ ``]
+ [ ['(2)] and ['(3)] ]
+ ]
+]
+
+[*Return type]: `__result_of__::__anon__<T>::type` for each ['(1)], ['(2)] and ['(3)]
+
+[*Semantics]: Creates an anonymous container.
+
+[heading Header]
+
+ __header_anon__
+
+[heading Example]
+
+[table
+ [[Expression][Designation]]
+ [
+ [``
+ __anon__<int>( __nil__ );
+ ``]
+ [ ['(1) ] ]
+ ]
+ [
+ [``
+ int __arg_0__; __anon__( __arg_0__ );
+ ``]
+ [ ['(2)] ]
+ ]
+ [
+ [``
+ __anon__( 1 );
+ ``]
+ [ ['(2)] ]
+ ]
+]
+
+[endsect] [/ anon]
+[section __chain__]
+
+Forms a range by chaining two ranges in a way that
+
+* preserves __lvalue__-ness ['elementwise]. If, for example, the two ranges are `const` but
+their elements are __lvalue__--reference wrappers, then the dereference value of the underlying
+iterator is also __lvalue__.
+* is convertible to an arbitrary container.
+
+[heading `namespace`]
+``
+ using namespace adaptor;
+``
+
+[heading Synopsis]
+
+``
+ template<typename R1,typename U2>
+ typename __result_of__::__chain__<R1,R2>::type
+ operator|(U1& r1,chain_aux::adaptor1<U2,boost::use_default>);
+``
+
+[note `U1` = `R1` or `R1 const` and likewise for `U2`. ]
+
+[heading Parameters]
+
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[R1] [models __concept_range__] [Range to be chained]]
+ [[R2] [models __concept_range__] [Range to chain to]]
+]
+
+[heading Expression Semantics]
+
+``
+ r1 | _chain( r2 );
+``
+
+[*Return type]: `__result_of__::__chain__<U1,U2>::type`
+
+[*Semantics]: Chains two ranges to form one.
+
+[heading Header]
+``
+ __header_chain__
+``
+
+[heading Example]
+``
+ using namespace adaptor;
+ std::vector<int> __container__( 2, -1);
+ boost::array<int,2> __array__; __array__.assign( 1 );
+ __container__ | __chain__( __array__ );
+``
+[heading `operator&&`]
+
+These are two equivalent ways to chain:
+
+[table
+ [[Expression 1][Expression 2]]
+ [
+ [``
+ r1 | _chain( r2 );
+ ``]
+ [``
+ r1 && r2;
+ ``]
+ ]
+]
+[endsect][/chain]
+[section `__convert__`]
+[heading Description]
+
+Assigns a __concept_range__ to an arbitrary container.
+
+[heading Synopsis]
+
+ template<typename To, typename From>
+ To __convert__( From const& from);
+
+[heading Parameters]
+
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[From] [models __concept_range__] [The argument to `__convert__`]]
+ [[To] [__unspecified__] [The return type of `__convert__`]]
+]
+
+[heading Expression Semantics]
+
+``
+ convert<To>( from );
+``
+
+[*Return type]: To
+
+[*Semantics]: Assigns `to` with the elements of `from`
+
+[heading Header]
+
+ __header_put_range__
+
+[heading Example]
+
+``
+ std::vector<int> from; from.push_back( -1 ); from.push_back( 0 );
+ typedef std::queue<int> to_;
+ to_ to = from.convert<to_>();
+``
+
+[endsect] [/ convert]
+[section `__put_range__`]
+[heading Description]
+
+Puts the elements of a __concept_range__ into an arbitrary container.
+
+[heading Synopsis]
+
+``
+ template<typename From,typename To>
+ To& put_range( From const&, To& to );
+``
+
+[heading Parameters]
+
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[From] [models __concept_range__] [The first argument to `__put_range__`]]
+ [[To] [__unspecified__] [The second argument to `__put_range__`]]
+]
+
+[heading Expression Semantics]
+
+``
+ put_range( from, to );
+``
+
+[*Return type]: To&
+
+[*Semantics]: Puts the elements in `from` into `to`.
+
+[heading Header]
+
+ __header_put_range__
+
+[heading Example]
+
+ std::vector<int> from; from.push_back( -1 ); from.push_back( 0 );
+ std::queue<int> to;
+ put_range( from, to );
+
+[endsect] [/ put_range]
+[section `__put_wrapper__`]
+[heading Description]
+
+Wraps around a container to be able to put elements into it, with a __functor_form__ or __csv_form__ interface.
+
+[heading Synopsis]
+
+ template<typename V>
+ typename __result_of__::__put_wrapper__<V>::type
+ put_wrapper( V& __container__);
+
+[heading Parameters]
+
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[V] [__unspecified__] [The argument to `__put_wrapper__`]]
+]
+
+[heading Expression Semantics]
+
+ put_wrapper( v );
+
+[*Return type]: `__result_of__::__put_wrapper__<V>::type`
+
+[*Semantics]: Creates an `object` with a __functor_form__ or __csv_form__ interface.
+
+[heading Header]
+
+ __header_put__
+
+[heading Example]
+
+ std::vector<int> __container__;
+ put_wrapper( __container__ );
+
+[endsect] [/ put_wrapper]
+[section `ref::__anon__`]
+
+[heading Namespace]
+``
+ __header_ref__
+ using namespace ref;
+``
+
+[heading Background on assign semantics]
+
+Let a reference wrapper, `__ref_wrapper__`, bind to some reference `y1` and that it is assigned as follows:
+``
+ __ref_wrapper__ = y2;
+``
+where `y2` is of the same type as `y1`. There are two possible semantics which are captured
+by the concepts below:
+
+[table Concepts
+ [[Name][Requirement]]
+ [[['__AssignCopy__]][ y2 == y1; ]]
+ [[['__AssignRebind__]][ &y2 == &y1; ]]
+]
+
+[heading Description]
+
+Creates a collection of references.
+
+[heading Synopsis]
+
+[table
+ [ [Syntax] [Designation]]
+ [
+ [``
+ template<typename Tag1, typename T>
+ typename result_of::anon_nil<Tag1, T>::type
+ anon( keyword_aux::nil );
+ ``]
+ [ ['(1)] ]
+ ]
+ [
+ [``
+ template<typename Tag1,typename T>
+ typename result_of::anon<Tag1, T>::type
+ ``]
+ [ ['(2)] ]
+ ]
+ [
+ [``
+ template<typename Tag1,typename T>
+ typename result_of::anon<Tag1, T const>::type
+ anon(T const & t);
+ ``]
+ [ ['(3)] ]
+ ]
+]
+
+[heading Parameters]
+
+[table
+ [[Parameter] [Requirement] [Description] ]
+ [[Tag1] [__unspecified__] [Controls assignement semantics] ]
+ [[T] [__unspecified__] [Value of the element(s) to reference to] ]
+]
+
+[heading Expression Semantics]
+
+[table
+ [ [Expression] [Designation]]
+ [
+ [`anon<__ref_assign_tag__>( __nil__ );` ]
+ [ ['(1)] ]
+ ]
+ [
+ [`anon<__ref_assign_tag__>( __value__ );`]
+ [ ['(2)] and ['(3)] ]
+ ]
+]
+
+[*Return type]:
+
+[table
+
+ [ [Expression] [Designation]]
+ [
+ [`__result_of__::__anon_nil__<__ref_assign_tag__,T>::type`]
+ [ ['(1)] ]
+ ]
+ [
+ [`__result_of__::__anon__<__ref_assign_tag__,T>::type`]
+ [ ['(2)] ]
+ ]
+ [
+ [`__result_of__::__anon__<__ref_assign_tag__,T const>::type`]
+ [ ['(3)] ]
+ ]
+]
+
+[*Semantics]: Creates a collection of references.
+
+[heading Header]
+
+ __header_ref__
+
+[heading Example]
+
+[table
+ [ [Expression] [Designation]]
+ [
+ [ `__anon__<int const>( __nil__ )( 1 )( 2 )( 3 );` ]
+ [ ['(1)] ]
+ ]
+ [
+ [``
+ int __arg_0__, __arg_1__, __arg_2__;
+ __anon__<int>( __arg_0__ )( __arg_1__ )( __arg_2__ );
+ ``]
+ [ ['(2)] ]
+ ]
+ [
+ [ `__anon__( 1 )( 2 )( 3 )` ]
+ [ ['(3)] ]
+ ]
+]
+
+[heading Copy semantics]
+
+The two expresions below are equivalent
+[table
+ [ [Expression1] [Expression2]]
+ [
+ [``
+ anon<assign_tag::copy>( __value__ );
+ ``]
+ [``
+ using namespace assign_copy;
+ anon( __value__ );
+ ``]
+ ]
+]
+
+[heading Rebind semantics]
+
+The two expresions below are equivalent
+[table
+ [ [Expression1] [Expression2]]
+ [
+ [``
+ anon<assign_tag::rebind>( __value__ );
+ ``]
+ [``
+ using namespace assign_rebind;
+ anon( __value__ );
+ ``]
+ ]
+]
+
+[endsect] [/ref::__anon__]
+[endsect] [/Reference]
+[section Portability ]
+
+[heading Methodology]
+
+For each of a set of containers (see below), ensure
+
+* At compile time, that the method deduced for modifying the container agrees with one that
+ is explicitly specified. For example, it verifies that `push()` is the method used for
+ `std::queue`.
+
+* At runtime time, that the container returned by
+``
+ convert<To>( from );
+``
+has the same elements as that of `from`, where `To` is the type of the container being tested.
+
+[table Containers tested
+ [[Container][Result]]
+ [[`boost::array<>`][OK]]
+ [[`std::deque<>`][OK]]
+ [[`std::list<>`][OK]]
+ [[`std::queue<>`][OK]]
+ [[`std::set<>`][OK]]
+ [[`std::set<>`][OK]]
+ [[`std::stack<>`][OK]]
+ [[`std::vector<>`][OK]]
+]
+
+[table Tests
+ [[OS][Compiler][Date ][Result]]
+ [[Mac OS X v10.6][GCC 4.2][August 2nd, 2010][Passed]]
+]
+
+[heading Dependencies]
+
+A previously avalaible set of files in the Vault, for chaining, by RangeEx, are made
+temporarily available [@http://svn.boost.org/svn/boost/sandbox/statistics/support/boost/range/ here]
+and need to be in the search path.
+
+[endsect]
+[section Change log]
+
+[heading Upgrading from Boost. v['1.4x]]
+
+* This upgrade to __boost_assign_v2__ represents a complete overhaul and is completely independent
+from the previous version. In terms of the directory structure, the new features are in __local_boost_dir__,
+and accordingly, a new namespace was created:
+
+``
+ using namespace boost::assign::v2;
+``
+
+* The latest version prior to __boost_assign_v2__ will continue to be supported in __boost__
+for backward compatibility purposes, and also because Boost.Assign v2 still needs to be developed
+in some areas such as pointers.
+
+* The change to __boost_assign_v2__ comes about with the proposal for the addition of two new features,
+namely chaining ranges and (more advanced) anonymous containers of references. However, it came to
+light during the [@http://lists.boost.org/Archives/boost/2010/06/168028.php mini-review],
+that the new and existing features seemed redundant or lacked homogeneity in their interface
+and therefore called for a little more than a tune up.
+
+[endsect][/Change log]
+[section Support]
+For questions or feature request, post to the __user_mailing_list__, but also make sure to reach
+__TO__ and __ER__ by CCing them.
+[endsect]
+[section History and acknowledgement]
+
+The idea for an assignment/initialization library is not new. The functionality of this library
+resembles Leor Zolman's STL Container Initialization Library a great deal, but it does not rely on
+string parsing to achieve its goals.
+
+Special thanks go to
+
+* Leor Zolman for our many discussion that eventually led to this library.
+* Tom Brinkman for being review manager.
+* JoaquÃn MuÃ±oz for vc6/vc7 portability.
+* Pavel Vozenilek for his countless suggestions, improvements and portability fixes.
+* Rene Rivera for Code Warrior portability.
+* Manuel Peinado Gallego for identifying the need for anonymous container of references,
+ his valuable advice throughout their development, and proposing a [@http://gist.github.com/287791 design]
+ that laid the foundation for chaining. Both features were introduced with Boost.Assign v2.
+
+[endsect] [/Ackowledgement]
+[section Bibliography]
+
+* Scott. Meyers, "More Effective C++", Item 7, Addison Wesley, 1996
+* K. Czarnecki and U.W. Eisenecker, "Generative programming", Addison-Wesley, 2000
+* [@http://www.oonumerics.org/blitz/ http://www.oonumerics.org/blitz/]
+* Gabriel Dos Reis and Bjarne Stroustrup,
+ [@http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1509.pdf Generalized Initializer Lists], 2003
+* Abrahams, David and Gurtovoy, Aleksey,
+ [@http://portal.acm.org/citation.cfm?id=1044941#
+ C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond (C++ in Depth Series)],
+ 2004, Addison-Wesley Professional.
+
+[endsect]
+[endsect] [/ dummy encloser]
+

Added: sandbox/statistics/support/libs/assign/v2/doc/html/index.html
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/doc/html/index.html 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,3095 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Chapter 1. Boost.Assign 2.0</title>
+<link rel="stylesheet" href="/usr/local/trunk/libs/non_parametric/doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="index.html" title="Chapter 1. Boost.Assign 2.0">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+<div class="chapter" title="Chapter 1. Boost.Assign 2.0">
+<div class="titlepage"><div>
+<div><h2 class="title">
+<a name="boost_assign_v2"></a>Chapter 1. Boost.Assign 2.0</h2></div>
+<div><div class="author"><h3 class="author">
+Ottosen Thorsten
+</h3></div></div>
+<div><div class="author"><h3 class="author">
+Erwann Rogard
+</h3></div></div>
+<div>Copyright © 2003 -2004 Thorsten Ottosen, 2010 Erwann Rogard</div>
+<div><div class="legalnotice" title="Legal Notice">
+<a name="id36154309"></a>
+ 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)
+ 
+</div></div>
+</div></div>
+<div class="toc">
+Table of Contents
+<dl>
+<dt>_</dt>
+<dd><dl>
+<dt>Introduction</dt>
+<dt>Notation</dt>
+<dt>Tutorial</dt>
+<dd><dl>
+<dt><a href="index.html#boost_assign_v2._.tutorial.putting_elements_into_to_a_container">Putting
+ elements into to a container</a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.anonymous_container__of_values__">Anonymous
+ container (of values) </a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.anonymous_container_of_references">Anonymous
+ container of references</a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.chaining_ranges">Chaining
+ ranges</a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.running_the_code">Running
+ the code</a></dt>
+</dl></dd>
+<dt><a href="index.html#boost_assign_v2._.library_interface_and_design">Library
+ interface and design</a></dt>
+<dt>Reference</dt>
+<dd><dl>
+<dt><a href="index.html#boost_assign_v2._.reference.overload_resolution">Overload
+ resolution</a></dt>
+<dt>Keywords</dt>
+<dd><dl>
+<dt>_deduce</dt>
+<dt>_fun</dt>
+<dt>_nil</dt>
+<dt>_unwrap</dt>
+<dt>_incr_lookup</dt>
+<dt>_repeat</dt>
+<dt>_put_tag</dt>
+</dl></dd>
+<dt>anon</dt>
+<dt>chain</dt>
+<dt>convert</dt>
+<dt>put_range</dt>
+<dt>put_wrapper</dt>
+<dt>ref::anon</dt>
+</dl></dd>
+<dt>Portability </dt>
+<dt>Change log</dt>
+<dt>Support</dt>
+<dt><a href="index.html#boost_assign_v2._.history_and_acknowledgement">History
+ and acknowledgement</a></dt>
+<dt>Bibliography</dt>
+</dl></dd>
+</dl>
+</div>
+<div class="section" title="_">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_assign_v2._"></a><a class="link" href="index.html#boost_assign_v2._" title="_">_</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt>Introduction</dt>
+<dt>Notation</dt>
+<dt>Tutorial</dt>
+<dd><dl>
+<dt><a href="index.html#boost_assign_v2._.tutorial.putting_elements_into_to_a_container">Putting
+ elements into to a container</a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.anonymous_container__of_values__">Anonymous
+ container (of values) </a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.anonymous_container_of_references">Anonymous
+ container of references</a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.chaining_ranges">Chaining
+ ranges</a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.running_the_code">Running
+ the code</a></dt>
+</dl></dd>
+<dt><a href="index.html#boost_assign_v2._.library_interface_and_design">Library
+ interface and design</a></dt>
+<dt>Reference</dt>
+<dd><dl>
+<dt><a href="index.html#boost_assign_v2._.reference.overload_resolution">Overload
+ resolution</a></dt>
+<dt>Keywords</dt>
+<dd><dl>
+<dt>_deduce</dt>
+<dt>_fun</dt>
+<dt>_nil</dt>
+<dt>_unwrap</dt>
+<dt>_incr_lookup</dt>
+<dt>_repeat</dt>
+<dt>_put_tag</dt>
+</dl></dd>
+<dt>anon</dt>
+<dt>chain</dt>
+<dt>convert</dt>
+<dt>put_range</dt>
+<dt>put_wrapper</dt>
+<dt>ref::anon</dt>
+</dl></dd>
+<dt>Portability </dt>
+<dt>Change log</dt>
+<dt>Support</dt>
+<dt><a href="index.html#boost_assign_v2._.history_and_acknowledgement">History
+ and acknowledgement</a></dt>
+<dt>Bibliography</dt>
+</dl></div>
+
+ Question to QBK authors : Without this dummy enclosing section (_), layout
+ is messy. Why?
+ 
+<div class="section" title="Introduction">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_assign_v2._.introduction"></a><a class="link" href="index.html#boost_assign_v2._.introduction" title="Introduction">Introduction</a>
+</h3></div></div></div>
+
+ This library offers a uniform interface for initializing or assigning containers,
+ and working with collections of references. The relevant directory structure
+ is rooted <code class="literal">boost/assign/v2</code>. Each directory in this structure
+ contains an <code class="literal">.hpp</code> file by the same name which includes
+ all its relevant files. We assume, throughout this documentation, that
+ 
+<pre class="programlisting">#include <boost/assert.hpp>
+#include <boost/range.hpp>
+#include <boost/assign/v2/v2.hpp>
+using namespace boost::assign::v2;
+</pre>
+
+ precedes all C++ statements.
+ 
+</div>
+<div class="section" title="Notation">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_assign_v2._.notation"></a><a class="link" href="index.html#boost_assign_v2._.notation" title="Notation">Notation</a>
+</h3></div></div></div>
+
+ To represent an <code class="computeroutput">object</code> and its type, we use the convention that
+ is implicit below:
+ 
+<pre class="programlisting">object_ object;
+</pre>
+<div class="table">
+<a name="boost_assign_v2._.notation.symbols"></a>Table 1.1. Symbols
+<div class="table-contents"><table class="table" summary="Symbols">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Symbol
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">v</code>
+ 
+ </td>
+<td>
+ 
+ A container of unspecified type
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">t</code>
+ 
+ </td>
+<td>
+ 
+ Element in a container
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">f</code>
+ 
+ </td>
+<td>
+ 
+ A function
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">object</code>
+ 
+ </td>
+<td>
+ 
+ An object returned by a function
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">p</code>
+ 
+ </td>
+<td>
+ 
+ A parameter to an object
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">x</code>
+ 
+ </td>
+<td>
+ 
+ An argument to a function
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">a</code>
+ 
+ </td>
+<td>
+ 
+ Argument in the first call to a function
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">b</code>
+ 
+ </td>
+<td>
+ 
+ Argument in the second call to a function
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">c</code>
+ 
+ </td>
+<td>
+ 
+ Argument in the third call to a function
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+ <div class="table">
+<a name="boost_assign_v2._.notation.expressions"></a>Table 1.2. Expressions
+<div class="table-contents"><table class="table" summary="Expressions">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="literal"> i = 0, ..., n-1</code>
+ 
+ </td>
+<td>
+ 
+ Indexes a sequences of <code class="computeroutput">t</code>'s
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="literal"> j = 0, ..., k-1</code>
+ 
+ </td>
+<td>
+ 
+ Indexes arguments in a function call
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="literal"> k[i] </code>
+ 
+ </td>
+<td>
+ 
+ Number of arguments of the i th functional call
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="literal"> <code class="computeroutput">x</code>[i,j]</code>
+ 
+ </td>
+<td>
+ 
+ j th argument of the i th functional call
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="literal"> <code class="computeroutput">a</code>[j] </code>
+ 
+ </td>
+<td>
+ 
+ <code class="literal"> <code class="computeroutput">x</code>[0,j]</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="literal"> <code class="computeroutput">b</code>[j] </code>
+ 
+ </td>
+<td>
+ 
+ <code class="literal"> <code class="computeroutput">x</code>[1,j]</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="literal"> <code class="computeroutput">c</code>[j] </code>
+ 
+ </td>
+<td>
+ 
+ <code class="literal"> <code class="computeroutput">x</code>[2,j]</code>
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+ 
+ Note that if <code class="literal">k = 0</code>, in the context of a function call,
+ it means that <code class="computeroutput">f()</code>
+ is called. In the context of constructing <code class="computeroutput">t</code>, `t_()' is called.
+ 
+</div>
+<div class="section" title="Tutorial">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_assign_v2._.tutorial"></a><a class="link" href="index.html#boost_assign_v2._.tutorial" title="Tutorial">Tutorial</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost_assign_v2._.tutorial.putting_elements_into_to_a_container">Putting
+ elements into to a container</a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.anonymous_container__of_values__">Anonymous
+ container (of values) </a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.anonymous_container_of_references">Anonymous
+ container of references</a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.chaining_ranges">Chaining
+ ranges</a></dt>
+<dt><a href="index.html#boost_assign_v2._.tutorial.running_the_code">Running
+ the code</a></dt>
+</dl></div>
+<div class="section" title="Putting elements into to a container">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.tutorial.putting_elements_into_to_a_container"></a><a class="link" href="index.html#boost_assign_v2._.tutorial.putting_elements_into_to_a_container" title="Putting elements into to a container">Putting
+ elements into to a container</a>
+</h4></div></div></div>
+
+ All three expressions in each row have the same side effect:
+ 
+<div class="table">
+<a name="boost_assign_v2._.tutorial.putting_elements_into_to_a_container.elementwise"></a>Table 1.3. Elementwise
+<div class="table-contents"><table class="table" summary="Elementwise">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression1
+ 
+ </th>
+<th>
+ 
+ Expression2
+ 
+ </th>
+<th>
+ 
+ Expression3
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+
+
+<pre class="programlisting">queue.push(a);
+queue.push( t_() );
+queue.push( t( c[0], c[1] ) );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+
+
+<pre class="programlisting">put_wrapper( queue ).csv( a )( t_() )( t( c[0], c[1] ) )
+</pre>
+
+ 
+ </td>
+<td>
+ 
+
+
+<pre class="programlisting">put_wrapper( queue )( a )()( c[0], c[1] );
+</pre>
+
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre class="programlisting">map[ a ] +=2 ; ++map[ b ];
+</pre>
+
+ 
+ </td>
+<td>
+ 
+
+
+<pre class="programlisting">( put_wrapper( map ) % _incr_lookup).csv( a, b, a );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+
+
+<pre class="programlisting">( put_wrapper( map )( b ) % _incr_lookup % ( _repeat = 2 ) )( a );
+</pre>
+
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre class="programlisting">deque.push_back( tuple_( a[0], a[1] ) );
+deque.push_back( tuple_( b[0], a[1] ) );
+deque.push_back( tuple_( c[0], a[1]) );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+
+
+<pre class="programlisting">using namespace boost::lambda;
+( put_wrapper( deque ) % ( _fun = bind<tuple_>(
+ constructor<tuple_>(), _1, a[1] )
+) )( a[0] )( b[0] )( c[0] );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ unspecified
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+ <div class="important" title="Important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/html/images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top">
+ Elements are passed by reference. In the example involving a <code class="computeroutput">tuple</code>,
+ it may have, for example, an lvalue and a <code class="computeroutput">const</code>
+ reference as its elements.
+ </td></tr>
+</table></div>
+
+ To pass a <code class="computeroutput">Range</code>,
+ <code class="computeroutput">from</code>, to an arbitrary container,
+ <code class="computeroutput">to</code>,
+
+<pre class="programlisting">put_range( from, to );
+</pre>
+
+ To assign a <code class="computeroutput">Range</code>
+ to a container,
+
+<pre class="programlisting">to = convert<To>( from );
+</pre>
+
+ 
+</div>
+<div class="section" title="Anonymous container (of values)">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.tutorial.anonymous_container__of_values__"></a><a class="link" href="index.html#boost_assign_v2._.tutorial.anonymous_container__of_values__" title="Anonymous container (of values)">Anonymous
+ container (of values) </a>
+</h4></div></div></div>
+
+ An anonymous container is created by using the same interface as that of
+ <code class="computeroutput">put_wrapper</code> and has most of the functionality of <code class="computeroutput">deque_</code> plus
+ the conversion (to an arbitrary container) capability:
+
+<pre class="programlisting">to = anon( a )( b )( c );
+</pre>
+
+ To copy-construct <code class="computeroutput">to</code>,
+
+<pre class="programlisting">to = anon( a )( b )( c ).convert<To>();
+</pre>
+
+ To be able to use <code class="computeroutput">operator%</code>,
+
+<pre class="programlisting">to = ( anon<t_>( _nil ) % (_repeat = n ) )( a )( b )( c );
+</pre>
+
+ 
+</div>
+<div class="section" title="Anonymous container of references">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.tutorial.anonymous_container_of_references"></a><a class="link" href="index.html#boost_assign_v2._.tutorial.anonymous_container_of_references" title="Anonymous container of references">Anonymous
+ container of references</a>
+</h4></div></div></div>
+
+ An anonymous collection of references is created with a function with the
+ same name as its value counterpart (above), <code class="computeroutput">anon</code>, but in the
+ nested <code class="computeroutput">namespace</code> <code class="computeroutput">ref</code>,
+ and by specifying a <code>ref-assign-tag</code> template argument:
+ 
+<pre class="programlisting">using namespace ref;
+anon<<code>ref-assign-tag</code>>( a )( b )( c );
+</pre>
+
+ The resulting container holds references to the arguments. Clearly only
+ unary function calls are allowed. The template argument <code>ref-assign-tag</code> specifies how references
+ are assigned : using copy semantics or rebind semantics. Finally, there
+ is a csv form as well. Rather than specifying <code>ref-assign-tag</code>, it
+ is equivalent to use a dedicated <code class="computeroutput">namespace</code>,
+ in the example that follows, <code class="computeroutput">ref::assign_copy</code>:
+ 
+
+
+
+<pre class="programlisting">using namespace ref::assign_copy;
+boost::copy( v , boost::begin( anon( a )( b )( c ) ) );
+BOOST_ASSERT( a == v[0] );
+BOOST_ASSERT( c == v[2] );
+</pre>
+
+ 
+
+ This example illustrates both the csv form and rebind
+ semantics:
+
+<pre class="programlisting">#include <boost/typeof/typeof.hpp>
+using namespace ref::assign_rebind;
+BOOST_AUTO( tmp, csv_anon( a , b ) );
+tmp.assign( c );
+BOOST_ASSERT( &tmp[ 0 ] == &c );
+BOOST_ASSERT( &tmp[ 1 ] == &c );
+</pre>
+
+ 
+</div>
+<div class="section" title="Chaining ranges">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.tutorial.chaining_ranges"></a><a class="link" href="index.html#boost_assign_v2._.tutorial.chaining_ranges" title="Chaining ranges">Chaining
+ ranges</a>
+</h4></div></div></div>
+
+ To assign from chained ranges:
+
+<pre class="programlisting">to = (r1 && r2 && r3).convert<To>();
+</pre>
+
+ Chaining is elementwise-lvalue preserving:
+
+<pre class="programlisting">#include <boost/typeof/typeof.hpp>
+using namespace ref::assign_copy;
+BOOST_AUTO( tmp, anon( a )( b ) );
+copy( v , boost::begin( tmp && anon( c ) ) );
+BOOST_ASSERT( a == v[0] );
+BOOST_ASSERT( b == v[1] );
+BOOST_ASSERT( c == v[2] );
+</pre>
+
+ The fact that <code class="computeroutput">anon( c
+ )</code>, above, returns an rvalue should
+ underscore the significance of elementwise in our
+ previous statement.
+ 
+</div>
+<div class="section" title="Running the code">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.tutorial.running_the_code"></a><a class="link" href="index.html#boost_assign_v2._.tutorial.running_the_code" title="Running the code">Running
+ the code</a>
+</h4></div></div></div>
+
+ The file below contains similar material,
+ 
+
+
+
+<pre class="programlisting">#include <libs/assign/v2/example/tutorial.h>
+</pre>
+
+ 
+
+ and is be executed like this:
+ 
+
+
+
+<pre class="programlisting">#include <libs/assign/v2/example/tutorial.h>
+int main()
+{
+ using namespace example_assign_v2;
+ xxx_tutorial::run();
+ return 0;
+}
+</pre>
+
+ 
+</div>
+</div>
+<div class="section" title="Library interface and design">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_assign_v2._.library_interface_and_design"></a><a class="link" href="index.html#boost_assign_v2._.library_interface_and_design" title="Library interface and design">Library
+ interface and design</a>
+</h3></div></div></div>
+
+ This section discusses general features of the interface and concerns the
+ <code class="computeroutput">object</code> s returned by
+ 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem"><code class="computeroutput">anon()</code></li>
+<li class="listitem"><code class="computeroutput">put_wrapper()</code></li>
+<li class="listitem"><code class="computeroutput">ref::anon()</code></li>
+<li class="listitem"><code class="computeroutput">ref::csv_anon()</code></li>
+</ul></div>
+
+ Functions are the primary interface by which the user interacts with the
+ library. However, it is the object that they return that are responsible
+ for performing the desired task. The relationship between a function and
+ its resulting object can be formalized as follows, where both expressions
+ have the same side effect:
+ 
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression1
+ 
+ </th>
+<th>
+ 
+ Expression2
+ 
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">fun( a )( b )( c );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">result_of::fun_nil<T>::type object = fun<T>( _nil );
+object( a )( b )( c );
+</pre>
+
+ 
+ </td>
+</tr></tbody>
+</table></div>
+
+ In <code class="computeroutput">namespace</code> <code class="computeroutput">ref</code>
+ with <code class="computeroutput">anon</code> as <code class="computeroutput">fun</code>,
+ this is exactly the representation that is used. In other segments of the
+ library, however, although the interface may not match exactly that above,
+ a similar idea is at work.
+ 
+
+ To avoid passing to functions many, in fact any, parameters that would confuse
+ the user and cause the developer a headache, the library usually deduces
+ the parameters from its input using traits. Considering, for example, the
+ <code class="computeroutput">put_wrapper</code> functionality, the library, by default,
+ 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ Calls a functor, <code class="computeroutput">constructor<t>()</code>, which is overloaded on the number
+ and lvalue/<code class="computeroutput">const</code>-ness of its
+ arguments, and returns the type of the elements in the destination container.
+ </li>
+<li class="listitem">
+ Another traits decides which modifier (such as <code class="computeroutput">push_back()</code>) to use given certain properties of the
+ container. For example, if the container has <code class="computeroutput">push()</code> it takes precedence over <code class="computeroutput">push_back()</code>.
+ </li>
+</ul></div>
+
+ For example, the side effect of
+
+<pre class="programlisting">put_wrapper( map )( key1, a )( key2, b )( key3, c )
+</pre>
+
+ is identical to that of
+
+<pre class="programlisting">map.insert( make_pair( key1, a ) );
+map.insert( make_pair( key2, b ) );
+map.insert( make_pair( key3, c ) );
+</pre>
+
+ 
+
+ The deduced parameters that we have just discussed can be selectively overriden
+ with <code class="computeroutput">operator%</code>
+ taking as its first argument the result of the function, and a keyword.
+ A keyword is a <code class="computeroutput">const</code> object
+ defined in an anonymous namespace whose identifier has prefix <code class="computeroutput">_</code>. Here's the generic form
+
+<pre class="programlisting">object % _keyword;
+</pre>
+
+ or
+
+<pre class="programlisting">object % (_keyword = p);
+</pre>
+
+ Operators are usually composable e.g.
+
+<pre class="programlisting">object % _keyword1 % (_keyword2 = p);
+</pre>
+
+ In each case, the operation may return a reference to the same <code class="computeroutput">object</code>,
+ but with a different state, or a new object of a different type altogether,
+ thereby modifying the semantics of subequent calls to the object. For example,
+
+
+<pre class="programlisting">(put_wrapper( map ) % _incr_lookup)( a )( b )( c )
+</pre>
+
+ 
+
+ is equivalent to
+ 
+
+
+
+<pre class="programlisting">++ map [ a ];
+++ map [ b ];
+++ map [ c ];
+</pre>
+
+ 
+</div>
+<div class="section" title="Reference">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_assign_v2._.reference"></a><a class="link" href="index.html#boost_assign_v2._.reference" title="Reference">Reference</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost_assign_v2._.reference.overload_resolution">Overload
+ resolution</a></dt>
+<dt>Keywords</dt>
+<dd><dl>
+<dt>_deduce</dt>
+<dt>_fun</dt>
+<dt>_nil</dt>
+<dt>_unwrap</dt>
+<dt>_incr_lookup</dt>
+<dt>_repeat</dt>
+<dt>_put_tag</dt>
+</dl></dd>
+<dt>anon</dt>
+<dt>chain</dt>
+<dt>convert</dt>
+<dt>put_range</dt>
+<dt>put_wrapper</dt>
+<dt>ref::anon</dt>
+</dl></div>
+<div class="section" title="Overload resolution">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.reference.overload_resolution"></a><a class="link" href="index.html#boost_assign_v2._.reference.overload_resolution" title="Overload resolution">Overload
+ resolution</a>
+</h4></div></div></div>
+
+ This section concerns the <code class="computeroutput">object</code> s returned by
+ 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem"><code class="computeroutput">anon()</code></li>
+<li class="listitem"><code class="computeroutput">put_wrapper()</code></li>
+<li class="listitem"><code class="computeroutput">ref::anon()</code></li>
+<li class="listitem"><code class="computeroutput">ref::csv_anon()</code></li>
+</ul></div>
+<a name="boost_assign_v2._.reference.overload_resolution.headers"></a><h6>
+<a name="id36158235"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.overload_resolution.headers">Headers</a>
+ </h6>
+<pre class="programlisting">#include <boost/assign/v2/detail/config/arity_bound.hpp>
+#include <boost/assign/v2/detail/functor/crtp_unary_and_up.hpp>
+</pre>
+<a name="boost_assign_v2._.reference.overload_resolution._emphasis_functor__emphasis__and__emphasis_csv__emphasis__forms"></a><h6>
+<a name="id36158395"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.overload_resolution._emphasis_functor__emphasis__and__emphasis_csv__emphasis__forms">functor
+ and csv forms</a>
+ </h6>
+<div class="table">
+<a name="boost_assign_v2._.reference.overload_resolution.the_functor_and_csv_forms"></a>Table 1.4. The functor and csv forms
+<div class="table-contents"><table class="table" summary="The functor and csv forms">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Syntax
+ 
+ </th>
+<th>
+ 
+ Designation
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+
+
+<pre class="programlisting">f( x[0,0], ..., x[0,k(0)-1] ) ... ( x[n-1,0], ..., x[n-1,k(n-1)-1] )
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ functor
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre class="programlisting">f( x[0], ..., x[n-1] )
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ csv
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+ <div class="note" title="Note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ The arguments are passed as references.
+ </td></tr>
+</table></div>
+<div class="important" title="Important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/html/images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top">
+ The rules for <code class="computeroutput">ref::anon()</code> are those of the csv.
+ </td></tr>
+</table></div>
+<a name="boost_assign_v2._.reference.overload_resolution.arity"></a><h6>
+<a name="id36158748"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.overload_resolution.arity">Arity</a>
+ </h6>
+
+ Let <code class="literal">m</code> designates the constant under consideration in
+ each row below:
+ 
+<div class="table">
+<a name="boost_assign_v2._.reference.overload_resolution.preprocessor_constants"></a>Table 1.5. Preprocessor constants
+<div class="table-contents"><table class="table" summary="Preprocessor constants">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ Relevant form
+ 
+ </th>
+<th>
+ 
+ User definable
+ 
+ </th>
+<th>
+ 
+ Implication
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ BOOST_ASSIGN_V2_ARITY_BOUND
+ 
+ </td>
+<td>
+ 
+ functor
+ 
+ </td>
+<td>
+ 
+ Yes
+ 
+ </td>
+<td>
+ 
+ <code class="literal">k < m</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ BOOST_ASSIGN_V2_LVALUE_CONST_ARITY_BOUND
+ 
+ </td>
+<td>
+ 
+ functor
+ 
+ </td>
+<td>
+ 
+ No
+ 
+ </td>
+<td>
+ 
+ See below
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ BOOST_ASSIGN_V2_CSV_ARITY_BOUND
+ 
+ </td>
+<td>
+ 
+ csv
+ 
+ </td>
+<td>
+ 
+ Yes
+ 
+ </td>
+<td>
+ 
+ <code class="literal">n < m</code>
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+ 
+ Necessary and sufficient conditions for preserving lvalue-ness, for a given
+ <code class="literal">j</code>, are
+ 
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Function
+ 
+ </th>
+<th>
+ 
+ Condition
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="literal">i</code>th call to functor
+ 
+ </td>
+<td>
+ 
+ <code class="literal">k(i) < m</code> or all of <code class="computeroutput">x[i,0]</code>,...,<code class="computeroutput">x[i,k(i)-1]</code> are lvalue s
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ csv
+ 
+ </td>
+<td>
+ 
+ All of <code class="computeroutput">x[0]</code>,...,<code class="computeroutput">x[n-1]</code> are lvalue s
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+
+ where <code class="literal">m</code> is as previously defined, looking at the second
+ row of the preceding table. If the condition, in each row, is violated,
+ the overload whose arguments are all <code class="computeroutput">const</code>
+ references is that which is resolved to.
+ 
+</div>
+<div class="section" title="Keywords">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.reference.keywords"></a><a class="link" href="index.html#boost_assign_v2._.reference.keywords" title="Keywords">Keywords</a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt>_deduce</dt>
+<dt>_fun</dt>
+<dt>_nil</dt>
+<dt>_unwrap</dt>
+<dt>_incr_lookup</dt>
+<dt>_repeat</dt>
+<dt>_put_tag</dt>
+</dl></div>
+<div class="section" title="_deduce">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_assign_v2._.reference.keywords.__deduce__"></a><a class="link" href="index.html#boost_assign_v2._.reference.keywords.__deduce__" title="_deduce">_deduce</a>
+</h5></div></div></div>
+<a name="boost_assign_v2._.reference.keywords.__deduce__.expression_semantics"></a><h6>
+<a name="id36159164"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__deduce__.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+
+
+
+<pre class="programlisting">object % deduce;
+</pre>
+
+ Return type <code>implementation-defined</code>
+ 
+
+ Semantics unspecified
+ 
+<a name="boost_assign_v2._.reference.keywords.__deduce__.header"></a><h6>
+<a name="id36159223"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__deduce__.header">Header</a>
+ </h6>
+
+
+
+<pre class="programlisting">#include <boost/assign/v2/detail/keywords/keywords.hpp>
+</pre>
+
+ 
+</div>
+<div class="section" title="_fun">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_assign_v2._.reference.keywords.__fun__"></a><a class="link" href="index.html#boost_assign_v2._.reference.keywords.__fun__" title="_fun">_fun</a>
+</h5></div></div></div>
+<a name="boost_assign_v2._.reference.keywords.__fun__.expression_semantics"></a><h6>
+<a name="id36159261"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__fun__.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+
+
+
+<pre class="programlisting">object % ( _fun = f);
+</pre>
+
+ 
+
+ Return type <code>implementation-defined</code>
+ 
+
+ Semantics unspecified
+ 
+<a name="boost_assign_v2._.reference.keywords.__fun__.header"></a><h6>
+<a name="id36159337"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__fun__.header">Header</a>
+ </h6>
+
+
+
+<pre class="programlisting">#include <boost/assign/v2/detail/keywords/keywords.hpp>
+</pre>
+
+ 
+</div>
+<div class="section" title="_nil">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_assign_v2._.reference.keywords.__nil__"></a><a class="link" href="index.html#boost_assign_v2._.reference.keywords.__nil__" title="_nil">_nil</a>
+</h5></div></div></div>
+<a name="boost_assign_v2._.reference.keywords.__nil__.expression_semantics"></a><h6>
+<a name="id36159375"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__nil__.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+
+
+
+<pre class="programlisting">f( _nil );
+</pre>
+
+ 
+
+ Return type <code>implementation-defined</code>
+ 
+
+ Semantics unspecified
+ 
+<a name="boost_assign_v2._.reference.keywords.__nil__.header"></a><h6>
+<a name="id36159440"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__nil__.header">Header</a>
+ </h6>
+
+
+
+<pre class="programlisting">#include <boost/assign/v2/detail/keywords/keywords.hpp>
+</pre>
+
+ 
+</div>
+<div class="section" title="_unwrap">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_assign_v2._.reference.keywords.__unwrap__"></a><a class="link" href="index.html#boost_assign_v2._.reference.keywords.__unwrap__" title="_unwrap">_unwrap</a>
+</h5></div></div></div>
+<a name="boost_assign_v2._.reference.keywords.__unwrap__.expression_semantics"></a><h6>
+<a name="id36159478"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__unwrap__.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+
+
+
+<pre class="programlisting">unspecified
+</pre>
+
+ 
+
+ Return type <code>implementation-defined</code>
+ 
+
+ Semantics unspecified
+ 
+<a name="boost_assign_v2._.reference.keywords.__unwrap__.header"></a><h6>
+<a name="id36159528"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__unwrap__.header">Header</a>
+ </h6>
+
+
+
+<pre class="programlisting">#include <boost/assign/v2/detail/keywords/keywords.hpp>
+</pre>
+
+ 
+</div>
+<div class="section" title="_incr_lookup">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_assign_v2._.reference.keywords.__incr_lookup__"></a><a class="link" href="index.html#boost_assign_v2._.reference.keywords.__incr_lookup__" title="_incr_lookup">_incr_lookup</a>
+</h5></div></div></div>
+<a name="boost_assign_v2._.reference.keywords.__incr_lookup__.expression_semantics"></a><h6>
+<a name="id36159568"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__incr_lookup__.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+
+
+
+<pre class="programlisting">unspecified
+</pre>
+
+ Return type <code>implementation-defined</code>
+ 
+
+ Semantics unspecified
+ 
+<a name="boost_assign_v2._.reference.keywords.__incr_lookup__.header"></a><h6>
+<a name="id36159614"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__incr_lookup__.header">Header</a>
+ </h6>
+
+
+
+<pre class="programlisting">#include <boost/assign/v2/detail/keywords/keywords.hpp>
+</pre>
+
+ 
+</div>
+<div class="section" title="_repeat">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_assign_v2._.reference.keywords.__repeat__"></a><a class="link" href="index.html#boost_assign_v2._.reference.keywords.__repeat__" title="_repeat">_repeat</a>
+</h5></div></div></div>
+<a name="boost_assign_v2._.reference.keywords.__repeat__.expression_semantics"></a><h6>
+<a name="id36159652"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__repeat__.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+
+
+
+<pre class="programlisting">object % (_repeat = n);
+</pre>
+
+ 
+
+ Return type <code>implementation-defined</code>
+ 
+
+ Semantics unspecified
+ 
+<a name="boost_assign_v2._.reference.keywords.__repeat__.header"></a><h6>
+<a name="id36159723"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__repeat__.header">Header</a>
+ </h6>
+
+
+
+<pre class="programlisting">#include <boost/assign/v2/detail/keywords/keywords.hpp>
+</pre>
+
+ 
+</div>
+<div class="section" title="_put_tag">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_assign_v2._.reference.keywords.__put_kwd__"></a><a class="link" href="index.html#boost_assign_v2._.reference.keywords.__put_kwd__" title="_put_tag">_put_tag</a>
+</h5></div></div></div>
+<a name="boost_assign_v2._.reference.keywords.__put_kwd__.expression_semantics"></a><h6>
+<a name="id36159763"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__put_kwd__.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+
+
+
+<pre class="programlisting">object % (_put_tag = <code>put-tag</code>());
+</pre>
+
+ 
+
+ Return type <code>implementation-defined</code>
+ 
+
+ Semantics Selects a container modifier.
+ 
+<div class="table">
+<a name="boost_assign_v2._.reference.keywords.__put_kwd__.candidate_tags_"></a>Table 1.6. Candidate tags.
+<div class="table-contents"><table class="table" summary="Candidate tags.">
+<colgroup><col></colgroup>
+<thead><tr><th>
+ 
+ Name
+ 
+ </th></tr></thead>
+<tbody>
+<tr><td>
+ 
+ <code class="computeroutput">put_tag::at_next</code>
+ 
+ </td></tr>
+<tr><td>
+ 
+ <code class="computeroutput">put_tag::insert</code>
+ 
+ </td></tr>
+<tr><td>
+ 
+ <code class="computeroutput">put_tag::push</code>
+ 
+ </td></tr>
+<tr><td>
+ 
+ <code class="computeroutput">put_tag::push_back</code>
+ 
+ </td></tr>
+</tbody>
+</table></div>
+</div>
+ <a name="boost_assign_v2._.reference.keywords.__put_kwd__.header"></a><h6>
+<a name="id36159953"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.keywords.__put_kwd__.header">Header</a>
+ </h6>
+
+
+
+<pre class="programlisting">#include <boost/assign/v2/put/put.hpp>
+</pre>
+
+ [header Example]
+
+<pre class="programlisting">object % (_put_tag = put_tag::push());
+</pre>
+
+ 
+</div>
+</div>
+<div class="section" title="anon">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.reference.___anon___"></a><a class="link" href="index.html#boost_assign_v2._.reference.___anon___" title="anon"><code class="computeroutput">anon</code></a>
+</h4></div></div></div>
+<a name="boost_assign_v2._.reference.___anon___.description"></a><h6>
+<a name="id36160027"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___anon___.description">Description</a>
+ </h6>
+
+ Creates an anonymous container
+ 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ With the same interface as <code class="computeroutput">put_wrapper</code>
+</li>
+<li class="listitem">
+ and converts to an arbitrary container
+ </li>
+</ul></div>
+<a name="boost_assign_v2._.reference.___anon___.synopsis"></a><h6>
+<a name="id36160061"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___anon___.synopsis">Synopsis</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<thead><tr>
+<th>
+ 
+ Syntax
+ 
+ </th>
+<th>
+ 
+ Designation
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">template<typename T>
+typename result_of::anon<T>::type
+anon( keyword_aux::nil const& );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ (1)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">template<typename T>
+typename result_of::anon<T>::type
+anon( T& );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ (2)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">template<typename T>
+typename result_of::anon<T const>::type
+anon( T const& );
+</pre>
+
+ 
+ </td>
+<td class="auto-generated"> </td>
+</tr>
+</tbody>
+</table></div>
+<a name="boost_assign_v2._.reference.___anon___.parameters"></a><h6>
+<a name="id36160410"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___anon___.parameters">Parameters</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Requirement
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ 
+ T
+ 
+ </td>
+<td>
+ 
+ unspecified
+ 
+ </td>
+<td>
+ 
+ Value of argument to <code class="computeroutput">anon</code>
+ 
+ </td>
+</tr></tbody>
+</table></div>
+<a name="boost_assign_v2._.reference.___anon___.expression_semantics"></a><h6>
+<a name="id36160498"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___anon___.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Designation
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">anon<T>( _nil );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ (1) 
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">anon( t );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ (2) and (3)
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+
+ Return type: <code class="computeroutput">result_of::anon<T>::type</code>
+ for each (1), (2) and (3)
+ 
+
+ Semantics: Creates an anonymous container.
+ 
+<a name="boost_assign_v2._.reference.___anon___.header"></a><h6>
+<a name="id36160684"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___anon___.header">Header</a>
+ </h6>
+<pre class="programlisting">#include <boost/assign/v2/anon/anon.hpp>
+</pre>
+<a name="boost_assign_v2._.reference.___anon___.example"></a><h6>
+<a name="id36160704"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___anon___.example">Example</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Designation
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">anon<int>( _nil );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ (1) 
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">int a; anon( a );
+ </pre>
+
+ 
+ </td>
+<td>
+ 
+ (2)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">anon( 1 );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ (2)
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section" title="chain">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.reference.__chain__"></a><a class="link" href="index.html#boost_assign_v2._.reference.__chain__" title="chain">chain</a>
+</h4></div></div></div>
+
+ Forms a range by chaining two ranges in a way that
+ 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ preserves lvalue-ness elementwise. If, for example,
+ the two ranges are <code class="computeroutput">const</code>
+ but their elements are lvalue--reference wrappers, then the dereference
+ value of the underlying iterator is also lvalue.
+ </li>
+<li class="listitem">
+ is convertible to an arbitrary container.
+ </li>
+</ul></div>
+<a name="boost_assign_v2._.reference.__chain__._code__phrase_role__keyword__namespace__phrase___code_"></a><h6>
+<a name="id36160918"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.__chain__._code__phrase_role__keyword__namespace__phrase___code_"><code class="computeroutput">namespace</code></a>
+ </h6>
+
+
+
+<pre class="programlisting">using namespace adaptor;
+</pre>
+
+ 
+<a name="boost_assign_v2._.reference.__chain__.synopsis"></a><h6>
+<a name="id36160965"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.__chain__.synopsis">Synopsis</a>
+ </h6>
+
+
+
+<pre class="programlisting">template<typename R1,typename U2>
+typename result_of::chain<R1,R2>::type
+operator|(U1& r1,chain_aux::adaptor1<U2,boost::use_default>);
+</pre>
+
+ 
+<div class="note" title="Note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ <code class="computeroutput">U1</code> = <code class="computeroutput">R1</code>
+ or <code class="computeroutput">R1 const</code>
+ and likewise for <code class="computeroutput">U2</code>.
+ </td></tr>
+</table></div>
+<a name="boost_assign_v2._.reference.__chain__.parameters"></a><h6>
+<a name="id36161168"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.__chain__.parameters">Parameters</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Requirement
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ R1
+ 
+ </td>
+<td>
+ 
+ models Range
+ 
+ </td>
+<td>
+ 
+ Range to be chained
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ R2
+ 
+ </td>
+<td>
+ 
+ models Range
+ 
+ </td>
+<td>
+ 
+ Range to chain to
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+<a name="boost_assign_v2._.reference.__chain__.expression_semantics"></a><h6>
+<a name="id36161282"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.__chain__.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+
+
+
+<pre class="programlisting">r1 | _chain( r2 );
+</pre>
+
+ 
+
+ Return type: <code class="computeroutput">result_of::chain<U1,U2>::type</code>
+ 
+
+ Semantics: Chains two ranges to form one.
+ 
+<a name="boost_assign_v2._.reference.__chain__.header"></a><h6>
+<a name="id36161385"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.__chain__.header">Header</a>
+ </h6>
+
+
+
+<pre class="programlisting">#include <boost/assign/v2/chain/chain.hpp>
+</pre>
+
+ 
+<a name="boost_assign_v2._.reference.__chain__.example"></a><h6>
+<a name="id36161408"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.__chain__.example">Example</a>
+ </h6>
+
+
+
+<pre class="programlisting">using namespace adaptor;
+std::vector<int> v( 2, -1);
+boost::array<int,2> array; array.assign( 1 );
+v | chain( array );
+</pre>
+
+ [heading <code class="computeroutput">operator&&</code>]
+ 
+
+ These are two equivalent ways to chain:
+ 
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression 1
+ 
+ </th>
+<th>
+ 
+ Expression 2
+ 
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">r1 | _chain( r2 );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">r1 && r2;
+</pre>
+
+ 
+ </td>
+</tr></tbody>
+</table></div>
+</div>
+<div class="section" title="convert">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.reference.___convert___"></a><a class="link" href="index.html#boost_assign_v2._.reference.___convert___" title="convert"><code class="computeroutput">convert</code></a>
+</h4></div></div></div>
+<a name="boost_assign_v2._.reference.___convert___.description"></a><h6>
+<a name="id36161729"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___convert___.description">Description</a>
+ </h6>
+
+ Assigns a Range
+ to an arbitrary container.
+ 
+<a name="boost_assign_v2._.reference.___convert___.synopsis"></a><h6>
+<a name="id36161754"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___convert___.synopsis">Synopsis</a>
+ </h6>
+<pre class="programlisting">template<typename To, typename From>
+To convert( From const& from);
+</pre>
+<a name="boost_assign_v2._.reference.___convert___.parameters"></a><h6>
+<a name="id36161844"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___convert___.parameters">Parameters</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Requirement
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ From
+ 
+ </td>
+<td>
+ 
+ models Range
+ 
+ </td>
+<td>
+ 
+ The argument to <code class="computeroutput">convert</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ To
+ 
+ </td>
+<td>
+ 
+ unspecified
+ 
+ </td>
+<td>
+ 
+ The return type of <code class="computeroutput">convert</code>
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+<a name="boost_assign_v2._.reference.___convert___.expression_semantics"></a><h6>
+<a name="id36161964"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___convert___.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+
+
+
+<pre class="programlisting">convert<To>( from );
+</pre>
+
+ 
+
+ Return type: To
+ 
+
+ Semantics: Assigns <code class="computeroutput">to</code>
+ with the elements of <code class="computeroutput">from</code>
+ 
+<a name="boost_assign_v2._.reference.___convert___.header"></a><h6>
+<a name="id36162048"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___convert___.header">Header</a>
+ </h6>
+<pre class="programlisting">#include <boost/assign/v2/put/range.hpp>
+</pre>
+<a name="boost_assign_v2._.reference.___convert___.example"></a><h6>
+<a name="id36162070"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___convert___.example">Example</a>
+ </h6>
+
+
+
+<pre class="programlisting">std::vector<int> from; from.push_back( -1 ); from.push_back( 0 );
+typedef std::queue<int> to_;
+to_ to = from.convert<to_>();
+</pre>
+
+ 
+</div>
+<div class="section" title="put_range">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.reference.___put_range___"></a><a class="link" href="index.html#boost_assign_v2._.reference.___put_range___" title="put_range"><code class="computeroutput">put_range</code></a>
+</h4></div></div></div>
+<a name="boost_assign_v2._.reference.___put_range___.description"></a><h6>
+<a name="id36162280"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_range___.description">Description</a>
+ </h6>
+
+ Puts the elements of a Range
+ into an arbitrary container.
+ 
+<a name="boost_assign_v2._.reference.___put_range___.synopsis"></a><h6>
+<a name="id36162305"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_range___.synopsis">Synopsis</a>
+ </h6>
+
+
+
+<pre class="programlisting">template<typename From,typename To>
+To& put_range( From const&, To& to );
+</pre>
+
+ 
+<a name="boost_assign_v2._.reference.___put_range___.parameters"></a><h6>
+<a name="id36162415"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_range___.parameters">Parameters</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Requirement
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ From
+ 
+ </td>
+<td>
+ 
+ models Range
+ 
+ </td>
+<td>
+ 
+ The first argument to <code class="computeroutput">put_range</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ To
+ 
+ </td>
+<td>
+ 
+ unspecified
+ 
+ </td>
+<td>
+ 
+ The second argument to <code class="computeroutput">put_range</code>
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+<a name="boost_assign_v2._.reference.___put_range___.expression_semantics"></a><h6>
+<a name="id36162536"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_range___.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+
+
+
+<pre class="programlisting">put_range( from, to );
+</pre>
+
+ 
+
+ Return type: To&
+ 
+
+ Semantics: Puts the elements in <code class="computeroutput">from</code> into <code class="computeroutput">to</code>.
+ 
+<a name="boost_assign_v2._.reference.___put_range___.header"></a><h6>
+<a name="id36162621"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_range___.header">Header</a>
+ </h6>
+<pre class="programlisting">#include <boost/assign/v2/put/range.hpp>
+</pre>
+<a name="boost_assign_v2._.reference.___put_range___.example"></a><h6>
+<a name="id36162643"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_range___.example">Example</a>
+ </h6>
+<pre class="programlisting">std::vector<int> from; from.push_back( -1 ); from.push_back( 0 );
+std::queue<int> to;
+put_range( from, to );
+</pre>
+</div>
+<div class="section" title="put_wrapper">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.reference.___put_wrapper___"></a><a class="link" href="index.html#boost_assign_v2._.reference.___put_wrapper___" title="put_wrapper"><code class="computeroutput">put_wrapper</code></a>
+</h4></div></div></div>
+<a name="boost_assign_v2._.reference.___put_wrapper___.description"></a><h6>
+<a name="id36162832"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_wrapper___.description">Description</a>
+ </h6>
+
+ Wraps around a container to be able to put elements into it, with a functor
+ or csv interface.
+ 
+<a name="boost_assign_v2._.reference.___put_wrapper___.synopsis"></a><h6>
+<a name="id36162859"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_wrapper___.synopsis">Synopsis</a>
+ </h6>
+<pre class="programlisting">template<typename V>
+typename result_of::put_wrapper<V>::type
+put_wrapper( V& v);
+</pre>
+<a name="boost_assign_v2._.reference.___put_wrapper___.parameters"></a><h6>
+<a name="id36162952"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_wrapper___.parameters">Parameters</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Requirement
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ 
+ V
+ 
+ </td>
+<td>
+ 
+ unspecified
+ 
+ </td>
+<td>
+ 
+ The argument to <code class="computeroutput">put_wrapper</code>
+ 
+ </td>
+</tr></tbody>
+</table></div>
+<a name="boost_assign_v2._.reference.___put_wrapper___.expression_semantics"></a><h6>
+<a name="id36163040"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_wrapper___.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+<pre class="programlisting">put_wrapper( v );
+</pre>
+
+ Return type: <code class="computeroutput">result_of::put_wrapper<V>::type</code>
+ 
+
+ Semantics: Creates an <code class="computeroutput">object</code>
+ with a functor or csv interface.
+ 
+<a name="boost_assign_v2._.reference.___put_wrapper___.header"></a><h6>
+<a name="id36163136"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_wrapper___.header">Header</a>
+ </h6>
+<pre class="programlisting">#include <boost/assign/v2/put/put.hpp>
+</pre>
+<a name="boost_assign_v2._.reference.___put_wrapper___.example"></a><h6>
+<a name="id36163159"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference.___put_wrapper___.example">Example</a>
+ </h6>
+<pre class="programlisting">std::vector<int> v;
+put_wrapper( v );
+</pre>
+</div>
+<div class="section" title="ref::anon">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_assign_v2._.reference._ref____anon___"></a><a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___" title="ref::anon"><code class="computeroutput">ref::anon</code></a>
+</h4></div></div></div>
+<a name="boost_assign_v2._.reference._ref____anon___.namespace"></a><h6>
+<a name="id36163245"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___.namespace">Namespace</a>
+ </h6>
+
+
+
+<pre class="programlisting">#include <boost/assign/v2/ref/ref.hpp>
+using namespace ref;
+</pre>
+
+ 
+<a name="boost_assign_v2._.reference._ref____anon___.background_on_assign_semantics"></a><h6>
+<a name="id36163291"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___.background_on_assign_semantics">Background
+ on assign semantics</a>
+ </h6>
+
+ Let a reference wrapper, <code class="computeroutput">w</code>, bind to some reference <code class="computeroutput">y1</code> and that it is assigned as follows:
+
+
+<pre class="programlisting">w = y2;
+</pre>
+
+ where <code class="computeroutput">y2</code> is of the same
+ type as <code class="computeroutput">y1</code>. There are two
+ possible semantics which are captured by the concepts below:
+ 
+<div class="table">
+<a name="boost_assign_v2._.reference._ref____anon___.concepts"></a>Table 1.7. Concepts
+<div class="table-contents"><table class="table" summary="Concepts">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ Requirement
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ AssignCopy
+ 
+ </td>
+<td>
+ 
+ y2 == y1;
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ AssignRebind
+ 
+ </td>
+<td>
+ 
+ &y2 == &y1;
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+ <a name="boost_assign_v2._.reference._ref____anon___.description"></a><h6>
+<a name="id36163439"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___.description">Description</a>
+ </h6>
+
+ Creates a collection of references.
+ 
+<a name="boost_assign_v2._.reference._ref____anon___.synopsis"></a><h6>
+<a name="id36163459"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___.synopsis">Synopsis</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Syntax
+ 
+ </th>
+<th>
+ 
+ Designation
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">template<typename Tag1, typename T>
+ typename result_of::anon_nil<Tag1, T>::type
+anon( keyword_aux::nil );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ (1)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"> template<typename Tag1,typename T>
+typename result_of::anon<Tag1, T>::type
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ (2)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"> template<typename Tag1,typename T>
+typename result_of::anon<Tag1, T const>::type
+ anon(T const & t);
+ </pre>
+
+ 
+ </td>
+<td>
+ 
+ (3)
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+<a name="boost_assign_v2._.reference._ref____anon___.parameters"></a><h6>
+<a name="id36163881"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___.parameters">Parameters</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Requirement
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ Tag1
+ 
+ </td>
+<td>
+ 
+ unspecified
+ 
+ </td>
+<td>
+ 
+ Controls assignement semantics
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ T
+ 
+ </td>
+<td>
+ 
+ unspecified
+ 
+ </td>
+<td>
+ 
+ Value of the element(s) to reference to
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+<a name="boost_assign_v2._.reference._ref____anon___.expression_semantics"></a><h6>
+<a name="id36163991"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___.expression_semantics">Expression
+ Semantics</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Designation
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">anon<<code>ref-assign-tag</code>>( _nil );</code>
+ 
+ </td>
+<td>
+ 
+ (1)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">anon<<code>ref-assign-tag</code>>( t );</code>
+ 
+ </td>
+<td>
+ 
+ (2) and (3)
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+
+ Return type:
+ 
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Designation
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">result_of::anon_nil<<code>ref-assign-tag</code>,T>::type</code>
+ 
+ </td>
+<td>
+ 
+ (1)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">result_of::anon<<code>ref-assign-tag</code>,T>::type</code>
+ 
+ </td>
+<td>
+ 
+ (2)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">result_of::anon<<code>ref-assign-tag</code>,T const>::type</code>
+ 
+ </td>
+<td>
+ 
+ (3)
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+
+ Semantics: Creates a collection of references.
+ 
+<a name="boost_assign_v2._.reference._ref____anon___.header"></a><h6>
+<a name="id36164338"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___.header">Header</a>
+ </h6>
+<pre class="programlisting">#include <boost/assign/v2/ref/ref.hpp>
+</pre>
+<a name="boost_assign_v2._.reference._ref____anon___.example"></a><h6>
+<a name="id36164361"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___.example">Example</a>
+ </h6>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Designation
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">anon<int
+ const>(
+ _nil )( 1
+ )( 2
+ )( 3
+ );</code>
+ 
+ </td>
+<td>
+ 
+ (1)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">int a, b, c;
+anon<int>( a )( b )( c );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+ (2)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">anon( 1
+ )( 2
+ )( 3
+ )</code>
+ 
+ </td>
+<td>
+ 
+ (3)
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+<a name="boost_assign_v2._.reference._ref____anon___.copy_semantics"></a><h6>
+<a name="id36164618"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___.copy_semantics">Copy
+ semantics</a>
+ </h6>
+
+ The two expresions below are equivalent
+ 
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression1
+ 
+ </th>
+<th>
+ 
+ Expression2
+ 
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">anon<assign_tag::copy>( t );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">using namespace assign_copy;
+anon( t );
+</pre>
+
+ 
+ </td>
+</tr></tbody>
+</table></div>
+<a name="boost_assign_v2._.reference._ref____anon___.rebind_semantics"></a><h6>
+<a name="id36164759"></a>
+ <a class="link" href="index.html#boost_assign_v2._.reference._ref____anon___.rebind_semantics">Rebind
+ semantics</a>
+ </h6>
+
+ The two expresions below are equivalent
+ 
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Expression1
+ 
+ </th>
+<th>
+ 
+ Expression2
+ 
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">anon<assign_tag::rebind>( t );
+</pre>
+
+ 
+ </td>
+<td>
+ 
+
+
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">using namespace assign_rebind;
+anon( t );
+</pre>
+
+ 
+ </td>
+</tr></tbody>
+</table></div>
+</div>
+</div>
+<div class="section" title="Portability">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_assign_v2._.portability_"></a><a class="link" href="index.html#boost_assign_v2._.portability_" title="Portability">Portability </a>
+</h3></div></div></div>
+<a name="boost_assign_v2._.portability_.methodology"></a><h5>
+<a name="id36164910"></a>
+ <a class="link" href="index.html#boost_assign_v2._.portability_.methodology">Methodology</a>
+ </h5>
+
+ For each of a set of containers (see below), ensure
+ 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ At compile time, that the method deduced for modifying the container agrees
+ with one that is explicitly specified. For example, it verifies that <code class="computeroutput">push()</code>
+ is the method used for <code class="computeroutput">std::queue</code>.
+ </li>
+<li class="listitem">
+ At runtime time, that the container returned by
+<pre class="programlisting">convert<To>( from );
+</pre>
+ has the same elements as that of <code class="computeroutput">from</code>,
+ where <code class="computeroutput">To</code> is the type of
+ the container being tested.
+ </li>
+</ul></div>
+<div class="table">
+<a name="boost_assign_v2._.portability_.containers_tested"></a>Table 1.8. Containers tested
+<div class="table-contents"><table class="table" summary="Containers tested">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Container
+ 
+ </th>
+<th>
+ 
+ Result
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">boost::array<></code>
+ 
+ </td>
+<td>
+ 
+ OK
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">std::deque<></code>
+ 
+ </td>
+<td>
+ 
+ OK
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">std::list<></code>
+ 
+ </td>
+<td>
+ 
+ OK
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">std::queue<></code>
+ 
+ </td>
+<td>
+ 
+ OK
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">std::set<></code>
+ 
+ </td>
+<td>
+ 
+ OK
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">std::set<></code>
+ 
+ </td>
+<td>
+ 
+ OK
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">std::stack<></code>
+ 
+ </td>
+<td>
+ 
+ OK
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">std::vector<></code>
+ 
+ </td>
+<td>
+ 
+ OK
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+ <div class="table">
+<a name="boost_assign_v2._.portability_.tests"></a>Table 1.9. Tests
+<div class="table-contents"><table class="table" summary="Tests">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ OS
+ 
+ </th>
+<th>
+ 
+ Compiler
+ 
+ </th>
+<th>
+ 
+ Date
+ 
+ </th>
+<th>
+ 
+ Result
+ 
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ 
+ Mac OS X v10.6
+ 
+ </td>
+<td>
+ 
+ GCC 4.2
+ 
+ </td>
+<td>
+ 
+ August 2nd, 2010
+ 
+ </td>
+<td>
+ 
+ Passed
+ 
+ </td>
+</tr></tbody>
+</table></div>
+</div>
+ <a name="boost_assign_v2._.portability_.dependencies"></a><h5>
+<a name="id36165423"></a>
+ <a class="link" href="index.html#boost_assign_v2._.portability_.dependencies">Dependencies</a>
+ </h5>
+
+ A previously avalaible set of files in the Vault, for chaining, by RangeEx,
+ are made temporarily available here
+ and need to be in the search path.
+ 
+</div>
+<div class="section" title="Change log">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_assign_v2._.change_log"></a><a class="link" href="index.html#boost_assign_v2._.change_log" title="Change log">Change log</a>
+</h3></div></div></div>
+<a name="boost_assign_v2._.change_log.upgrading_from_boost__v_emphasis_1_4x__emphasis_"></a><h5>
+<a name="id36165461"></a>
+ <a class="link" href="index.html#boost_assign_v2._.change_log.upgrading_from_boost__v_emphasis_1_4x__emphasis_">Upgrading
+ from Boost. v1.4x</a>
+ </h5>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+ This upgrade to Boost.Assign v2 represents a complete overhaul and is completely
+ independent from the previous version. In terms of the directory structure,
+ the new features are in boost/assign/v2, and accordingly, a new namespace
+ was created:
+ </li></ul></div>
+
+
+
+<pre class="programlisting">using namespace boost::assign::v2;
+</pre>
+
+ 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ The latest version prior to Boost.Assign v2 will continue to be supported
+ in Boost for backward compatibility
+ purposes, and also because Boost.Assign v2 still needs to be developed
+ in some areas such as pointers.
+ </li>
+<li class="listitem">
+ The change to Boost.Assign v2 comes about with the proposal for the addition
+ of two new features, namely chaining ranges and (more advanced) anonymous
+ containers of references. However, it came to light during the mini-review,
+ that the new and existing features seemed redundant or lacked homogeneity
+ in their interface and therefore called for a little more than a tune up.
+ </li>
+</ul></div>
+</div>
+<div class="section" title="Support">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_assign_v2._.support"></a><a class="link" href="index.html#boost_assign_v2._.support" title="Support">Support</a>
+</h3></div></div></div>
+
+ For questions or feature request, post to the <a href="http://www.boost.org/community/groups.html#users" target="_top">Boost
+ Users Mailing List</a>, but also make sure to reach TO
+ and <a href="mailto:er.ci.2020_at_[hidden]" target="_top">ER</a> by CCing them.
+ 
+</div>
+<div class="section" title="History and acknowledgement">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_assign_v2._.history_and_acknowledgement"></a><a class="link" href="index.html#boost_assign_v2._.history_and_acknowledgement" title="History and acknowledgement">History
+ and acknowledgement</a>
+</h3></div></div></div>
+
+ The idea for an assignment/initialization library is not new. The functionality
+ of this library resembles Leor Zolman's STL Container Initialization Library
+ a great deal, but it does not rely on string parsing to achieve its goals.
+ 
+
+ Special thanks go to
+ 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ Leor Zolman for our many discussion that eventually led to this library.
+ </li>
+<li class="listitem">
+ Tom Brinkman for being review manager.
+ </li>
+<li class="listitem">
+ Joaquín Muñoz for vc6/vc7 portability.
+ </li>
+<li class="listitem">
+ Pavel Vozenilek for his countless suggestions, improvements and portability
+ fixes.
+ </li>
+<li class="listitem">
+ Rene Rivera for Code Warrior portability.
+ </li>
+<li class="listitem">
+ Manuel Peinado Gallego for identifying the need for anonymous container
+ of references, his valuable advice throughout their development, and proposing
+ a design that laid the
+ foundation for chaining. Both features were introduced with Boost.Assign
+ v2.
+ </li>
+</ul></div>
+</div>
+<div class="section" title="Bibliography">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_assign_v2._.bibliography"></a><a class="link" href="index.html#boost_assign_v2._.bibliography" title="Bibliography">Bibliography</a>
+</h3></div></div></div>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+ Scott. Meyers, "More Effective C++", Item 7, Addison Wesley,
+ 1996
+ </li>
+<li class="listitem">
+ K. Czarnecki and U.W. Eisenecker, "Generative programming", Addison-Wesley,
+ 2000
+ </li>
+<li class="listitem">http://www.oonumerics.orgblitz</li>
+<li class="listitem">
+ Gabriel Dos Reis and Bjarne Stroustrup, <a href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1509.pdf" target="_top">Generalized
+ Initializer Lists</a>, 2003
+ </li>
+<li class="listitem">
+ Abrahams, David and Gurtovoy, Aleksey, <a href="http://portal.acm.org/citation.cfm?id=1044941#" target="_top">C++
+ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and
+ Beyond (C++ in Depth Series)</a>, 2004, Addison-Wesley Professional.
+ </li>
+</ul></div>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left">Last revised: August 05, 2010 at 05:05:38 GMT</td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+</body>
+</html>

Added: sandbox/statistics/support/libs/assign/v2/example/tutorial.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/example/tutorial.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,95 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <deque>
+#include <map>
+#include <vector>
+#include <boost/array.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/lambda/bind.hpp>
+
+#include <boost/range.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <boost/assign/v2/v2.hpp>
+
+#include <libs/assign/v2/example/tutorial.h>
+
+namespace example_assign_v2{
+namespace xxx_tutorial{
+
+ void run()
+ {
+ using namespace boost::assign::v2;
+ {
+ // --- PUT --- //
+ {
+ typedef boost::tuple<int&, const int&> tuple_;
+ typedef std::deque<tuple_> cont_;
+ cont_ cont;
+ int a1, a2, b1, c1;
+ constructor<tuple_>();
+ ( put_wrapper( cont ) % ( _fun = boost::lambda::bind<tuple_>(
+ constructor<tuple_>(),
+ boost::lambda::_1,
+ a2
+ ) ) )( a1 )( b1 )( c1 );
+ }
+ {
+ typedef std::map<const char*, int> cont_;
+ typedef boost::range_value<cont_>::type value_;
+ cont_ cont;
+ ( put_wrapper( cont ) % _incr_lookup).csv( "x", "y", "x" );
+ BOOST_ASSERT( cont["x"] == 2 );
+ BOOST_ASSERT( cont["y"] == 1 );
+ }
+ }
+ {
+ // --- ANON --- //
+ {
+ typedef std::vector<int> cont_;
+ cont_ cont = anon( 1 )( 2 )( 3 ).convert<cont_>();
+ BOOST_ASSERT(cont[0] == 1);
+ BOOST_ASSERT(cont[2] == 3);
+ }
+ }
+ {
+ // --- REF-ANON-- //
+ using namespace ref;
+ { // -- assign_copy-- //
+ std::vector<int> v( 3 ); v[ 0 ] = 1; v[ 1 ] = 2; v [ 3 ] = 3;
+ int a, b, c;
+ boost::copy( v ,
+ boost::begin( assign_copy::anon( a )( b )( c ) ) );
+ BOOST_ASSERT( a == v[ 0 ] );
+ BOOST_ASSERT( b == v[ 1 ] );
+ BOOST_ASSERT( c == v[ 2 ] );
+ }
+ {
+ int a = 1, b = 2, c = 3;
+ BOOST_AUTO( tmp, assign_rebind::csv_anon( a , b ) );
+ tmp.assign( c );
+ BOOST_ASSERT( &tmp[ 0 ] == &c );
+ BOOST_ASSERT( &tmp[ 1 ] == &c );
+ }
+ }
+ { // --- CHAIN --- //
+ using namespace ref;
+ typedef boost::array<int,3> cont_;
+ cont_ cont; cont[ 0 ] = 1; cont[ 1 ] = 2; cont[ 2 ] = 3;
+ int a, b, c = 3;
+ BOOST_AUTO( tmp, assign_copy::anon( a )( b ) );
+ boost::copy( cont , boost::begin( tmp && assign_copy::anon( c ) ) );
+ BOOST_ASSERT( a == cont[ 0 ] );
+ BOOST_ASSERT( b == cont[ 1 ] );
+ BOOST_ASSERT( c == cont[ 2 ] );
+ }
+ }
+}// xxx_tutorial
+}// example_assign_v2
+

Added: sandbox/statistics/support/libs/assign/v2/example/tutorial.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/example/tutorial.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,21 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_EXAMPLE_TUTORIAL_ER_2010_H
+#define BOOST_ASSIGN_V2_EXAMPLE_TUTORIAL_ER_2010_H
+
+namespace example_assign_v2{
+namespace xxx_tutorial{
+
+ void run();
+
+}// xxx_tutorial
+}// example_assign_v2
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/src/main.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/src/main.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,39 @@
+#include <libs/assign/v2/test/anon/anon.h>
+#include <libs/assign/v2/test/chain/chain.h>
+#include <libs/assign/v2/test/detail/functor.h>
+#include <libs/assign/v2/test/put/put_wrapper.h>
+#include <libs/assign/v2/test/put_range/convert.h>
+#include <libs/assign/v2/test/type_traits/has_push.h>
+#include <libs/assign/v2/test/type_traits/has_value_type.h>
+#include <libs/assign/v2/test/type_traits/has_static_size.h>
+#include <libs/assign/v2/test/ref/csv_anon.h>
+#include <libs/assign/v2/test/ref/ext_anon.h>
+#include <libs/assign/v2/test/ref/fusion_list.h>
+#include <libs/assign/v2/test/ref/static_list.h>
+#include <libs/assign/v2/test/ref/wrapper.h>
+
+#include <libs/assign/v2/example/tutorial.h>
+
+int main (int argc, char * const argv[]) {
+
+ using namespace test_assign_v2;
+ xxx_anon::xxx_anon::test();
+ xxx_chain::xxx_chain::test();
+ xxx_detail::xxx_functor::test();
+ xxx_type_traits::xxx_has_value_type::test();
+ xxx_type_traits::xxx_has_static_size::test();
+ xxx_ref::xxx_fusion_list::test();
+ xxx_ref::xxx_static_list::test();
+ xxx_ref::xxx_ext_anon::test();
+ xxx_ref::xxx_csv_anon::test();
+ xxx_ref::xxx_wrapper::test();
+ xxx_put::xxx_put_wrapper::test();
+ xxx_put_range::xxx_convert::test();
+
+ {
+ using namespace example_assign_v2;
+ xxx_tutorial::run();
+ }
+ return 0;
+
+}

Added: sandbox/statistics/support/libs/assign/v2/test/anon/anon.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/anon/anon.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,114 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <deque>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <vector>
+#include <boost/array.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <boost/assign/v2/detail/keyword/keyword.hpp>
+#include <boost/assign/v2/detail/checking/container.hpp>
+#include <boost/assign/v2/detail/checking/constants.hpp>
+#include <boost/assign/v2/detail/checking/relational_op.hpp>
+
+#include <boost/assign/v2/anon/anon.hpp>
+
+#include <libs/assign/v2/test/anon/anon.h>
+
+namespace test_assign_v2{
+namespace xxx_anon{
+namespace xxx_anon{
+
+ void test()
+ {
+ using namespace boost::assign::v2;
+ {
+ // CSV
+ using namespace checking::constants;
+ using namespace checking::container;
+ do_check( anon<int>( _nil ).csv( a, b , c , d , e , f , g , h ) );
+ }
+ {
+ // Operator%
+ BOOST_AUTO(tmp, ( anon<int>( _nil ) % (_repeat = 3) ) );
+ tmp( 1 );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( boost::size( tmp ), 3 );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( tmp.front(), 1 );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( tmp.back(), 1 );
+ }
+ {
+ // Conversion
+ typedef result_of::anon<int>::type anon_;
+ anon_ from;
+ {
+ using namespace checking::constants;
+ from = anon( a )( b )( c )( d )( e )( f )( g )( h );
+ }
+ using namespace checking::container;
+ {
+ typedef boost::array<int,8> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::deque<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::list<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::queue<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::set<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::stack<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::vector<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+
+ }
+ { // Relational
+ using namespace checking::constants;
+ using namespace checking::relational_op;
+ do_check(
+ anon( a )( b )( c )( d )( e )( f )( g )( h )
+ );
+ }
+
+ }
+
+}// xxx_anon
+}// xxx_anon
+}// test_assign_v2

Added: sandbox/statistics/support/libs/assign/v2/test/anon/anon.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/anon/anon.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,23 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_TEST_ANON_ANON_ER_2010_H
+#define BOOST_ASSIGN_V2_TEST_ANON_ANON_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_anon{
+namespace xxx_anon{
+
+ void test();
+
+}// xxx_anon
+}// xxx_anon
+}// test_assign_v2
+
+#endif
\ No newline at end of file

Added: sandbox/statistics/support/libs/assign/v2/test/chain/chain.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/chain/chain.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,30 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/assign/v2/chain/checking/twin_values.hpp>
+#include <boost/assign/v2/chain/checking/distinct_values.hpp>
+#include <libs/assign/v2/test/chain/chain.h>
+
+namespace test_assign_v2{
+namespace xxx_chain{
+namespace xxx_chain{
+
+ void test()
+ {
+ using namespace boost::assign::v2::checking::chain;
+ twin_values::do_check<int>();
+ distinct_values::do_check<short>();
+ distinct_values::do_check<int>();
+ distinct_values::do_check<float>();
+ distinct_values::do_check<double>();
+ }
+
+}// xxx_chain
+}// xxx_chain
+}// test_assign_v2

Added: sandbox/statistics/support/libs/assign/v2/test/chain/chain.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/chain/chain.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,23 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_TEST_CHAIN_CHAIN_ER_2010_H
+#define BOOST_ASSIGN_V2_TEST_CHAIN_CHAIN_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_chain{
+namespace xxx_chain{
+
+ void test();
+
+}// xxx_chain
+}// xxx_chain
+}// test_assign_v2
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/chain/convert.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/chain/convert.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,98 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <deque>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <vector>
+#include <boost/array.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <boost/assign/v2/chain/chain.hpp>
+#include <boost/assign/v2/detail/checking/container.hpp>
+#include <boost/assign/v2/detail/checking/constants.hpp>
+#include <libs/assign/v2/test/chain/convert.h>
+
+namespace test_assign_v2{
+namespace xxx_chain{
+namespace xxx_convert{
+
+ void test()
+ {
+ using namespace boost::assign::v2;
+ {
+ typedef std::vector<int> vec_;
+ typedef boost::array<int,3> array_;
+
+ vec_ cont1, cont3;
+ array_ cont2;
+ {
+ using namespace checking::constants;
+ cont1.push_back( a ); cont1.push_back( b );
+ cont2[0] = c;
+ cont2[1] = d;
+ cont2[2] = e;
+ cont3.push_back( f );
+ cont3.push_back( g );
+ cont3.push_back( h );
+ }
+ BOOST_AUTO(from, cont1 && cont2 && cont3);
+ { // Conversion
+ using namespace checking::container;
+ {
+ typedef boost::array<int,8> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::deque<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::list<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::queue<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::set<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::stack<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::vector<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ }
+ }
+ }
+
+}// xxx_convert
+}// xxx_chain
+}// test_assign_v2

Added: sandbox/statistics/support/libs/assign/v2/test/chain/convert.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/chain/convert.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,23 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_TEST_CHAIN_CONVERT_ER_2010_H
+#define BOOST_ASSIGN_V2_TEST_CHAIN_CONVERT_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_chain{
+namespace xxx_convert{
+
+ void test();
+
+}// xxx_convert
+}// xxx_chain
+}// test_assign_v2
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/detail/functor.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/detail/functor.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,37 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/tuple/tuple.hpp>
+#include <boost/assign/v2/detail/checking/check_equal.hpp>
+#include <boost/assign/v2/detail/functor/constructor.hpp>
+#include <libs/assign/v2/test/detail/functor.h>
+
+namespace test_assign_v2{
+namespace xxx_detail{
+namespace xxx_functor{
+
+ void test()
+ {
+ using namespace boost::assign::v2;
+
+ {
+ typedef boost::tuple<int&, int const&> t_;
+ typedef functor_aux::constructor<t_> f_;
+ int a = 1;
+ int b = 2;
+ f_ f;
+ t_ t = f( a, b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &boost::get<0>( t ), &a );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &boost::get<1>( t ), &b );
+ }
+ }
+
+}// xxx_functor
+}// xxx_detail
+}// test_assign_v2

Added: sandbox/statistics/support/libs/assign/v2/test/detail/functor.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/detail/functor.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,23 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_TEST_DETAIL_FUNCTOR_ER_2010_H
+#define BOOST_ASSIGN_V2_TEST_DETAIL_FUNCTOR_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_detail{
+namespace xxx_functor{
+
+ void test();
+
+}// xxx_functor
+}// xxx_detail
+}// test_assign_v2
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/put/modifier.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/put/modifier.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,68 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <deque>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <vector>
+#include <boost/array.hpp>
+
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/control/expr_if.hpp>
+#include <boost/assign/v2/detail/checking/assert.hpp>
+#include <boost/assign/v2/put/modifier/modifier.hpp>
+#include <libs/assign/v2/test/put/modifier.h>
+
+namespace test_assign_v2{
+namespace xxx_put{
+namespace xxx_modifier{
+
+#define LIBS_ASSIGN_V2_TEST_PUT_modifier( V, T0, T1, n )\
+ { \
+ typedef V< T0 BOOST_PP_COMMA_IF(n) BOOST_PP_EXPR_IF(n, T1) > cont_; \
+ typedef put_aux::deduce_modifier<cont_>::type found_; \
+ checking::do_assert_is_same<found_,wanted_>(); \
+ } \
+/**/
+
+ void test()
+ {
+ using namespace boost::assign::v2;
+ {
+ typedef put_tag::push_back wanted_;
+ LIBS_ASSIGN_V2_TEST_PUT_modifier( std::list, int, , 0 )
+ LIBS_ASSIGN_V2_TEST_PUT_modifier( std::set, int, , 0 )
+ LIBS_ASSIGN_V2_TEST_PUT_modifier( std::vector, int, , 0 )
+ LIBS_ASSIGN_V2_TEST_PUT_modifier( std::deque, int, , 0 )
+ }
+ {
+ typedef put_tag::at_next wanted_;
+ LIBS_ASSIGN_V2_TEST_PUT_modifier(boost::array, int, 1, 1 )
+ }
+ {
+ typedef put_tag::push wanted_;
+ LIBS_ASSIGN_V2_TEST_PUT_modifier( std::queue, int, , 0 )
+ LIBS_ASSIGN_V2_TEST_PUT_modifier( std::stack, int, , 0 )
+ }
+ {
+ typedef put_tag::insert wanted_;
+ LIBS_ASSIGN_V2_TEST_PUT_modifier( std::map, const char*, int, 1 )
+ }
+
+ }
+
+#undef LIBS_ASSIGN_V2_TEST_PUT_modifier
+
+}// xxx_modifier
+}// xxx_put
+}// test_assign_v2
+

Added: sandbox/statistics/support/libs/assign/v2/test/put/modifier.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/put/modifier.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,23 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_CHAIN_TEST_PUT_MODIFIER_ER_2010_H
+#define BOOST_ASSIGN_V2_CHAIN_TEST_PUT_MODIFIER_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_put{
+namespace xxx_modifier{
+
+ void test();
+
+}// modifier
+}// xxx_put
+}// xxx_test_assign
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/put/put_wrapper.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/put/put_wrapper.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,87 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <deque>
+#include <queue>
+#include <vector>
+#include <map>
+#include <boost/array.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/assign/v2/detail/checking/container.hpp>
+#include <boost/assign/v2/detail/checking/constants.hpp>
+#include <boost/assign/v2/put/put.hpp>
+#include <libs/assign/v2/test/put/put_wrapper.h>
+
+namespace test_assign_v2{
+namespace xxx_put{
+namespace xxx_put_wrapper{
+
+ void test()
+ {
+ using namespace boost::assign::v2;
+ using namespace checking::constants;
+ namespace chk_cont = checking::container;
+ {
+ // Array
+ typedef boost::array<int,8> cont_;
+ cont_ cont;
+ chk_cont::do_check(
+ put_wrapper( cont )
+ ( a )( b )( c )( d )( e )( f )( g )( h ).unwrap()
+ );
+ }
+ { // Queue
+ typedef std::queue<int> cont_;
+ cont_ cont;
+ ( put_wrapper( cont ) % (_repeat = 3 ) ) (-1);
+ BOOST_ASSIGN_V2_CHECK_EQUAL( cont.front(), -1); cont.pop();
+ BOOST_ASSIGN_V2_CHECK_EQUAL( cont.front(), -1); cont.pop();
+ BOOST_ASSIGN_V2_CHECK_EQUAL( cont.front(), -1); cont.pop();
+ BOOST_ASSIGN_V2_CHECK_EQUAL( cont.empty(), true);
+ }
+ {
+ int a1, b1, c1, d1;//, e1, f1, g1, h1;
+ {
+ a1 = a; b1 = b; c1 = c;
+ d1 = d;
+ }
+ { // Deque + tuple
+ typedef boost::tuple<int&, const int&> tuple_;
+ typedef std::deque<tuple_> cont_;
+ {
+ cont_ cont;
+ put_wrapper( cont )( a1 , b1 )( c1 , d1 );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &a1, &boost::get<0>( cont[0] ) );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &b1, &boost::get<1>( cont[0] ) );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &c1, &boost::get<0>( cont[1] ) );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &d1, &boost::get<1>( cont[1] ) );
+ }
+ }
+ {
+ // Map
+ typedef std::map<const char*, int> cont_;
+ cont_ cont;
+ put_wrapper( cont )( "x", 2 )( "y", 1 );
+ }
+ { // Map
+ typedef std::map<const char*, int> cont_;
+ cont_ cont;
+ ( put_wrapper( cont ) % _incr_lookup).csv( "x", "y", "x" );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( 2, cont["x"] );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( 1, cont["y"] );
+ }
+ }
+ }
+
+
+}// xxx_put_wrapper
+}// xxx_put
+}// test_assign_v2
+
+

Added: sandbox/statistics/support/libs/assign/v2/test/put/put_wrapper.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/put/put_wrapper.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,24 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_CHAIN_TEST_PUT_PUT_WRAPPER_ER_2010_H
+#define BOOST_ASSIGN_V2_CHAIN_TEST_PUT_PUT_WRAPPER_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_put{
+namespace xxx_put_wrapper{
+
+ void test();
+
+}// xxx_put_wrapper
+}// xxx_put
+}// test_assign_v2
+
+#endif
+

Added: sandbox/statistics/support/libs/assign/v2/test/put_range/convert.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/put_range/convert.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,78 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <deque>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <vector>
+#include <boost/array.hpp>
+
+#include <boost/assign/v2/detail/checking/container.hpp>
+#include <boost/assign/v2/detail/checking/constants.hpp>
+#include <boost/assign/v2/put/range/range.hpp>
+
+#include <libs/assign/v2/test/put_range/convert.h>
+
+namespace test_assign_v2{
+namespace xxx_put_range{
+namespace xxx_convert{
+
+ void test()
+ {
+ typedef std::vector<int> from_;
+ from_ from;
+ using namespace boost::assign::v2;
+ namespace chk_cont = checking::container;
+ {
+ using namespace checking::constants;
+ from.push_back( a );
+ from.push_back( b );
+ from.push_back( c );
+ from.push_back( d );
+ from.push_back( e );
+ from.push_back( f );
+ from.push_back( g );
+ from.push_back( h );
+ }
+ {
+ typedef boost::array<int,8> to_;
+ chk_cont::do_check( convert<to_>( from ) );
+ }
+ {
+ typedef std::deque<int> to_;
+ chk_cont::do_check( convert<to_>( from ) );
+ }
+ {
+ typedef std::list<int> to_;
+ chk_cont::do_check( convert<to_>( from ) );
+ }
+ {
+ typedef std::queue<int> to_;
+ chk_cont::do_check( convert<to_>( from ) );
+ }
+ {
+ typedef std::set<int> to_;
+ chk_cont::do_check( convert<to_>( from ) );
+ }
+ {
+ typedef std::stack<int> to_;
+ chk_cont::do_check( convert<to_>( from ) );
+ }
+ {
+ typedef std::vector<int> to_;
+ chk_cont::do_check( convert<to_>( from ) );
+ }
+ }
+
+}// xxx_convert
+}// xxx_put_range
+}// test_assign_v2

Added: sandbox/statistics/support/libs/assign/v2/test/put_range/convert.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/put_range/convert.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,23 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_TEST_PUT_RANGE_CONVERT_ER_2010_H
+#define BOOST_ASSIGN_V2_TEST_PUT_RANGE_CONVERT_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_put_range{
+namespace xxx_convert{
+
+ void test();
+
+}// xxx_convert
+}// xxx_put_range
+}// test_assign_v2
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/ref/convert_traits.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/convert_traits.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,35 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <libs/assign/v2/test/ref/convert_traits.h>
+#include <boost/assign/v2/ref/detail/convert_traits/checking.hpp>
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_convert_traits{
+
+ void test()
+ {
+ namespace ns = boost::assign::v2::ref::convert_traits::checking;
+ {
+ ns::twin_values::do_check<int>();
+ }
+ {
+ namespace dv = ns::distinct_values;
+ namespace ari = dv::arithmetic;
+ ari::do_check<short>();
+ ari::do_check<int>();
+ ari::do_check<float>();
+ ari::do_check<double>();
+ }
+ }
+
+}// convert_traits
+}// ref
+}// test_assign

Added: sandbox/statistics/support/libs/assign/v2/test/ref/convert_traits.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/convert_traits.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,24 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_CHAIN_TEST_REF_CONVERT_TRAITS_ER_2010_H
+#define BOOST_ASSIGN_V2_CHAIN_TEST_REF_CONVERT_TRAITS_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_conversion{
+
+ void test();
+
+}// xxx_conversion
+}// xxx_ref
+}// test_assign
+
+#endif
+

Added: sandbox/statistics/support/libs/assign/v2/test/ref/csv_anon.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/csv_anon.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,106 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <vector>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/empty_base.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <boost/assign/v2/detail/checking/check_equal.hpp>
+#include <boost/assign/v2/detail/checking/constants.hpp>
+#include <boost/assign/v2/detail/checking/range.hpp>
+#include <boost/assign/v2/detail/checking/array.hpp>
+#include <boost/assign/v2/ref/anon/csv/csv.hpp>
+#include <libs/assign/v2/test/ref/ext_anon.h>
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_csv_anon{
+
+ void test()
+ {
+ using namespace boost::assign::v2;
+ typedef ref::assign_tag::copy copy_;
+ {
+ typedef ref::nth_result_of::csv_anon<
+ 8,
+ copy_,
+ int const
+ >::type ar_;
+ using namespace checking::constants;
+ ar_ ar = ref::csv_anon<copy_>
+ ( a , b , c , d , e , f , g , h );
+ using namespace checking;
+ {
+ typedef container_tag::static_array tag_;
+ checking::do_check(tag_(), ar );
+ }
+ {
+ typedef container_tag::range tag_;
+ checking::do_check(tag_(), ar );
+ }
+ }
+ {
+ int a1, b1, c1, d1, e1, f1, g1, h1;
+ typedef std::vector<int> vec_;
+ vec_ vec;
+ {
+ using namespace checking::constants;
+ vec.push_back( a );
+ vec.push_back( b );
+ vec.push_back( c );
+ vec.push_back( d );
+ vec.push_back( e );
+ vec.push_back( f );
+ vec.push_back( g );
+ vec.push_back( h );
+ }
+ boost::copy(
+ vec,
+ boost::begin( ref::assign_copy::csv_anon
+ ( a1 , b1 , c1 , d1 , e1 , f1 , g1 , h1 )
+ )
+ );
+ {
+ using namespace checking;
+ typedef container_tag::static_array tag_;
+ do_check( tag_(), ref::assign_copy::csv_anon<int const>
+ ( a1 , b1 , c1 , d1 , e1 , f1 , g1 , h1 )
+ );
+ }
+ }
+ {
+ typedef int const& cref_;
+ using namespace checking::constants;
+ cref_ a1 = a, b1 = b, c1 = c, d1 = d, e1 = e, f1 = f, g1 = g,
+ h1 = h;
+ BOOST_AUTO(ar, ref::assign_rebind::csv_anon
+ ( a1 , b1 , c1 , d1 , e1 , f1 , g1 , h1 )
+ );
+ {
+ using namespace checking;
+ typedef container_tag::static_array tag_;
+ do_check( tag_(), ar );
+ }
+ ar.assign( b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[0] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[1] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[2] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[3] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[4] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[5] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[6] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[7] , &b );
+ }
+ }
+
+}// xxx_csv_anon
+}// xxx_ref
+}// test_assign

Added: sandbox/statistics/support/libs/assign/v2/test/ref/csv_anon.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/csv_anon.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,24 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_CHAIN_TEST_REF_CSV_ARRAY_ER_2010_H
+#define BOOST_ASSIGN_V2_CHAIN_TEST_REF_CSV_ARRAY_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_csv_anon{
+
+ void test();
+
+}// xxx_csv_anon
+}// xxx_ref
+}// test_assign
+
+#endif
+

Added: sandbox/statistics/support/libs/assign/v2/test/ref/ext_anon.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/ext_anon.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,175 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <deque>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <vector>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/empty_base.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <boost/assign/v2/detail/checking/check_equal.hpp>
+#include <boost/assign/v2/detail/checking/constants.hpp>
+#include <boost/assign/v2/detail/checking/container.hpp>
+#include <boost/assign/v2/detail/checking/array.hpp>
+#include <boost/assign/v2/detail/checking/relational_op.hpp>
+#include <boost/assign/v2/ref/anon/functor/functor.hpp>
+#include <boost/assign/v2/ref/wrapper/copy.hpp>
+#include <libs/assign/v2/test/ref/ext_anon.h>
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_ext_anon{
+
+ void test()
+ {
+ using namespace boost::assign::v2;
+ typedef ref::assign_tag::copy copy_;
+ {
+ // Array
+ typedef ref::nth_result_of::anon<
+ 8,
+ copy_,
+ int const
+ >::type ar_;
+ using namespace checking::constants;
+ ar_ ar = ref::anon<copy_>
+ ( a )( b )( c )( d )( e )( f )( g )( h );
+ {
+ using namespace checking;
+ typedef container_tag::static_array tag_;
+ do_check(tag_(), ar );
+ }
+ }
+ {
+ // Assignement of references
+ int a1, b1, c1, d1, e1, f1, g1, h1;
+ typedef std::vector<int> vec_;
+ vec_ vec;
+ {
+ using namespace checking::constants;
+ vec.push_back( a );
+ vec.push_back( b );
+ vec.push_back( c );
+ vec.push_back( d );
+ vec.push_back( e );
+ vec.push_back( f );
+ vec.push_back( g );
+ vec.push_back( h );
+ }
+ boost::copy(
+ vec,
+ boost::begin( ref::assign_copy::anon
+ ( a1 )( b1 )( c1 )( d1 )( e1 )( f1 )( g1 )( h1 )
+ )
+ );
+ {
+ using namespace checking::container;
+ do_check( ref::assign_copy::anon<int const>
+ ( a1 )( b1 )( c1 )( d1 )( e1 )( f1 )( g1 )( h1 )
+ );
+ }
+ }
+ {
+ // Rebind
+ typedef int const& cref_;
+ using namespace checking::constants;
+ cref_ a1 = a, b1 = b, c1 = c, d1 = d, e1 = e, f1 = f, g1 = g,
+ h1 = h;
+ BOOST_AUTO(ar, ref::assign_rebind::anon
+ ( a1 )( b1 )( c1 )( d1 )( e1 )( f1 )( g1 )( h1 )
+ );
+ {
+ using namespace checking::container;
+ do_check( ar );
+ }
+ ar.assign( b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[0] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[1] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[2] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[3] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[4] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[5] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[6] , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar[7] , &b );
+ }
+ {
+ // Conversion
+ typedef ref::assign_copy::nth_result_of::anon<
+ 8,int const>::type anon_;
+
+ anon_ from;
+ {
+ using namespace checking::constants;
+ from = ref::assign_copy::anon
+ ( a )( b )( c )( d )( e )( f )( g )( h );
+ }
+ using namespace checking::container;
+ {
+ typedef boost::array<int,8> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::deque<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::list<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::queue<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::set<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::stack<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+ {
+ typedef std::vector<int> to_;
+ do_check( from.convert<to_>() );
+ to_ to; to = from;
+ do_check( from );
+ }
+
+ }
+ { // Relational
+ using namespace checking::constants;
+ using namespace checking::relational_op;
+ do_check(
+ ref::assign_copy::anon
+ ( a )( b )( c )( d )( e )( f )( g )( h )
+ );
+ }
+ }
+
+}// xxx_ext_anon
+}// xxx_ref
+}// test_assign

Added: sandbox/statistics/support/libs/assign/v2/test/ref/ext_anon.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/ext_anon.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,24 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_CHAIN_TEST_REF_EXT_ARRAY_ER_2010_H
+#define BOOST_ASSIGN_V2_CHAIN_TEST_REF_EXT_ARRAY_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_ext_anon{
+
+ void test();
+
+}// xxx_ext_anon
+}// xxx_ref
+}// test_assign
+
+#endif
+

Added: sandbox/statistics/support/libs/assign/v2/test/ref/fusion_list.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/fusion_list.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,89 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/array.hpp>
+#include <boost/assign/v2/detail/checking/check_equal.hpp>
+#include <boost/assign/v2/ref/wrapper/copy.hpp>
+#include <boost/assign/v2/ref/detail/fusion_list/fusion_list.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <libs/assign/v2/test/ref/fusion_list.h>
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_fusion_list{
+
+ void test()
+ {
+ using namespace boost::assign::v2;
+ using namespace ref;
+ typedef assign_tag::copy assign_tag_;
+ typedef boost::mpl::int_<0> i0_;
+ typedef boost::mpl::int_<1> i1_;
+ typedef boost::mpl::int_<2> i2_;
+ {
+ typedef int t0_;
+ typedef int const t1_;
+ typedef const char* t2_;
+ t0_ a = 0;
+ t1_ b = 1;
+ t2_ c = "c";
+
+ typedef nth_result_of::fusion_list<assign_tag_,t0_> result_;
+ typedef boost::mpl::apply3<result_,t0_,t1_,t2_>::type ar_;
+ ar_ ar = fusion_list<assign_tag_>( a )( b )( c );
+ ar.static_lookup( i0_() );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar.static_lookup( i0_() ), &a );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar.static_lookup( i1_() ), &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar.static_lookup( i2_() ), &c );
+ {
+ typedef boost::mpl::apply2<result_,t0_,t1_>::type ar2_;
+ ar2_ ar2 = ar.pop();
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar2.back(), &b );
+ typedef boost::mpl::apply1<result_,t0_>::type ar1_;
+ ar1_ ar1 = ar2.pop();
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &ar1.back(), &a );
+ typedef boost::mpl::apply0<result_>::type ar0_;
+ ar0_ ar0 = ar1.pop();
+ }
+ }
+ {
+ typedef int t_;
+ t_ a = 0;
+ t_ b = 1;
+ t_ c = 2;
+ typedef wrapper<assign_tag_,t_> w_;
+ typedef boost::array<w_,3> arw_;
+ typedef nth_result_of::fusion_list<assign_tag_,t_> result_;
+ typedef boost::mpl::apply3<result_,t_,t_,t_>::type ar_;
+ ar_ ar = fusion_list<assign_tag_>( a )( b )( c );
+ arw_ arw;
+ assign_array( arw, ar );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &arw[ 0 ].unwrap() , &a );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &arw[ 1 ].unwrap() , &b );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &arw[ 2 ].unwrap() , &c );
+ }
+ {
+ typedef int t_;
+ t_ a = 0;
+ t_ b = 1;
+ t_ c = 2;
+ typedef boost::tuple<t_ const&> tuple_;
+ typedef nth_result_of::fusion_list<assign_tag_,tuple_> result_;
+ typedef boost::mpl::apply3<result_,t_,t_,t_>::type ar_;
+ fusion_list<assign_tag_>
+ ( tuple_( a ) )( tuple_( b ) )( tuple_( c ) );
+ }
+ }
+
+}// xxx_fusion_list
+}// xxx_ref
+}// test_assign
+

Added: sandbox/statistics/support/libs/assign/v2/test/ref/fusion_list.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/fusion_list.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,24 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_CHAIN_TEST_REF_FUSION_LIST_ER_2010_H
+#define BOOST_ASSIGN_V2_CHAIN_TEST_REF_FUSION_LIST_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_fusion_list{
+
+ void test();
+
+}// xxx_fusion_list
+}// xxx_ref
+}// test_assign
+
+#endif
+

Added: sandbox/statistics/support/libs/assign/v2/test/ref/static_list.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/static_list.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,43 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/empty_base.hpp>
+#include <boost/assign/v2/detail/checking/check_equal.hpp>
+#include <boost/assign/v2/ref/detail/static_list/static_list.hpp>
+#include <boost/assign/v2/ref/wrapper/copy.hpp>
+#include <libs/assign/v2/test/ref/static_list.h>
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_static_list{
+
+ void test()
+ {
+ using namespace boost::assign::v2::ref;
+ {
+ typedef assign_tag::copy tag1_;
+ typedef boost::mpl::empty_base tag2_;
+ typedef nth_result_of::static_list<2,
+ tag1_,
+ tag2_,
+ int
+ >::type list2_;
+ int a = 0, b = 1;
+ list2_ list2 = static_list<tag1_,tag2_>( a )( b );
+ typedef boost::mpl::int_<0> i0_;
+ typedef boost::mpl::int_<1> i1_;
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &list2.static_lookup( i0_() ) , &a );
+ BOOST_ASSIGN_V2_CHECK_EQUAL( &list2.static_lookup( i1_() ) , &b );
+ }
+ }
+
+}// xxx_static_list
+}// xxx_ref
+}// test_assign

Added: sandbox/statistics/support/libs/assign/v2/test/ref/static_list.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/static_list.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,24 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_CHAIN_TEST_REF_STATIC_LIST_ER_2010_H
+#define BOOST_ASSIGN_V2_CHAIN_TEST_REF_STATIC_LIST_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_static_list{
+
+ void test();
+
+}// xxx_static_list
+}// xxx_ref
+}// test_assign
+
+#endif
+

Added: sandbox/statistics/support/libs/assign/v2/test/ref/wrapper.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/wrapper.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,52 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <libs/assign/v2/test/ref/wrapper.h>
+#include <boost/assign/v2/ref/wrapper/wrapper.hpp>
+#include <boost/assign/v2/detail/checking/check_equal.hpp>
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_wrapper{
+
+ void test()
+ {
+ using namespace boost::assign::v2;
+ typedef int val_;
+ {
+ typedef ref::type_traits::copy_wrapper<val_>::type w_;
+ w_ w;
+ val_ a = 1, b = 2, c = 3;
+ w.rebind( a ); BOOST_ASSIGN_V2_CHECK_EQUAL( &w.unwrap(), &a );
+ w.assign( b ); BOOST_ASSIGN_V2_CHECK_EQUAL( a, b );
+ w = c; BOOST_ASSIGN_V2_CHECK_EQUAL( a, c );
+ }
+ {
+ typedef ref::type_traits::copy_wrapper<val_ const>::type w_;
+ w_ w;
+ val_ a = 1;
+ w.rebind( a ); BOOST_ASSIGN_V2_CHECK_EQUAL( &w.unwrap(), &a );
+ }
+ {
+ typedef ref::type_traits::rebind_wrapper<val_>::type w_;
+ w_ w;
+ val_ a = 1;
+ w = a; BOOST_ASSIGN_V2_CHECK_EQUAL( &w.unwrap(), &a );
+ }
+ {
+ typedef ref::type_traits::rebind_wrapper<val_ const>::type w_;
+ w_ w;
+ val_ const a = 1;
+ w = a; BOOST_ASSIGN_V2_CHECK_EQUAL( &w.unwrap(), &a );
+ }
+ }
+
+}// xxx_wrapper
+}// xxx_ref
+}// test_assign_v2

Added: sandbox/statistics/support/libs/assign/v2/test/ref/wrapper.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/ref/wrapper.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,23 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_CHAIN_TEST_REF_WRAPPER_ER_2010_H
+#define BOOST_ASSIGN_V2_CHAIN_TEST_REF_WRAPPER_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_ref{
+namespace xxx_wrapper{
+
+ void test();
+
+}// xxx_wrapper
+}// xxx_ref
+}// test_assign
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/type_traits/has_push.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/type_traits/has_push.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,48 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <vector>
+#include <stack>
+#include <queue>
+#include <boost/static_assert.hpp>
+#include <boost/assign/v2/detail/type_traits/container/has_push.hpp>
+#include <libs/assign/v2/test/type_traits/has_push.h>
+
+namespace test_assign_v2{
+namespace xxx_type_traits{
+namespace xxx_has_push{
+
+ void test()
+ {
+ namespace ns = boost::assign::v2::container_type_traits;
+ {
+ typedef std::queue<int> v_;
+ typedef ns::has_push<v_> has_push_;
+
+ //typedef void (v_::*fp_)(int const&) ;
+ //fp_ fp = &v_::push; v_ v; ((v).*fp)( 1 );
+ //BOOST_ASSERT(v.front() == 1);
+ BOOST_STATIC_ASSERT( has_push_::value );
+ }
+ {
+ typedef std::stack<int> v_;
+ typedef ns::has_push<v_> has_push_;
+ BOOST_STATIC_ASSERT( has_push_::value );
+ }
+ {
+ typedef std::vector<int> v_;
+ typedef ns::has_push<v_> has_push_;
+ BOOST_STATIC_ASSERT( !has_push_::value );
+ }
+ }
+
+}// xxx_has_push
+}// xxx_type_traits
+}// test_assign_v2
+

Added: sandbox/statistics/support/libs/assign/v2/test/type_traits/has_push.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/type_traits/has_push.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,24 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_TEST_TYPE_TRAITS_HAS_PUSH_ER_2010_H
+#define BOOST_ASSIGN_V2_TEST_TYPE_TRAITS_HAS_PUSH_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_type_traits{
+namespace xxx_has_push{
+
+ void test();
+
+}// xxx_has_push
+}// xxx_type_traits
+}// test_assign_v2
+
+#endif
+

Added: sandbox/statistics/support/libs/assign/v2/test/type_traits/has_static_size.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/type_traits/has_static_size.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,47 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/array.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/assign/v2/detail/type_traits/container/has_static_size.hpp>
+#include <boost/assign/v2/ref/anon/functor/assign_copy.hpp>
+#include <libs/assign/v2/test/type_traits/has_static_size.h>
+
+struct foo{
+ typedef std::size_t size_type;
+};
+
+namespace test_assign_v2{
+namespace xxx_type_traits{
+namespace xxx_has_static_size{
+
+ void test()
+ {
+ using namespace boost::assign::v2;
+ {
+ typedef boost::array<int,1> cont_;
+ typedef container_type_traits::has_static_size<cont_> pred_;
+ BOOST_STATIC_ASSERT( pred_::value );
+ }
+ {
+ typedef ref::assign_copy::result_of::anon_nil<
+ int>::type cont_;
+ typedef container_type_traits::has_static_size<cont_> pred_;
+ BOOST_STATIC_ASSERT( pred_::value );
+ }
+ {
+ typedef foo cont_;
+ typedef container_type_traits::has_static_size<cont_> pred_;
+ BOOST_STATIC_ASSERT( !pred_::value );
+ }
+ }
+
+}// xxx_has_static_size
+}// xxx_type_traits
+}// test_assign_v2

Added: sandbox/statistics/support/libs/assign/v2/test/type_traits/has_static_size.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/type_traits/has_static_size.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,23 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_TEST_TYPE_TRAITS_HAS_STATIC_SIZE_ER_2010_H
+#define BOOST_ASSIGN_V2_TEST_TYPE_TRAITS_HAS_STATIC_SIZE_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_type_traits{
+namespace xxx_has_static_size{
+
+ void test();
+
+}// xxx_has_static_size
+}// xxx_type_traits
+}// test_assign
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/type_traits/has_value_type.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/type_traits/has_value_type.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,37 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#include <vector>
+#include <boost/static_assert.hpp>
+#include <boost/assign/v2/detail/type_traits/has_value_type.hpp>
+#include <libs/assign/v2/test/type_traits/has_value_type.h>
+
+namespace test_assign_v2{
+namespace xxx_type_traits{
+namespace xxx_has_value_type{
+
+ void test(){
+
+ using namespace boost::assign::v2;
+ {
+ typedef std::vector<int> inp_;
+ typedef type_traits::has_value_type<inp_>::type pred_;
+ BOOST_STATIC_ASSERT(pred_::value);
+ }
+ {
+ typedef int inp_;
+ typedef type_traits::has_value_type<inp_>::type pred_;
+ BOOST_STATIC_ASSERT(!pred_::value);
+ }
+ }
+
+
+}// xxx_has_value_type
+}// xxx_type_traits
+}// test_assign

Added: sandbox/statistics/support/libs/assign/v2/test/type_traits/has_value_type.h
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/type_traits/has_value_type.h 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,23 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_ASSIGN_V2_TEST_TYPE_TRAITS_HAS_VALUE_TYPE_ER_2010_H
+#define BOOST_ASSIGN_V2_TEST_TYPE_TRAITS_HAS_VALUE_TYPE_ER_2010_H
+
+namespace test_assign_v2{
+namespace xxx_type_traits{
+namespace xxx_has_value_type{
+
+ void test();
+
+}// xxx_has_value_type
+}// xxx_type_traits
+}// test_assign
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/unit_testing/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/unit_testing/Jamfile.v2 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,28 @@
+# Boost.Assign library
+#
+# Copyright Thorsten Ottosen 2003-2005. Use, modification and
+# distribution is subject to the Boost Software License, Version
+# 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+# For more information, see http://www.boost.org/libs/assign/
+#
+
+rule assign-test ( name )
+{
+ return [
+ run $(name).cpp /boost/test//boost_unit_test_framework/<link>static ]
+ ;
+}
+
+test-suite assign :
+ [ assign-test anon ]
+ [ assign-test chain ]
+ [ assign-test detail ]
+ [ assign-test put_range ]
+ [ assign-test put ]
+ [ assign-test ref ]
+ [ assign-test type_traits ]
+;
+
+

Added: sandbox/statistics/support/libs/assign/v2/test/unit_testing/anon.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/unit_testing/anon.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,32 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef LIBS_ASSIGN_V2_TEST_UNIT_TEST_ANON_ER_2010_CPP
+#define LIBS_ASSIGN_V2_TEST_UNIT_TEST_ANON_ER_2010_CPP
+
+#include <iostream> // needed?
+
+#include <boost/test/test_tools.hpp>
+#define BOOST_ASSIGN_CHECK_EQUAL(a,b) BOOST_CHECK_EQUAL(a,b)
+#include <libs/assign/v2/test/anon/anon.cpp>
+
+#include <boost/test/unit_test.hpp>
+using boost::unit_test::test_suite;
+test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+ test_suite* test = BOOST_TEST_SUITE( "BOOST_ASSIGN_V2" );
+ using namespace test_assign_v2;
+ {
+ namespace ns = xxx_anon;
+ test->add( BOOST_TEST_CASE( &ns::xxx_anon::test ) );
+ }
+ return test;
+}
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/unit_testing/chain.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/unit_testing/chain.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,34 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef LIBS_ASSIGN_V2_TEST_UNIT_TEST_CHAIN_ER_2010_CPP
+#define LIBS_ASSIGN_V2_TEST_UNIT_TEST_CHAIN_ER_2010_CPP
+
+#include <iostream> // needed?
+
+#include <boost/test/test_tools.hpp>
+#define BOOST_ASSIGN_CHECK_EQUAL(a,b) BOOST_CHECK_EQUAL(a,b)
+#include <libs/assign/v2/test/chain/convert.cpp>
+#include <libs/assign/v2/test/chain/chain.cpp>
+
+#include <boost/test/unit_test.hpp>
+using boost::unit_test::test_suite;
+test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+ test_suite* test = BOOST_TEST_SUITE( "BOOST_ASSIGN_V2" );
+ using namespace test_assign_v2;
+ {
+ namespace ns = xxx_chain;
+ test->add( BOOST_TEST_CASE( &ns::xxx_convert::test ) );
+ test->add( BOOST_TEST_CASE( &ns::xxx_chain::test ) );
+ }
+ return test;
+}
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/unit_testing/detail.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/unit_testing/detail.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,32 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef LIBS_ASSIGN_V2_TEST_UNIT_TEST_DETAIL_ER_2010_CPP
+#define LIBS_ASSIGN_V2_TEST_UNIT_TEST_DETAIL_ER_2010_CPP
+
+#include <iostream> // needed?
+
+#include <boost/test/test_tools.hpp>
+#define BOOST_ASSIGN_CHECK_EQUAL(a,b) BOOST_CHECK_EQUAL(a,b)
+#include <libs/assign/v2/test/detail/functor.cpp>
+
+#include <boost/test/unit_test.hpp>
+using boost::unit_test::test_suite;
+test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+ test_suite* test = BOOST_TEST_SUITE( "BOOST_ASSIGN_V2" );
+ using namespace test_assign_v2;
+ {
+ using namespace xxx_detail;
+ test->add( BOOST_TEST_CASE( &xxx_functor::test ) );
+ }
+ return test;
+}
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/unit_testing/put.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/unit_testing/put.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,34 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef LIBS_ASSIGN_V2_TEST_UNIT_TEST_PUT_ER_2010_CPP
+#define LIBS_ASSIGN_V2_TEST_UNIT_TEST_PUT_ER_2010_CPP
+
+#include <iostream> // needed?
+
+#include <boost/test/test_tools.hpp>
+#define BOOST_ASSIGN_CHECK_EQUAL(a,b) BOOST_CHECK_EQUAL(a,b)
+#include <libs/assign/v2/test/put/put_wrapper.cpp>
+#include <libs/assign/v2/test/put/modifier.cpp>
+
+#include <boost/test/unit_test.hpp>
+using boost::unit_test::test_suite;
+test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+ test_suite* test = BOOST_TEST_SUITE( "BOOST_ASSIGN_V2" );
+ using namespace test_assign_v2;
+ {
+ using namespace xxx_put;
+ test->add( BOOST_TEST_CASE( &xxx_put_wrapper::test ) );
+ test->add( BOOST_TEST_CASE( &xxx_modifier::test ) );
+ }
+ return test;
+}
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/unit_testing/put_range.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/unit_testing/put_range.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,32 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef LIBS_ASSIGN_V2_TEST_UNIT_TEST_PUT_RANGE_ER_2010_CPP
+#define LIBS_ASSIGN_V2_TEST_UNIT_TEST_PUT_RANGE_ER_2010_CPP
+
+#include <iostream> // needed?
+
+#include <boost/test/test_tools.hpp>
+#define BOOST_ASSIGN_CHECK_EQUAL(a,b) BOOST_CHECK_EQUAL(a,b)
+#include <libs/assign/v2/test/put_range/convert.cpp>
+
+#include <boost/test/unit_test.hpp>
+using boost::unit_test::test_suite;
+test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+ test_suite* test = BOOST_TEST_SUITE( "BOOST_ASSIGN_V2" );
+ using namespace test_assign_v2;
+ {
+ using namespace xxx_put_range;
+ test->add( BOOST_TEST_CASE( &xxx_convert::test ) );
+ }
+ return test;
+}
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/unit_testing/ref.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/unit_testing/ref.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,42 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef LIBS_ASSIGN_V2_TEST_UNIT_TEST_REF_ER_2010_CPP
+#define LIBS_ASSIGN_V2_TEST_UNIT_TEST_REF_ER_2010_CPP
+
+#include <iostream> // needed?
+
+#include <boost/test/test_tools.hpp>
+#define BOOST_ASSIGN_CHECK_EQUAL(a,b) BOOST_CHECK_EQUAL(a,b)
+#include <libs/assign/v2/test/ref/convert_traits.cpp>
+#include <libs/assign/v2/test/ref/csv_anon.cpp>
+#include <libs/assign/v2/test/ref/ext_anon.cpp>
+#include <libs/assign/v2/test/ref/fusion_list.cpp>
+#include <libs/assign/v2/test/ref/static_list.cpp>
+#include <libs/assign/v2/test/ref/wrapper.cpp>
+
+#include <boost/test/unit_test.hpp>
+using boost::unit_test::test_suite;
+test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+ test_suite* test = BOOST_TEST_SUITE( "BOOST_ASSIGN_V2" );
+ using namespace test_assign_v2;
+ {
+ using namespace xxx_ref;
+ test->add( BOOST_TEST_CASE( &xxx_convert_traits::test ) );
+ test->add( BOOST_TEST_CASE( &xxx_csv_anon::test ) );
+ test->add( BOOST_TEST_CASE( &xxx_ext_anon::test ) );
+ test->add( BOOST_TEST_CASE( &xxx_fusion_list::test ) );
+ test->add( BOOST_TEST_CASE( &xxx_static_list::test ) );
+ test->add( BOOST_TEST_CASE( &xxx_wrapper::test ) );
+ }
+ return test;
+}
+
+#endif

Added: sandbox/statistics/support/libs/assign/v2/test/unit_testing/type_traits.cpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/support/libs/assign/v2/test/unit_testing/type_traits.cpp 2010-08-05 01:23:17 EDT (Thu, 05 Aug 2010)
@@ -0,0 +1,36 @@
+//////////////////////////////////////////////////////////////////////////////
+// Boost.Assign v2 //
+// //
+// Copyright (C) 2003-2004 Thorsten Ottosen //
+// Copyright (C) 2010 Erwann Rogard //
+// Use, modification and distribution are subject to the //
+// Boost Software License, Version 1.0. (See accompanying file //
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //
+//////////////////////////////////////////////////////////////////////////////
+#ifndef LIBS_ASSIGN_V2_TEST_UNIT_TEST_TYPE_TRAITS_ER_2010_CPP
+#define LIBS_ASSIGN_V2_TEST_UNIT_TEST_TYPE_TRAITS_ER_2010_CPP
+
+#include <iostream> // needed?
+
+#include <boost/test/test_tools.hpp>
+#define BOOST_ASSIGN_CHECK_EQUAL(a,b) BOOST_CHECK_EQUAL(a,b)
+#include <libs/assign/v2/test/type_traits/has_push.cpp>
+#include <libs/assign/v2/test/type_traits/has_value_type.cpp>
+#include <libs/assign/v2/test/type_traits/has_static_size.cpp>
+
+#include <boost/test/unit_test.hpp>
+using boost::unit_test::test_suite;
+test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+ test_suite* test = BOOST_TEST_SUITE( "BOOST_ASSIGN_V2" );
+ using namespace test_assign_v2;
+ {
+ namespace ns = xxx_type_traits;
+ test->add( BOOST_TEST_CASE( &ns::xxx_has_push::test ) );
+ test->add( BOOST_TEST_CASE( &ns::xxx_has_value_type::test ) );
+ test->add( BOOST_TEST_CASE( &ns::xxx_has_static_size::test ) );
+ }
+ return test;
+}
+
+#endif

Next message: ghost_at_[hidden]: "[Boost-commit] svn:boost r64610 - in trunk/tools/build/v2: . build engine/src kernel test util"
Previous message: cppljevans_at_[hidden]: "[Boost-commit] svn:boost r64608 - sandbox/variadic_templates/boost/mpl"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk