Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r57066 - in sandbox/conversion/libs/conversion/doc: . html html/boost/conversion html/boost/conversion/appendices html/boost/conversion/examples html/boost/conversion/overview html/boost/conversion/reference html/boost/conversion/users_guide
From: vicente.botet_at_[hidden]
Date: 2009-10-22 09:59:53

Author: viboes
Date: 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
New Revision: 57066
URL: http://svn.boost.org/trac/boost/changeset/57066

Log:
TBoost.conversion: v0.3 documentation
Added:
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/boost_classes_specializations.html (contents, props changed)
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/c___standard_classes_specializations.html (contents, props changed)
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/conversion_hpp.html (contents, props changed)
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/core.html (contents, props changed)
   sandbox/conversion/libs/conversion/doc/index.html (contents, props changed)
Removed:
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/array_hpp.html
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/assign_to_hpp.html
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/chrono_posix_time_hpp.html
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/complex_hpp.html
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/convert_to_hpp.html
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/interval_hpp.html
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/optional_hpp.html
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/pair_hpp.html
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/rational_hpp.html
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/string_hpp.html
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/tuple_hpp.html
Text files modified:
   sandbox/conversion/libs/conversion/doc/conversion.qbk | 494 ++++++++++++++++++++++++++++++---------
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices.html | 5
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/acknowledgements.html | 3
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/appendix_e__tests.html | 288 ++++++++++++++++++++--
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/history.html | 85 +++++-
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/implementation.html | 12
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/rationale.html | 12
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/todo.html | 61 ++++
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples.html | 7
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/boost__optional.html | 3
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/chrono__time_point_and_posix_time__ptime.html | 5
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/std__pair.html | 3
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/overview.html | 60 ++++
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/overview/motivation.html | 82 ++++--
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference.html | 56 +++-
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/users_guide/getting_started.html | 16
   sandbox/conversion/libs/conversion/doc/html/boost/conversion/users_guide/tutorial.html | 38 +-
   sandbox/conversion/libs/conversion/doc/html/index.html | 20 -
   sandbox/conversion/libs/conversion/doc/html/standalone_HTML.manifest | 15
   19 files changed, 981 insertions(+), 284 deletions(-)

Modified: sandbox/conversion/libs/conversion/doc/conversion.qbk
==============================================================================
--- sandbox/conversion/libs/conversion/doc/conversion.qbk (original)
+++ sandbox/conversion/libs/conversion/doc/conversion.qbk 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -1,4 +1,5 @@
[/
+[/
 / Copyright (c) 2008 Vicente J. Botet Escriba
 /
 / Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -55,8 +56,19 @@

[*Boost.Conversion] provides:

-* a generic convert_to function which can be specialized by the user to make explict conversion between unrelated types.
-* a generic assign_to function which can be specialized by the user to make explict assignation between unrelated types.
+* a generic __convert_to__ function which can be specialized by the user to make explict conversion between unrelated types.
+* a generic __assign_to__ function which can be specialized by the user to make explict assignation between unrelated types.
+* a generic `mca` function returning a wrapper which replace assignments by a call to `assign_to` and conversion operators by a call `convert_to`.
+* a generic `convert_to_via` function which convert a type `From` to another `To` using a temporary one `Via`.
+* conversion between `std::complex` of explicitly convertible types.
+* conversion between `std::pair` of explicitly convertible types.
+* conversion between `boost::optional` of explicitly convertible types.
+* conversion between `boost::rational` of explicitly convertible types.
+* conversion between `boost::interval` of explicitly convertible types.
+* conversion between `boost::chrono::time_point` and `boost::ptime`.
+* conversion between `boost::chrono::duration` and `boost::time_duration`.
+* conversion between `boost::array` of explicitly convertible types.
+* conversion between Boost.Fusion sequences of explicitly convertible types.

[/====================================]
[heading How to Use This Documentation]
@@ -77,46 +89,46 @@

Finally, you can mentally add the following to any code fragments in this document:

- // Include all of Conversion files
+ // Include all of the core Conversion files
 #include <boost/conversion.hpp>
+
+ using namespace boost;

[section Motivation]
-
-Imagine you need to convert unrelated types Source and Target. You can get it by defining a specific function such as
+
+Imagine you need to convert unrelated types `Source` and `Target`. You can get it by defining a specific function such as

 Target SourceToTarget(Source& v);
-
+
Imagine now that you need to convert a `std::pair<Source, Source>` to a `std::pair<Target, Target>`. Well you can again define a specific function

 std::pair<Target,Target> PairOfSourceToPairOfTarget(std::pair<Source,Source>& v) {
 return std::make_pair(SourceToTarget(v.fisrt), SourceToTarget(v.second));
 }
-
-While the SourceToTarget could be specific, the PairOfSourceToPairOfTarget sould be generic
+
+While the `SourceToTarget` could be specific, the `PairOfSourceToPairOfTarget` sould be generic

 template <typename Target1, typename Target2, typename Source1, typename Source2)
 std::pair<Target1,Target2> ConvertPair(std::pair<Source1,Source2>& v);
-
-In order to do that we need that the pair template parameters define a common function, let it call convert_to,
+
+In order to do that we need that the pair template parameters define a common function, let it call `convert_to`,

 template <typename Target, typename Source)
 Target convert_to(Source& v);
-
-so ConvertPair can be defined as
+
+so `ConvertPair` can be defined as

 template <typename Target1, typename Target2, typename Source1, typename Source2)
 std::pair<Target1,Target2> ConvertPair(std::pair<Source1,Source2>& v) {
 return std::make_pair(convert_to(v.fisrt), convert_to(v.second));
 }
-
-The issue is that we need to specialize the convert_to function for the classes Source and Target. We can do it as follows
+
+The issue is that we need to specialize the `convert_to` function for the classes `Source` and `Target`. We can do it as follows

 template <>
 Target convert_to<Target, Source>(Source& v) {return SourceToTarget(v);}
-
-What about converting std::pair<Source,std::pair<Source,Source>> to std::pair<Target,std::pair<Target,Target>>?

-The issue now is that convert_to(std::make_pair<to, std::make_pair<to,to>>) do not compiles because the conversion of std::pair is named ConvertPair. So we need to specialize the function convert_to for pairs. With C++0x there is no major problem as it allows partial specialization of function templates. With C++98, we need to use a trick; as it allows partial specialization of classes we can define convert_to by as relying to a specific function of a class, as follows:
+What about converting `std::pair<Source,std::pair<Source,Source> >` to `std::pair<Target,std::pair<Target,Target> >`? The issue now is that `convert_to(std::make_pair<to, std::make_pair<to,to> >)` do not compiles because the conversion of `std::pair` is named `ConvertPair`. So we need to specialize the function `convert_to` for pairs. There is no major problem with compilers supporting partial specialization of function templates. If this is not the case, we need to use a trick; as it allows partial specialization of classes we can define __convert_to__ by as relying to a specific function of a class, as follows:

 namespace partial_specialization_workaround {
 template < typename Target, typename Source >
@@ -130,7 +142,7 @@
 return partial_specialization_workaround::convert_to<Target,Source>::apply(val);
 }

-So now we can specialize partial_specialization_workaround::convert_to for pairs as follows:
+So now we can specialize `partial_specialization_workaround::convert_to` for pairs as follows:

 namespace partial_specialization_workaround {
 template <typename Target1, typename Target2, typename Source1, typename Source2)
@@ -156,28 +168,28 @@
 }

-What have we learned? Classes or algorithms relying on a conversion by construction or by the conversion operator can be made more generic by relaying in a function that explicitly states this conversion. So instead of requiring
+What have we learned? Classes or algorithms relying on a conversion by copy-construction or by the conversion operator can be made more generic by relaying in a function that explicitly states this conversion. Thus, instead of requiring

 Target(from)
-
+
requires

 convert_to<Target>(from)
-
+
The same applies to classes or algorithms relying on the assignment operator. So instead of requiring

 to = from

requires

- assign_to(from, to);
-
-The default implementation of assign_to relies on the assignement operator
+ assign_to(to, from);
+
+The default implementation of __assign_to__ relies on the assignement operator

 namespace partial_specialization_workaround {
 template < typename Target, typename Source >
 struct assign_to {
- inline static To& apply(const Source& from, Target& to)
+ inline static To& apply(Target& to, const Source& from)
 {
 to = from;
 return to;
@@ -185,15 +197,29 @@
 };
 }
 template < typename Target, typename Source >
- To& assign_to(const Source& from, Target& to) {
- return partial_specialization_workaround::assign_to<Target,Source>::apply(from, to);
+ To& assign_to(Target& to, const Source& from) {
+ return partial_specialization_workaround::assign_to<Target,Source>::apply(to, from);
 }
-
-For classes that are explicitly convertible and having a self assignment operator it is easy to make a specialization of assign_to as follows.
+
+For classes that are explicitly convertible and having a self assignment operator it is easy to make a specialization of __assign_to__ as follows.

 to = convert_to<Target>(from);
+
+The rationale is that if there was not a copy constructor from a Source seems reasonable to think that there will not be an assignment operator. So in most of the cases, once we have specialized the convert_to function we recover a reasonable implementation for the __assign_to__ function.
+
+When doing multiple assignements we use to do
+
+ a = b = c;

-The rationale is that if there was not a copy constructor from a Source seems reasonable to think that there will not be an assignment operator. So in most of the cases, once we have specialized the convert_to function we recover a reasonable implementation for the assign_to function.
+With __assign_to__ we could do
+
+ assign_to(a, assign_to(b, c));
+
+and if we find this not really readable we can try with
+
+ mca(a) = mca(b) = c;
+
+The behavior of mca recall the tie function of Boost.Tuple, but instead of allowing multiple assignations, allows a single assign_to call.

We can even generalize this, so classes or algorithms relying on a member function can be made more generic by relaying on a function. The default function implementation could just to call to the member function with the equivalent prototype, but this is out of the scope of this library.

@@ -219,7 +245,7 @@
[/=================================]

You can get the last stable release of Boost.Conversion by downloading [^conversion.zip] from the
-[@http://www.boost-consulting.com/vault/index.php?directory=Concurrent%20Programming Boost Vault]
+[@http://www.boostpro.com/vault/index.php?action=downloadfile&filename=conversion.zip&directory=Utilities& Boost Vault Utilities directory]

You can also access the latest (unstable?) state from the [@https://svn.boost.org/svn/boost/sandbox/conversion Boost Sandbox].

@@ -235,7 +261,7 @@
[heading Requirements]
[/=========================]

-[*Boost.Conversion] do not depends on any Boost library, at least for the generic part. Of course it dependens on the specific libraries when specific conversion are used. For these specific parts you must use either Boost version 1.39.0 or the version in SVN trunk (even if Boost version 1.35.x should works also).
+[*Boost.Conversion] do not depends on any Boost library, at least for the generic part. Of course it dependens on the specific libraries when specific conversion are used. For these specific parts you must use either Boost version 1.39.0 or the version in SVN trunk (even if Boost version 1.35.x should works also).

[/========================]
@@ -251,7 +277,6 @@

All functions in the library are thread-unsafe except when noted explicitly.

-
[/=======================]
[heading Tested compilers]
[/=======================]
@@ -278,32 +303,32 @@

[section Using generic conversions]

-When you need to make a generic explicit conversion or assignation you just need to include the file boost/conversion/convert_to.hpp or boost/conversion/assign_to.hpp and just use the boost conversion function.
+When you need to make a generic explicit conversion or assignation you just need to include the file `boost/conversion/convert_to.hpp` or `boost/conversion/assign_to.hpp` and just use the boost conversion function.
+
+ #include <boost/conversion/convert_to.hpp>

- #include <boost/conversion/std/pair.hpp>
-
 // ...
-
+
 int i = convert_to<int>(3.5);

[endsect]

[section Using specific conversions]

-When you need make a specific conversion you will need to include the specific conversion file. E.g.
+When you need to make a specific conversion you will need to include the specific conversion file. E.g.

 #include <boost/conversion/std/pair.hpp>

 std::pair<int,int> pint(0,1);
 std::pair<double,double> pdouble=boost::convert_to<std::pair<double,double> >(pint);

-Do not forget to include this files when you use a generic class or algorithm using the generic convert_to or assign_to, otherwise your program should not compile. E.g. if you want to convert a pair of chrono::time_point<> to a pair of posix_time::ptime do not forget to include in addition to the boost/conversion/std/pair.hpp the file boost/conversion/boost/chrono_posix_time.hpp
+Do not forget to include this files when you use a generic class or algorithm using the generic __convert_to__ or __assign_to__, otherwise your program should not compile. E.g. if you want to convert a pair of `chrono::time_point<>` to a pair of `posix_time::ptime` do not forget to include in addition to the `boost/conversion/std/pair.hpp` the file `boost/conversion/boost/chrono_posix_time.hpp`

[endsect]

[section How to completly specialize the conversion functions]

-You can completly specialize the convert_to and assign_to functions as you will do for other functions. Just add an complete overload. E.g. if you want to add an explicit convertion from a type F to a type T do the following:
+You can completly specialize the __convert_to__ and __assign_to__ functions as you will do for other functions. Just add an complete overload. E.g. if you want to add an explicit convertion from a type `F` to a type `T` do the following:

 T convert_to(const F& from);

@@ -311,7 +336,7 @@

[section How to partially specialize the conversion functions]

-As it has been explained in the introduction, until you use a C++ compiler supporting the new partial specialization of function templates you will need to follow partial specialization workaround and partialy specialize the partial_specialization_workaround::convert_to class.
+As it has been explained in the introduction, until you use a C++ compiler supporting the partial specialization of function templates you will need to follow partial specialization workaround and partialy specialize the `partial_specialization_workaround::convert_to` class.

[endsect]

@@ -322,7 +347,7 @@
[section:ext_references References]
[variablelist
[
- [[@http://www.boostpro.com/vault/index.php?action=downloadfile&filename=boost-string-convert.zip&directory=&
+ [[@http://www.boostpro.com/vault/index.php?action=downloadfile&filename=boost-string-convert.zip&directory=&
 [*Boost.Convert]]]
 [Vladimir Batov. Not yet scheduled]
]
@@ -345,6 +370,23 @@

[section Reference]
+
+[/==========================================================================================]
+[section:conversion_hpp Header `<boost/conversion.hpp>`]
+[/==========================================================================================]
+
+Include all the core conversion public header files. Note thatyou will need to include explicitly the C++ standard or Boost specific files when usin specific classes.
+
+ #include <boost/conversion/convert_to.hpp>
+ #include <boost/conversion/assign_to.hpp>
+ #include <boost/conversion/convert_to_via.hpp>
+ #include <boost/conversion/ca_wrapper.hpp>
+
+[endsect]
+
+[section Core]
+
+
[/==========================================================================================]
[section:convert_to_hpp Header `<boost/conversion/convert_to.hpp>`]
[/==========================================================================================]
@@ -355,17 +397,33 @@
 struct convert_to {
 static To apply(const From& val);
 };
-
- template < typename To, typename From, std::size_t N >
- struct convert_to<To[N],From[N]> {
- static To[N] apply(const From (& val)[N]);
- };
 }

 template < typename To, typename From >
- To convert_to(const From& val);
+ To convert_to(const From& from);
 }

+Defines a free function __convert_to__ which converts the `from` parameter to a `To` type. The default implementation applies the conversion `To` operator of the `From` class or the copy constructor of the `To` class. A user adapting another type could need to specialize the __convert_to__ free function if the default behavior is not satisfactory.
+
+As for the moment we can not partially specialize a function a trick is used: instead of calling directly to the __convert_to__ member function, __convert_to__ calls to the static operation `apply` on a class with the same name in the namespace __partial_specialization_workaround__. Thus the user can specialize partially this class.
+
+
+
+[section Function `convert_to()`]
+
+ template < typename To, typename From >
+ To convert_to(const From& from);
+
+[variablelist
+
+[[Effects:] [Converts the from parameter to an instance of the To type, using by default the conversion operator or copy constructor.]]
+
+[[Throws:] [Whatever the underlying conversion `To` operator of the `From` class or the copy constructor of the `To` class throws.]]
+
+]
+
+[endsect]
+
[endsect]

[/==========================================================================================]
@@ -376,21 +434,150 @@
 namespace partial_specialization_workaround {
 template < typename To, typename From >
 struct assign_to {
- static void apply(const From& from, To& to);
+ static void apply(To& toconst From& from);
 };
 template < typename To, typename From, std::size_t N >
 struct assign_to<To[N],From[N]> {
- static void apply(const From(& from)[N], To (&to)[N]);
+ static void apply(To (&to)[N], const From(& from)[N]);
 };
 }

 template < typename To, typename From >
- void assign_to(const From& from, To& to);
+ void assign_to(To& to, const From& from);
 }

+Defines a free function __assign_to__ which assigns the `from` parameter to the `to` parameter. The default implementation applies the the assignement operator of the `To` class. A user adapting another type could need to specialize the __assign_to__ free function if the default behavior is not satisfactory.
+
+As for the moment we can not partially specialize a function a trick is used: instead of calling directly to the __assign_to__ member function, __assign_to__ calls to the static operation apply on a class with the same name in the namespace __partial_specialization_workaround__.
+This the user can specialize partially this class.
+
+[section Function `assign_to()`]
+
+ template < typename To, typename From >
+ void assign_to(To& to, const From& from);
+
+[variablelist
+
+[[Effects:] [Assigns the `from` parameter to the `to` parameter, using by default the assignement operator of the `To` class.]]
+
+[[Throws:] [Whatever the underlying the assignement operator of the `To` class throws.]]
+
+]
+
+[endsect]
+
[endsect]

[/==========================================================================================]
+[section:convert_to_via_hpp Header `<boost/conversion/convert_to_via.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+
+ template < typename To, typename Via, typename From >
+ To convert_to_via(const From& val) {
+ convert_to<To>(convert_to<Via>(val));
+ }
+ }
+
+[section Function `convert_to_via<>()`]
+
+[variablelist
+
+[[Effects:] [Converts the from parameter to an instance of the To type using a intermediary Via type.]]
+
+[[Throws:] [Whatever the underlying conversions functions throws.]]
+
+]
+
+[endsect]
+[endsect]
+
+[/==========================================================================================]
+[section:ca_wrapper_hpp Header `<boost/conversion/ca_wrapper.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+
+ template <typename T> class ca_wrapper;
+ template <typename T> ca_wrapper<T> mca(T& r);
+ }
+
+[section Template Class `ca_wrapper<>`]
+
+ template <typename T>
+ class ca_wrapper {
+ public:
+ ca_wrapper(T& r);
+ template <typename U> operator U();
+ template <typename U> T& operator =(U const& u);
+ };
+
+[section Constructor]
+
+ ca_wrapper(T& r);
+
+[variablelist
+
+[[Effects:] [Stores the reference to type.]]
+
+[[Throws:] [Nothing]]
+
+]
+
+[endsect]
+
+[section Conversion operator]
+
+ template <typename U> operator U();
+
+[variablelist
+
+[[Effects:] [Call to the `convert_to` on the stored reference.]]
+
+[[Throws:] [Whatever __convert_to__ throws.]]
+
+]
+
+[endsect]
+
+[section Assignement operator]
+
+ template <typename U> T& operator =(U const& u);
+
+[variablelist
+
+[[Effects:] [Call to the `assignt_to<T,U>` with the stored reference and the passed parameter `u`.]]
+
+[[Throws:] [Whatever __assign_to__ throws.]]
+
+]
+
+[endsect]
+
+
+[endsect]
+
+[section Function `mca<>()`]
+
+ template <typename T> ca_wrapper<T> mca(T& r);
+
+[variablelist
+
+[[Effects:] [Creates a ca_wrapper.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+[endsect]
+
+[endsect]
+
+[section C++ Standard classes specializations]
+
+[/==========================================================================================]
[section:complex_hpp Header `<boost/conversion/std/complex.hpp>`]
[/==========================================================================================]

@@ -425,7 +612,7 @@
 };
 template < class T1, class T2, class U1, class U2>
 struct assign_to< std::pair<T1,T2>, std::pair<U1,U2> > {
- static std::pair<T1,T2>& apply(const std::pair<U1,U2>& from, std::pair<T1,T2>& to);
+ static std::pair<T1,T2>& apply(std::pair<T1,T2>& to, const std::pair<U1,U2>& from);
 };
 }
 }
@@ -446,7 +633,7 @@
 template<typename T, typename CharT, typename Traits, typename Alloc>
 struct assign_to< std::basic_string<CharT,Traits,Alloc>, T > {
 static std::basic_string<CharT,Traits,Alloc>& apply(
- const T& from, std::basic_string<CharT,Traits,Alloc>& to);
+ std::basic_string<CharT,Traits,Alloc>& to, const T& from);
 };
 template<typename T, typename CharT, typename Traits, typename Alloc>
 struct convert_to< T, std::basic_string<CharT,Traits,Alloc>> {
@@ -454,13 +641,17 @@
 };
 template<typename T, typename CharT, typename Traits, typename Alloc>
 struct assign_to< T, std::basic_string<CharT,Traits,Alloc>> {
- static void apply(
- const std::basic_string<CharT,Traits,Alloc>& from, T& to);
+ static void apply(T& to
+ const std::basic_string<CharT,Traits,Alloc>& from);
 };
 }
 }

[endsect]
+[endsect]
+
+[section Boost classes specializations]
+
[/==========================================================================================]
[section:rational_hpp Header `<boost/conversion/boost/rational.hpp>`]
[/==========================================================================================]
@@ -475,7 +666,7 @@
 };
 template < class T, class U>
 struct assign_to< rational<T>, rational > {
- inline static rational<T>& apply(const rational& from, rational<T>& to);
+ inline static rational<T>& apply(rational<T>& to, const rational& from);
 };
 }
 }
@@ -495,10 +686,11 @@
 chrono::duration<Rep, Period> const & from);
 };
 template < class Rep, class Period>
- struct assign_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
+ struct assign_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
 static posix_time::time_duration& apply(
- const chrono::duration<Rep, Period>& from,
- posix_time::time_duration& to);
+ posix_time::time_duration& to,
+ const chrono::duration<Rep, Period>& from
+ );
 };

 template < class Rep, class Period>
@@ -508,8 +700,8 @@
 template < class Rep, class Period>
 struct assign_to<chrono::duration<Rep, Period>, posix_time::time_duration> {
 static chrono::duration<Rep, Period> & apply(
- const posix_time::time_duration& from,
- chrono::duration<Rep, Period> & to);
+ chrono::duration<Rep, Period> & to,
+ const posix_time::time_duration& from);
 };
 }
 }
@@ -522,11 +714,10 @@
 };
 template < class Clock, class Duration>
 struct assign_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
- static posix_time::ptime& apply(
- const chrono::time_point<Clock, Duration>& from,
- posix_time::ptime& to);
+ static posix_time::ptime& apply(posix_time::ptime& to,
+ const chrono::time_point<Clock, Duration>& from);
 };
-
+
 template < class Clock, class Duration>
 struct convert_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
 static chrono::time_point<Clock, Duration> apply(const posix_time::ptime& from);
@@ -534,8 +725,8 @@
 template < class Clock, class Duration>
 struct assign_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
 static chrono::time_point<Clock, Duration>& apply(
- const posix_time::ptime& from,
- chrono::time_point<Clock, Duration>& to);
+ chrono::time_point<Clock, Duration>& to,
+ const posix_time::ptime& from);
 };
 }
 }
@@ -556,7 +747,7 @@
 template < class T, class PT, class U, class PU>
 struct assign_to< interval<T,PT>, interval<U,PU> > {
 static interval<T,PT>& apply(
- const interval<U,PU>& from, interval<T,PT>& to);
+ interval<T,PT>& to, const interval<U,PU>& from);
 };

 }
@@ -578,7 +769,7 @@
 template < class Target, class Source>
 struct assign_to< optional<Target>, optional<Source> > {
 static optional<Target>& apply(
- const optional<Target>& from, optional<Target>& to);
+ optional<Target>& to, const optional<Target>& from);
 };

 }
@@ -597,11 +788,11 @@
 namespace partial_specialization_workaround {
 template < typename T1, typename T2, std::size_t N>
 struct convert_to< array<T1,N>, array<T2,N> > {
- inline static array<T1,N> apply(array<T2,N> const & from);
+ static array<T1,N> apply(array<T2,N> const & from);
 };
 template < typename T1, typename T2, std::size_t N>
- struct assign_to< array<T1,N>, array<T2,N> > {
- inline static array<T1,N>& apply(array<T2,N> const & from, array<T1,N>& to);
+ struct assign_to< array<T1,N>, array<T2,N> > {
+ static array<T1,N>& apply(array<T1,N>& to, array<T2,N> const & from);
 };
 }
 }
@@ -619,13 +810,13 @@
 namespace partial_specialization_workaround {
 template < class T1, ..., class Tn, class U1, ..., class Un>
 struct convert_to< boost::fusion::tuple<T1,...,T3>, boost::fusion::tuple<U1,...,U3> > {
- inline static boost::fusion::tuple<T1,...,T3>
+ inline static boost::fusion::tuple<T1,...,T3>
 apply(boost::fusion::tuple<U1,...,U3> const & from);
 };
 template < class T1, ..., class Tn, class U1, ..., class Un>
 struct assign_to< boost::fusion::tuple<T1,...,T3>, boost::fusion::tuple<U1,...,U3> > {
- inline static boost::fusion::tuple<T1,...,T3>
- apply(boost::fusion::tuple<U1,...,U3> const & from, boost::fusion::tuple<T1,...,T3>& to);
+ inline static boost::fusion::tuple<T1,...,T3>
+ apply(boost::fusion::tuple<T1,...,T3>& to, boost::fusion::tuple<U1,...,U3> const & from);
 };

 }
@@ -633,6 +824,7 @@

[endsect]
[endsect]
+[endsect]

[section Examples]
[section chrono::time_point and posix_time::ptime]
@@ -653,11 +845,30 @@
[section Appendices]
[/=================]
[section:history Appendix A: History]
+[section [*Version 0.3.0, Oct 22, 2009] ['Changing the order of `to` and `from` parameters on __assign_to__ + Added `mca' function]]
+
+[*Incopatibility:]
+
+* Changing the order of `to` and `from` parameters on __assign_to__.
+* Now `boost/conversion/convert_to.hpp` and `boost/conversion/assign_to.hpp` files are separated.
+
+[*New Features:]
+
+* Added <boost/conversion.hpp> global file.
+* Added `mca()` function.
+* Added `convert_to_via` function.
+
+[*Test:]
+
+* Added test for the new features
+
+
+[endsect]
[section [*Version 0.2.0, Mai 16, 2009] ['Adding array + fusion::tuples + Adaptation to Boost 1.39]]

[*New Features:]

-* conversion between boost::array of explicitly convertible types.
+* conversion between `boost::array` of explicitly convertible types.
* conversion between Boost.Fusion sequences of explicitly convertible types.

[endsect]
@@ -666,20 +877,20 @@

[*Features:]

-* a generic convert_to function which can be specialized by the user to make explict conversion between unrelated types.
-* a generic assign_to function which can be specialized by the user to make explict assignation between unrelated types.
+* a generic __convert_to__ function which can be specialized by the user to make explict conversion between unrelated types.
+* a generic __assign_to__ function which can be specialized by the user to make explict assignation between unrelated types.
* conversion between C-arrays of explicitly convertible types.

-* conversion between std::complex of explicitly convertible types.
-* conversion between std::pair of explicitly convertible types.
-* conversion between std::string and Streamable types.
-
-* conversion between boost::optional of explicitly convertible types.
-* conversion between boost::rational of explicitly convertible types.
-* conversion between boost::interval of explicitly convertible types.
+* conversion between `std::complex` of explicitly convertible types.
+* conversion between `std::pair` of explicitly convertible types.
+* conversion between `std::string` and Streamable types.
+
+* conversion between `boost::optional` of explicitly convertible types.
+* conversion between `boost::rational` of explicitly convertible types.
+* conversion between `boost::interval` of explicitly convertible types.

-* conversion between boost::chrono::time_point and boost::ptime.
-* conversion between boost::chrono::duration and boost::time_duration.
+* conversion between `boost::chrono::time_point` and `boost::ptime`.
+* conversion between `boost::chrono::duration` and `boost::time_duration`.

[endsect]
[endsect]
@@ -694,18 +905,18 @@
 B b;
 C c;

-* Reflexive: A is convertible to A if it is CopyConstructible
+* Reflexive: A is convertible to A if it is CopyConstructible or a specialization of convert_to is provided.

-* Symetric : A convertible to B implies B convertible to C
+* AntiSymetric : A convertible to B don't implies B convertible to A

* Loss of precission: Conversions can loss precission but not at infinitum

-Two convertible types don't loss precission if
+Two convertible types don't loss precission if

 b = convert_to(a);
 a2 = convert_to<A>(b);
 assert(a==a2);
-
+
If they can loss precission they satisfy

 b = convert_to(a)
@@ -721,7 +932,7 @@
 return convert_to<A>(convert_to(c));
 }

-
+The library provides a convert_to_via function which helps to implement that.

[heading Why use partial function specialization and not ADL?]

@@ -730,26 +941,29 @@

[section:implementation Appendix C: Implementation Notes]

-[heading Why `convert_to` between tuples is not be implemented using `boost::fusion::transform`?]
+[heading Why `convert_to` between tuples is not implemented using `boost::fusion::transform`?]

-`convert_to<T>` is a kind of transaformation, so the natural implementation of convert_to for homegeneus containers could be to use the transform function.
+`convert_to<T>` is a kind of transaformation, so the natural implementation of `convert_to` for homegeneus containers could be to use the transform function.

This can not be applied to heterogeneus containers as tuples because the function change with the type.

-
[endsect]
[section:acknowledgements Appendix D: Acknowledgements]

Thanks to Vladimir Batov proposing Boost.StringConversion which was the source of inspiration of this generic library.
+Thanks to Edward Diener to showing me indirectly that multiple assignements should be taken in account.

[endsect]
[section Appendix E: Tests]

[section Builtins]
[table
- [[Name] [kind] [Description] [Result] [Ticket]]
- [[convert_to_with_builtin_types] [run] [check convert_to works for builting types] [Pass] [#]]
- [[assign_to_with_builtin_types] [run] [check assign_to works for builting types] [Pass] [#]]
+ [[Name] [kind] [Description] [Result] [Ticket]]
+ [[convert_to_with_builtin_types] [run] [check `convert_to` works for builting types] [Pass] [#]]
+ [[assign_to_with_builtin_types] [run] [check `assign_to` works for builting types] [Pass] [#]]
+ [[assign_to_transitive] [run] [Use of `assign_to` transitively] [Pass] [#]]
+ [[mca_assign_to_with_builtin_types] [run] [check `mca` `works` for builting types] [Pass] [#]]
+ [[mca_assign_to_transitive] [run] [use of `mca` to multiple assignements] [Pass] [#]]
]
[endsect]

@@ -757,45 +971,49 @@
[section Intrinsec Conversions]
[table
 [[Name] [kind] [Description] [Result] [Ticket]]
- [[convert_to_with_implicit_constructor] [run] [check convert_to works when there is an implicit constructor] [Pass] [#]]
- [[convert_to_with_explicit_constructor] [run] [check convert_to works when there is an explicit constructor] [Pass] [#]]
- [[convert_to_with_conversion_operator] [run] [check assign_to works when there is an conversion operator] [Pass] [#]]
- [[assign_to_with_assignemet_operator] [run] [check assign_to works when there is an assignement operator] [Pass] [#]]
- [[assign_to_with_assignemet_operator_and_implicit_constructor] [run] [check assign_to works when there is an assignemet operator and implicit constructor] [Pass] [#]]
- [[assign_to_with_assignemet_operator_and_conversion_operator] [run] [check convert_to works when there is an assignemet operator and a conversion operator] [Pass] [#]]
+ [[convert_to_with_implicit_constructor] [run] [check `convert_to` works when there is an implicit constructor] [Pass] [#]]
+ [[convert_to_with_explicit_constructor] [run] [check `convert_to` works when there is an explicit constructor] [Pass] [#]]
+ [[convert_to_with_conversion_operator] [run] [check `assign_to` works when there is an conversion operator] [Pass] [#]]
+ [[assign_to_with_assignemet_operator] [run] [check `assign_to` works when there is an assignement operator] [Pass] [#]]
+ [[assign_to_with_assignemet_operator_and_implicit_constructor] [run] [check `assign_to` works when there is an assignemet operator and implicit constructor] [Pass] [#]]
+ [[assign_to_with_assignemet_operator_and_conversion_operator] [run] [check `convert_to` works when there is an assignemet operator and a conversion operator] [Pass] [#]]
+ [[mca_with_assignemet_operator] [run] [check `mca` works when there is an assignement operator] [Pass] [#]]
+ [[mca_with_assignemet_operator_and_implicit_constructor] [run] [check `mca` works when there is an assignemet operator and implicit constructor] [Pass] [#]]
+ [[mca_with_assignemet_operator_and_conversion_operator] [run] [check `mca` works when there is an assignemet operator and a conversion operator] [Pass] [#]]
]
[endsect]

-[section Extrinsec Conversions]
+[section Extrinsic Conversions]
[table
 [[Name] [kind] [Description] [Result] [Ticket]]
- [[explicit_convert_to] [run] [check convert_to works when convert_to is overloaded] [Pass] [#]]
- [[explicit_assign_to] [run] [check assign_to works when assign_to is overloaded] [Pass] [#]]
+ [[explicit_convert_to] [run] [check `convert_to` works when `convert_to` is overloaded] [Pass] [#]]
+ [[explicit_assign_to] [run] [check `assign_to` works when `assign_to` is overloaded] [Pass] [#]]
+ [[explicit_mca] [run] [check `mca` works when `assign_to` is overloaded] [Pass] [#]]
]
[endsect]

[section STD]
[table
 [[Name] [kind] [Description] [Result] [Ticket]]
- [[convert_to_pair] [run] [check convert_to pair works when the parameters are convertible] [Pass] [#]]
- [[convert_to_complex] [run] [check convert_to complex works when the parameters are convertible] [Pass] [#]]
- [[convert_to_string] [run] [check convert_to string works when the parameter defines the operator<<] [Pass] [#]]
- [[convert_from_string] [run] [check convert_to from string works when the parameter defines the operator>>] [Pass] [#]]
+ [[convert_to_pair] [run] [check `convert_to` `std::pair` works when the parameters are convertible] [Pass] [#]]
+ [[convert_to_complex] [run] [check `convert_to` `std::complex` works when the parameters are convertible] [Pass] [#]]
+ [[convert_to_string] [run] [check `convert_to` `std::string` works when the parameter defines the `operator<<`] [Pass] [#]]
+ [[convert_from_string] [run] [check `convert_to` from `std::string` works when the parameter defines the `operator>>`] [Pass] [#]]
]
[endsect]

[section Boost]
[table
 [[Name] [kind] [Description] [Result] [Ticket]]
- [[convert_to_rational] [run] [check convert_to rational works when the parameters are convertible] [Pass] [#]]
- [[convert_to_interval] [run] [check convert_to interval works when the parameters are convertible] [Pass] [#]]
- [[convert_to_optional] [run] [check convert_to optional works when the parameters are convertible] [Pass] [#]]
- [[convert_to_time_point] [run] [check convert_to time_point from ptime works] [Pass] [#]]
- [[convert_to_ptime] [run] [check convert_to ptime from time_point works] [Pass] [#]]
- [[convert_to_duration] [run] [check convert_to duration from time_duration works] [Pass] [#]]
- [[convert_to_time_duration] [run] [check convert_to time_duration from duration works] [Pass] [#]]
- [[convert_to_array] [run] [check convert_to array works when the parameters are convertible] [Pass] [#]]
- [[convert_to_tuple] [run] [check convert_to tuple works when the parameters are convertible] [Pass] [#]]
+ [[convert_to_rational] [run] [check `convert_to` `boost::rational` works when the parameters are convertible] [Pass] [#]]
+ [[convert_to_interval] [run] [check `convert_to` `boost::interval` works when the parameters are convertible] [Pass] [#]]
+ [[convert_to_optional] [run] [check `convert_to` `boost::optional` works when the parameters are convertible] [Pass] [#]]
+ [[convert_to_time_point] [run] [check `convert_to` `boost::chrono::system_clock::time_point` from boost::posix_time::ptime works] [Pass] [#]]
+ [[convert_to_ptime] [run] [check `convert_to` `boost::posix_time::ptime` from boost::chrono::system_clock::time_point works] [Pass] [#]]
+ [[convert_to_duration] [run] [check `convert_to` `boost::chrono::duration` from `boost::posix_time::time_duration` works] [Pass] [#]]
+ [[convert_to_time_duration] [run] [check `convert_to` `boost::posix_time::time_duration` from `boost::chrono::duration` works] [Pass] [#]]
+ [[convert_to_array] [run] [check `convert_to` `boost::array` works when the parameters are convertible] [Pass] [#]]
+ [[convert_to_tuple] [run] [check `convert_to` `boost::tuple` works when the parameters are convertible] [Pass] [#]]
]
[endsect]

@@ -810,14 +1028,46 @@

[heading Tasks to do before review]

-* conversion between std::vector of explicitly convertible types.
+* On compilers supporting partial template functions specialization no use of the workarround.
+* Add conversion between std::vector of explicitly convertible types.
+* Add a is_convertible_to metafunction. Inherits: If an imaginary lvalue of type From is convertible to type To using convert_to then inherits from true_type, otherwise inherits from false_type.
+
+ template <class From, class To>
+ struct is_convertible : public true_type-or-false_type {};
+
+* Add a is_asignable_to metafunction.

[heading For later releases]

-
* conversion between types for which lexical_cast works.
* conversion between types for which numeric_cast works.

+[heading Make a proposal to the C++ standard]
+
+C++1x has added explicit conversion operators, but they must always be defined in the Source class. The same applies to the assignement operator, it must be defined on the Target class.
+
+It will be interesting to be able to implicitly or explicitly add extrinsic conversion operators between unrelated types. Assignement operators could also be specialized.
+
+ template < typename To, typename From >
+ operator To(const From& val);
+
+ template < typename To, typename From >
+ To& operator=(To& to, const From& from);
+
+For example we could specialize this the conversion from as chrono::time_point<Clock, Duration> to posix_time::ptime follows
+
+ template < class Clock, class Duration>
+ operator boost::posix_time::ptime(const boost::chrono::time_point<Clock, Duration>& from) {
+ typedef boost::chrono::time_point<Clock, Duration> time_point_t;
+ typedef boost::chrono::nanoseconds duration_t;
+ typedef boost::duration_t::rep rep_t;
+ rep_t d = boost::chrono::duration_cast<duration_t>(from.time_since_epoch()).count();
+ rep_t sec = d/1000000000;
+ rep_t nsec = d%1000000000;
+ return boost::posix_time::from_time_t(0)+
+ boost::posix_time::seconds(static_cast<long>(sec))+
+ boost::posix_time::nanoseconds(nsec);
+ }

[endsect]
[endsect]

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -29,6 +29,9 @@
<div class="toc"><dl>
<dt> Appendix A: History</dt>
<dd><dl>
+<dt><a href="appendices/history.html#boost.conversion.appendices.history.__version_0_3_0__oct_22__2009____changing_the_order_of__to__and__from__parameters_on___assign_to_____added__mca__function_">Version 0.3.0, Oct 22, 2009 Changing the
+ order of <code class="computeroutput">to</code> and <code class="computeroutput">from</code> parameters on <code class="computeroutput">assign_to</code>
+ + Added `mca' function</a></dt>
<dt><a href="appendices/history.html#boost.conversion.appendices.history.__version_0_2_0__mai_16__2009____adding_array___fusion__tuples___adaptation_to_boost_1_39_">Version 0.2.0, Mai 16, 2009 Adding array
 + fusion::tuples + Adaptation to Boost 1.39</a></dt>
<dt><a href="appendices/history.html#boost.conversion.appendices.history.__version_0_1_0__april_16__2009____announcement_of_conversions_">Version 0.1.0, April 16, 2009 Announcement
@@ -45,7 +48,7 @@
<dt>Builtins</dt>
<dt><a href="appendices/appendix_e__tests.html#boost.conversion.appendices.appendix_e__tests.intrinsec_conversions">Intrinsec
 Conversions</a></dt>
-<dt><a href="appendices/appendix_e__tests.html#boost.conversion.appendices.appendix_e__tests.extrinsec_conversions">Extrinsec
+<dt><a href="appendices/appendix_e__tests.html#boost.conversion.appendices.appendix_e__tests.extrinsic_conversions">Extrinsic
 Conversions</a></dt>
<dt>STD</dt>
<dt>Boost</dt>

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/acknowledgements.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/acknowledgements.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/acknowledgements.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -33,7 +33,8 @@
</h3></div></div></div>

Thanks to Vladimir Batov proposing Boost.StringConversion which was the source
- of inspiration of this generic library.
+ of inspiration of this generic library. Thanks to Edward Diener to showing
+ me indirectly that multiple assignements should be taken in account.

</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/appendix_e__tests.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/appendix_e__tests.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/appendix_e__tests.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -35,7 +35,7 @@
<dt>Builtins</dt>
<dt><a href="appendix_e__tests.html#boost.conversion.appendices.appendix_e__tests.intrinsec_conversions">Intrinsec
 Conversions</a></dt>
-<dt><a href="appendix_e__tests.html#boost.conversion.appendices.appendix_e__tests.extrinsec_conversions">Extrinsec
+<dt><a href="appendix_e__tests.html#boost.conversion.appendices.appendix_e__tests.extrinsic_conversions">Extrinsic
 Conversions</a></dt>
<dt>STD</dt>
<dt>Boost</dt>
@@ -93,7 +93,8 @@
 </td>
<td>
 
- check convert_to works for builting types
+ check <code class="computeroutput">convert_to</code>
+ works for builting types
 
 </td>
<td>
@@ -120,7 +121,91 @@
 </td>
<td>
 
- check assign_to works for builting types
+ check <code class="computeroutput">assign_to</code>
+ works for builting types
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ assign_to_transitive
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ Use of <code class="computeroutput">assign_to</code>
+ transitively
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ mca_assign_to_with_builtin_types
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">mca</code> <code class="computeroutput">works</code> for builting types
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ mca_assign_to_transitive
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ use of <code class="computeroutput">mca</code> to multiple
+ assignements
 
 </td>
<td>
@@ -192,7 +277,8 @@
 </td>
<td>
 
- check convert_to works when there is an implicit constructor
+ check <code class="computeroutput">convert_to</code>
+ works when there is an implicit constructor
 
 </td>
<td>
@@ -219,7 +305,8 @@
 </td>
<td>
 
- check convert_to works when there is an explicit constructor
+ check <code class="computeroutput">convert_to</code>
+ works when there is an explicit constructor
 
 </td>
<td>
@@ -246,7 +333,8 @@
 </td>
<td>
 
- check assign_to works when there is an conversion operator
+ check <code class="computeroutput">assign_to</code>
+ works when there is an conversion operator
 
 </td>
<td>
@@ -273,7 +361,8 @@
 </td>
<td>
 
- check assign_to works when there is an assignement operator
+ check <code class="computeroutput">assign_to</code>
+ works when there is an assignement operator
 
 </td>
<td>
@@ -300,8 +389,8 @@
 </td>
<td>
 
- check assign_to works when there is an assignemet operator and
- implicit constructor
+ check <code class="computeroutput">assign_to</code>
+ works when there is an assignemet operator and implicit constructor
 
 </td>
<td>
@@ -328,8 +417,92 @@
 </td>
<td>
 
- check convert_to works when there is an assignemet operator and
- a conversion operator
+ check <code class="computeroutput">convert_to</code>
+ works when there is an assignemet operator and a conversion operator
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ mca_with_assignemet_operator
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">mca</code> works
+ when there is an assignement operator
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ mca_with_assignemet_operator_and_implicit_constructor
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">mca</code> works
+ when there is an assignemet operator and implicit constructor
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ mca_with_assignemet_operator_and_conversion_operator
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">mca</code> works
+ when there is an assignemet operator and a conversion operator
 
 </td>
<td>
@@ -348,8 +521,8 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="boost.conversion.appendices.appendix_e__tests.extrinsec_conversions"></a><a href="appendix_e__tests.html#boost.conversion.appendices.appendix_e__tests.extrinsec_conversions" title="Extrinsec
- Conversions">Extrinsec
+<a name="boost.conversion.appendices.appendix_e__tests.extrinsic_conversions"></a><a href="appendix_e__tests.html#boost.conversion.appendices.appendix_e__tests.extrinsic_conversions" title="Extrinsic
+ Conversions">Extrinsic
 Conversions</a>
</h4></div></div></div>
<div class="informaltable"><table class="table">
@@ -401,7 +574,9 @@
 </td>
<td>
 
- check convert_to works when convert_to is overloaded
+ check <code class="computeroutput">convert_to</code>
+ works when <code class="computeroutput">convert_to</code>
+ is overloaded
 
 </td>
<td>
@@ -428,7 +603,38 @@
 </td>
<td>
 
- check assign_to works when assign_to is overloaded
+ check <code class="computeroutput">assign_to</code>
+ works when <code class="computeroutput">assign_to</code>
+ is overloaded
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ explicit_mca
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">mca</code> works
+ when <code class="computeroutput">assign_to</code>
+ is overloaded
 
 </td>
<td>
@@ -498,7 +704,9 @@
 </td>
<td>
 
- check convert_to pair works when the parameters are convertible
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">std::pair</code> works when the parameters
+ are convertible
 
 </td>
<td>
@@ -525,7 +733,9 @@
 </td>
<td>
 
- check convert_to complex works when the parameters are convertible
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">std::complex</code> works when the parameters
+ are convertible
 
 </td>
<td>
@@ -552,7 +762,9 @@
 </td>
<td>
 
- check convert_to string works when the parameter defines the operator<<
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">std::string</code> works when the parameter
+ defines the <code class="computeroutput">operator<<</code>
 
 </td>
<td>
@@ -579,8 +791,9 @@
 </td>
<td>
 
- check convert_to from string works when the parameter defines the
- operator>>
+ check <code class="computeroutput">convert_to</code>
+ from <code class="computeroutput">std::string</code> works when the parameter
+ defines the <code class="computeroutput">operator>></code>
 
 </td>
<td>
@@ -650,7 +863,9 @@
 </td>
<td>
 
- check convert_to rational works when the parameters are convertible
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::rational</code> works when the parameters
+ are convertible
 
 </td>
<td>
@@ -677,7 +892,9 @@
 </td>
<td>
 
- check convert_to interval works when the parameters are convertible
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::interval</code> works when the parameters
+ are convertible
 
 </td>
<td>
@@ -704,7 +921,9 @@
 </td>
<td>
 
- check convert_to optional works when the parameters are convertible
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::optional</code> works when the parameters
+ are convertible
 
 </td>
<td>
@@ -731,7 +950,9 @@
 </td>
<td>
 
- check convert_to time_point from ptime works
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::chrono::system_clock::time_point</code> from boost::posix_time::ptime
+ works
 
 </td>
<td>
@@ -758,7 +979,9 @@
 </td>
<td>
 
- check convert_to ptime from time_point works
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::posix_time::ptime</code> from boost::chrono::system_clock::time_point
+ works
 
 </td>
<td>
@@ -785,7 +1008,9 @@
 </td>
<td>
 
- check convert_to duration from time_duration works
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::chrono::duration</code> from <code class="computeroutput">boost::posix_time::time_duration</code>
+ works
 
 </td>
<td>
@@ -812,7 +1037,8 @@
 </td>
<td>
 
- check convert_to time_duration from duration works
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::posix_time::time_duration</code> from <code class="computeroutput">boost::chrono::duration</code> works
 
 </td>
<td>
@@ -839,7 +1065,9 @@
 </td>
<td>
 
- check convert_to array works when the parameters are convertible
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::array</code> works when the parameters
+ are convertible
 
 </td>
<td>
@@ -866,7 +1094,9 @@
 </td>
<td>
 
- check convert_to tuple works when the parameters are convertible
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::tuple</code> works when the parameters
+ are convertible
 
 </td>
<td>

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/history.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/history.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/history.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -27,6 +27,9 @@
<a name="boost.conversion.appendices.history"></a> Appendix A: History
</h3></div></div></div>
<div class="toc"><dl>
+<dt><a href="history.html#boost.conversion.appendices.history.__version_0_3_0__oct_22__2009____changing_the_order_of__to__and__from__parameters_on___assign_to_____added__mca__function_">Version 0.3.0, Oct 22, 2009 Changing the
+ order of <code class="computeroutput">to</code> and <code class="computeroutput">from</code> parameters on <code class="computeroutput">assign_to</code>
+ + Added `mca' function</a></dt>
<dt><a href="history.html#boost.conversion.appendices.history.__version_0_2_0__mai_16__2009____adding_array___fusion__tuples___adaptation_to_boost_1_39_">Version 0.2.0, Mai 16, 2009 Adding array
 + fusion::tuples + Adaptation to Boost 1.39</a></dt>
<dt><a href="history.html#boost.conversion.appendices.history.__version_0_1_0__april_16__2009____announcement_of_conversions_">Version 0.1.0, April 16, 2009 Announcement
@@ -34,6 +37,51 @@
</dl></div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.history.__version_0_3_0__oct_22__2009____changing_the_order_of__to__and__from__parameters_on___assign_to_____added__mca__function_"></a><a href="history.html#boost.conversion.appendices.history.__version_0_3_0__oct_22__2009____changing_the_order_of__to__and__from__parameters_on___assign_to_____added__mca__function_" title="Version 0.3.0, Oct 22, 2009 Changing the
+ order of to and from parameters on assign_to
+ + Added `mca' function">Version 0.3.0, Oct 22, 2009 Changing the
+ order of <code class="computeroutput">to</code> and <code class="computeroutput">from</code> parameters on <code class="computeroutput">assign_to</code>
+ + Added `mca' function</a>
+</h4></div></div></div>
+
+ Incopatibility:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Changing the order of <code class="computeroutput">to</code>
+ and <code class="computeroutput">from</code> parameters on
+ <code class="computeroutput">assign_to</code>.
+ </li>
+<li>
+ Now <code class="computeroutput">boost/conversion/convert_to.hpp</code> and <code class="computeroutput">boost/conversion/assign_to.hpp</code>
+ files are separated.
+ </li>
+</ul></div>
+
+ New Features:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Added <boost/conversion.hpp> global file.
+ </li>
+<li>
+ Added <code class="computeroutput">mca()</code>
+ function.
+ </li>
+<li>
+ Added <code class="computeroutput">convert_to_via</code>
+ function.
+ </li>
+</ul></div>
+
+ Test:
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ Added test for the new features
+ </li></ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
<a name="boost.conversion.appendices.history.__version_0_2_0__mai_16__2009____adding_array___fusion__tuples___adaptation_to_boost_1_39_"></a><a href="history.html#boost.conversion.appendices.history.__version_0_2_0__mai_16__2009____adding_array___fusion__tuples___adaptation_to_boost_1_39_" title="Version 0.2.0, Mai 16, 2009 Adding array
 + fusion::tuples + Adaptation to Boost 1.39">Version 0.2.0, Mai 16, 2009 Adding array
 + fusion::tuples + Adaptation to Boost 1.39</a>
@@ -43,7 +91,8 @@
 
<div class="itemizedlist"><ul type="disc">
<li>
- conversion between boost::array of explicitly convertible types.
+ conversion between <code class="computeroutput">boost::array</code>
+ of explicitly convertible types.
 </li>
<li>
 conversion between Boost.Fusion sequences of explicitly convertible types.
@@ -61,39 +110,49 @@
 
<div class="itemizedlist"><ul type="disc">
<li>
- a generic convert_to function which can be specialized by the user to
- make explict conversion between unrelated types.
+ a generic <code class="computeroutput">convert_to</code>
+ function which can be specialized by the user to make explict conversion
+ between unrelated types.
 </li>
<li>
- a generic assign_to function which can be specialized by the user to
- make explict assignation between unrelated types.
+ a generic <code class="computeroutput">assign_to</code> function
+ which can be specialized by the user to make explict assignation between
+ unrelated types.
 </li>
<li>
 conversion between C-arrays of explicitly convertible types.
 </li>
<li>
- conversion between std::complex of explicitly convertible types.
+ conversion between <code class="computeroutput">std::complex</code>
+ of explicitly convertible types.
 </li>
<li>
- conversion between std::pair of explicitly convertible types.
+ conversion between <code class="computeroutput">std::pair</code>
+ of explicitly convertible types.
 </li>
<li>
- conversion between std::string and Streamable types.
+ conversion between <code class="computeroutput">std::string</code>
+ and Streamable types.
 </li>
<li>
- conversion between boost::optional of explicitly convertible types.
+ conversion between <code class="computeroutput">boost::optional</code>
+ of explicitly convertible types.
 </li>
<li>
- conversion between boost::rational of explicitly convertible types.
+ conversion between <code class="computeroutput">boost::rational</code>
+ of explicitly convertible types.
 </li>
<li>
- conversion between boost::interval of explicitly convertible types.
+ conversion between <code class="computeroutput">boost::interval</code>
+ of explicitly convertible types.
 </li>
<li>
- conversion between boost::chrono::time_point and boost::ptime.
+ conversion between <code class="computeroutput">boost::chrono::time_point</code>
+ and <code class="computeroutput">boost::ptime</code>.
 </li>
<li>
- conversion between boost::chrono::duration and boost::time_duration.
+ conversion between <code class="computeroutput">boost::chrono::duration</code>
+ and <code class="computeroutput">boost::time_duration</code>.
 </li>
</ul></div>
</div>

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/implementation.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/implementation.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/implementation.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -30,16 +30,16 @@
 C: Implementation Notes"> Appendix
 C: Implementation Notes</a>
</h3></div></div></div>
-<a name="boost.conversion.appendices.implementation.why__code__phrase_role__identifier__convert_to__phrase___code__between_tuples_is_not_be_implemented_using__code__phrase_role__identifier__boost__phrase__phrase_role__special______phrase__phrase_role__identifier__fusion__phrase__phrase_role__special______phrase__phrase_role__identifier__transform__phrase___code__"></a><h4>
-<a name="id4826820"></a>
- <a href="implementation.html#boost.conversion.appendices.implementation.why__code__phrase_role__identifier__convert_to__phrase___code__between_tuples_is_not_be_implemented_using__code__phrase_role__identifier__boost__phrase__phrase_role__special______phrase__phrase_role__identifier__fusion__phrase__phrase_role__special______phrase__phrase_role__identifier__transform__phrase___code__">Why
+<a name="boost.conversion.appendices.implementation.why__code__phrase_role__identifier__convert_to__phrase___code__between_tuples_is_not_implemented_using__code__phrase_role__identifier__boost__phrase__phrase_role__special______phrase__phrase_role__identifier__fusion__phrase__phrase_role__special______phrase__phrase_role__identifier__transform__phrase___code__"></a><h4>
+<a name="id4830841"></a>
+ <a href="implementation.html#boost.conversion.appendices.implementation.why__code__phrase_role__identifier__convert_to__phrase___code__between_tuples_is_not_implemented_using__code__phrase_role__identifier__boost__phrase__phrase_role__special______phrase__phrase_role__identifier__fusion__phrase__phrase_role__special______phrase__phrase_role__identifier__transform__phrase___code__">Why
 <code class="computeroutput">convert_to</code> between tuples
- is not be implemented using <code class="computeroutput">boost::fusion::transform</code>?</a>
+ is not implemented using <code class="computeroutput">boost::fusion::transform</code>?</a>
 </h4>

 <code class="computeroutput">convert_to<T></code> is
- a kind of transaformation, so the natural implementation of convert_to for
- homegeneus containers could be to use the transform function.
+ a kind of transaformation, so the natural implementation of <code class="computeroutput">convert_to</code> for homegeneus containers could
+ be to use the transform function.
 

 This can not be applied to heterogeneus containers as tuples because the

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/rationale.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/rationale.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/rationale.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -28,7 +28,7 @@
<a name="boost.conversion.appendices.rationale"></a> Appendix B: Rationale
</h3></div></div></div>
<a name="boost.conversion.appendices.rationale.mathematical_background"></a><h4>
-<a name="id4826260"></a>
+<a name="id4830276"></a>
 <a href="rationale.html#boost.conversion.appendices.rationale.mathematical_background">Mathematical
 background</a>
 </h4>
@@ -41,10 +41,11 @@
</pre>
<div class="itemizedlist"><ul type="disc">
<li>
- Reflexive: A is convertible to A if it is CopyConstructible
+ Reflexive: A is convertible to A if it is CopyConstructible or a specialization
+ of convert_to is provided.
 </li>
<li>
- Symetric : A convertible to B implies B convertible to C
+ AntiSymetric : A convertible to B don't implies B convertible to A
 </li>
<li>
 Loss of precission: Conversions can loss precission but not at infinitum
@@ -77,8 +78,11 @@
 return convert_to<A>(convert_to<B>(c));
}
</pre>
+
+ The library provides a convert_to_via function which helps to implement that.
+ 
<a name="boost.conversion.appendices.rationale.why_use_partial_function_specialization_and_not_adl_"></a><h4>
-<a name="id4826775"></a>
+<a name="id4830797"></a>
 <a href="rationale.html#boost.conversion.appendices.rationale.why_use_partial_function_specialization_and_not_adl_">Why
 use partial function specialization and not ADL?</a>
 </h4>

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/todo.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/todo.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/appendices/todo.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -30,15 +30,32 @@
 plans</a>
</h3></div></div></div>
<a name="boost.conversion.appendices.todo.tasks_to_do_before_review"></a><h4>
-<a name="id4828205"></a>
+<a name="id4833238"></a>
 <a href="todo.html#boost.conversion.appendices.todo.tasks_to_do_before_review">Tasks
 to do before review</a>
 </h4>
+<div class="itemizedlist"><ul type="disc">
+<li>
+ On compilers supporting partial template functions specialization no use
+ of the workarround.
+ </li>
+<li>
+ Add conversion between std::vector of explicitly convertible types.
+ </li>
+<li>
+ Add a is_convertible_to metafunction. Inherits: If an imaginary lvalue
+ of type From is convertible to type To using convert_to then inherits from
+ true_type, otherwise inherits from false_type.
+ </li>
+</ul></div>
+<pre class="programlisting">template <class From, class To>
+struct is_convertible : public true_type-or-false_type {};
+</pre>
<div class="itemizedlist"><ul type="disc"><li>
- conversion between std::vector of explicitly convertible types.
+ Add a is_asignable_to metafunction.
 </li></ul></div>
<a name="boost.conversion.appendices.todo.for_later_releases"></a><h4>
-<a name="id4828236"></a>
+<a name="id4833390"></a>
 <a href="todo.html#boost.conversion.appendices.todo.for_later_releases">For later
 releases</a>
 </h4>
@@ -50,6 +67,44 @@
 conversion between types for which numeric_cast works.
 </li>
</ul></div>
+<a name="boost.conversion.appendices.todo.make_a_proposal_to_the_c___standard"></a><h4>
+<a name="id4833424"></a>
+ <a href="todo.html#boost.conversion.appendices.todo.make_a_proposal_to_the_c___standard">Make
+ a proposal to the C++ standard</a>
+ </h4>
+
+ C++1x has added explicit conversion operators, but they must always be defined
+ in the Source class. The same applies to the assignement operator, it must
+ be defined on the Target class.
+ 
+
+ It will be interesting to be able to implicitly or explicitly add extrinsic
+ conversion operators between unrelated types. Assignement operators could
+ also be specialized.
+ 
+<pre class="programlisting">template < typename To, typename From >
+operator To(const From& val);
+
+template < typename To, typename From >
+To& operator=(To& to, const From& from);
+</pre>
+
+ For example we could specialize this the conversion from as chrono::time_point<Clock,
+ Duration> to posix_time::ptime follows
+ 
+<pre class="programlisting">template < class Clock, class Duration>
+operator boost::posix_time::ptime(const boost::chrono::time_point<Clock, Duration>& from) {
+ typedef boost::chrono::time_point<Clock, Duration> time_point_t;
+ typedef boost::chrono::nanoseconds duration_t;
+ typedef boost::duration_t::rep rep_t;
+ rep_t d = boost::chrono::duration_cast<duration_t>(from.time_since_epoch()).count();
+ rep_t sec = d/1000000000;
+ rep_t nsec = d%1000000000;
+ return boost::posix_time::from_time_t(0)+
+ boost::posix_time::seconds(static_cast<long>(sec))+
+ boost::posix_time::nanoseconds(nsec);
+}
+</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -6,7 +6,8 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
<link rel="start" href="../../index.html" title="Toward Boost.Conversion">
<link rel="up" href="../../index.html" title="Toward Boost.Conversion">
-<link rel="prev" href="reference/tuple_hpp.html" title=" Header <boost/conversion/boost/tuple.hpp>">
+<link rel="prev" href="reference/boost_classes_specializations.html" title="Boost
+ classes specializations">
<link rel="next" href="examples/chrono__time_point_and_posix_time__ptime.html" title="chrono::time_point
and posix_time::ptime">
</head>
@@ -21,7 +22,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="reference/tuple_hpp.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/chrono__time_point_and_posix_time__ptime.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="reference/boost_classes_specializations.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/chrono__time_point_and_posix_time__ptime.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -44,7 +45,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="reference/tuple_hpp.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/chrono__time_point_and_posix_time__ptime.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="reference/boost_classes_specializations.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/chrono__time_point_and_posix_time__ptime.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/boost__optional.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/boost__optional.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/boost__optional.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -38,6 +38,7 @@
#include <boost/optional.hpp>
#include <boost/none.hpp>
#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>

namespace boost {

@@ -51,7 +52,7 @@
 };
 template < class Target, class Source>
 struct assign_to< optional<Target>, optional<Source> > {
- inline static optional<Target>& apply(const optional<Source>& from, optional<Target>& to)
+ inline static optional<Target>& apply(optional<Target>& to, const optional<Source>& from)
 {
 to = from?boost::convert_to<Target>(from.get()):optional<Target>();
 return to;

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/chrono__time_point_and_posix_time__ptime.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/chrono__time_point_and_posix_time__ptime.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/chrono__time_point_and_posix_time__ptime.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -41,6 +41,7 @@
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/date_time/posix_time/conversion.hpp>
#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>

namespace boost {

@@ -66,7 +67,7 @@
 };
 template < class Clock, class Duration>
 struct assign_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
- inline static posix_time::ptime& apply(const chrono::time_point<Clock, Duration>& from, posix_time::ptime& to)
+ inline static posix_time::ptime& apply(posix_time::ptime& to, const chrono::time_point<Clock, Duration>& from)
 {
 to = boost::convert_to<posix_time::ptime>(from);
 return to;
@@ -86,7 +87,7 @@
 };
 template < class Clock, class Duration>
 struct assign_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
- inline static chrono::time_point<Clock, Duration>& apply(const posix_time::ptime& from, chrono::time_point<Clock, Duration>& to)
+ inline static chrono::time_point<Clock, Duration>& apply(chrono::time_point<Clock, Duration>& to, const posix_time::ptime& from)
 {
 to = boost::convert_to<chrono::time_point<Clock, Duration> >(from);
 return to;

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/std__pair.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/std__pair.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/examples/std__pair.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -36,6 +36,7 @@

#include <utility>
#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>

namespace boost {
 namespace partial_specialization_workaround {
@@ -48,7 +49,7 @@
 };
 template < class T1, class T2, class U1, class U2>
 struct assign_to< std::pair<T1,T2>, std::pair<U1,U2> > {
- inline static std::pair<T1,T2>& apply(const std::pair<U1,U2>& from, std::pair<T1,T
2>& to)
+ inline static std::pair<T1,T2>& apply(std::pair<T1,T2>& to, const std::pair<U1,U2>& from)
 {
 to.first = boost::convert_to<T1>(from.first);
 to.second = boost::convert_to<T2>(from.second);

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/overview.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/overview.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/overview.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -42,16 +42,62 @@
 
<div class="itemizedlist"><ul type="disc">
<li>
- a generic convert_to function which can be specialized by the user to make
- explict conversion between unrelated types.
+ a generic <code class="computeroutput">convert_to</code> function
+ which can be specialized by the user to make explict conversion between unrelated
+ types.
 </li>
<li>
- a generic assign_to function which can be specialized by the user to make
- explict assignation between unrelated types.
+ a generic <code class="computeroutput">assign_to</code> function
+ which can be specialized by the user to make explict assignation between
+ unrelated types.
+ </li>
+<li>
+ a generic <code class="computeroutput">mca</code> function returning
+ a wrapper which replace assignments by a call to <code class="computeroutput">assign_to</code>
+ and conversion operators by a call <code class="computeroutput">convert_to</code>.
+ </li>
+<li>
+ a generic <code class="computeroutput">convert_to_via</code>
+ function which convert a type <code class="computeroutput">From</code>
+ to another <code class="computeroutput">To</code> using a temporary
+ one <code class="computeroutput">Via</code>.
+ </li>
+<li>
+ conversion between <code class="computeroutput">std::complex</code> of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">std::pair</code> of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::optional</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::rational</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::interval</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::chrono::time_point</code>
+ and <code class="computeroutput">boost::ptime</code>.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::chrono::duration</code>
+ and <code class="computeroutput">boost::time_duration</code>.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::array</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between Boost.Fusion sequences of explicitly convertible types.
 </li>
</ul></div>
<a name="boost.conversion.overview.how_to_use_this_documentation"></a><h3>
-<a name="id4762305"></a>
+<a name="id4765018"></a>
 <a href="overview.html#boost.conversion.overview.how_to_use_this_documentation">How
 to Use This Documentation</a>
 </h3>
@@ -103,8 +149,10 @@

 Finally, you can mentally add the following to any code fragments in this document:
 
-<pre class="programlisting">// Include all of Conversion files
+<pre class="programlisting">// Include all of the core Conversion files
#include <boost/conversion.hpp>
+
+using namespace boost;
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/overview/motivation.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/overview/motivation.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/overview/motivation.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -27,8 +27,9 @@
<a name="boost.conversion.overview.motivation"></a>Motivation
</h3></div></div></div>

- Imagine you need to convert unrelated types Source and Target. You can get
- it by defining a specific function such as
+ Imagine you need to convert unrelated types <code class="computeroutput">Source</code>
+ and <code class="computeroutput">Target</code>. You can get it
+ by defining a specific function such as
 
<pre class="programlisting">Target SourceToTarget(Source& v);
</pre>
@@ -41,7 +42,8 @@
}
</pre>

- While the SourceToTarget could be specific, the PairOfSourceToPairOfTarget
+ While the <code class="computeroutput">SourceToTarget</code>
+ could be specific, the <code class="computeroutput">PairOfSourceToPairOfTarget</code>
 sould be generic
 
<pre class="programlisting">template <typename Target1, typename Target2, typename Source1, typename Source2)
@@ -49,13 +51,14 @@
</pre>

 In order to do that we need that the pair template parameters define a common
- function, let it call convert_to,
+ function, let it call <code class="computeroutput">convert_to</code>,
 
<pre class="programlisting">template <typename Target, typename Source)
Target convert_to(Source& v);
</pre>

- so ConvertPair can be defined as
+ so <code class="computeroutput">ConvertPair</code> can be defined
+ as
 
<pre class="programlisting">template <typename Target1, typename Target2, typename Source1, typename Source2)
std::pair<Target1,Target2> ConvertPair(std::pair<Source1,Source2>& v) {
@@ -63,24 +66,23 @@
}
</pre>

- The issue is that we need to specialize the convert_to function for the classes
- Source and Target. We can do it as follows
+ The issue is that we need to specialize the <code class="computeroutput">convert_to</code>
+ function for the classes <code class="computeroutput">Source</code>
+ and <code class="computeroutput">Target</code>. We can do it
+ as follows
 
<pre class="programlisting">template <>
Target convert_to<Target, Source>(Source& v) {return SourceToTarget(v);}
</pre>

- What about converting std::pair<Source,std::pair<Source,Source>>
- to std::pair<Target,std::pair<Target,Target>>?
- 
-
- The issue now is that convert_to(std::make_pair<to, std::make_pair<to,to>>)
- do not compiles because the conversion of std::pair is named ConvertPair.
- So we need to specialize the function convert_to for pairs. With C++0x there
- is no major problem as it allows partial specialization of function templates.
- With C++98, we need to use a trick; as it allows partial specialization of
- classes we can define convert_to by as relying to a specific function of
- a class, as follows:
+ What about converting <code class="computeroutput">std::pair<Source,std::pair<Source,Source> ></code> to <code class="computeroutput">std::pair<Target,std::pair<Target,Target> ></code>? The issue now is that <code class="computeroutput">convert_to(std::make_pair<to, std::make_pair<to,to> >)</code>
+ do not compiles because the conversion of <code class="computeroutput">std::pair</code>
+ is named <code class="computeroutput">ConvertPair</code>. So
+ we need to specialize the function <code class="computeroutput">convert_to</code>
+ for pairs. There is no major problem with compilers supporting partial specialization
+ of function templates. If this is not the case, we need to use a trick; as
+ it allows partial specialization of classes we can define <code class="computeroutput">convert_to</code>
+ by as relying to a specific function of a class, as follows:
 
<pre class="programlisting">namespace partial_specialization_workaround {
 template < typename Target, typename Source >
@@ -95,8 +97,8 @@
}
</pre>

- So now we can specialize partial_specialization_workaround::convert_to for
- pairs as follows:
+ So now we can specialize <code class="computeroutput">partial_specialization_workaround::convert_to</code>
+ for pairs as follows:
 
<pre class="programlisting">namespace partial_specialization_workaround {
 template <typename Target1, typename Target2, typename Source1, typename Source2)
@@ -128,9 +130,9 @@
}
</pre>

- What have we learned? Classes or algorithms relying on a conversion by construction
+ What have we learned? Classes or algorithms relying on a conversion by copy-construction
 or by the conversion operator can be made more generic by relaying in a function
- that explicitly states this conversion. So instead of requiring
+ that explicitly states this conversion. Thus, instead of requiring
 
<pre class="programlisting">Target(from)
</pre>
@@ -148,15 +150,16 @@

 requires
 
-<pre class="programlisting">assign_to(from, to);
+<pre class="programlisting">assign_to(to, from);
</pre>

- The default implementation of assign_to relies on the assignement operator
+ The default implementation of <code class="computeroutput">assign_to</code>
+ relies on the assignement operator
 
<pre class="programlisting">namespace partial_specialization_workaround {
 template < typename Target, typename Source >
 struct assign_to {
- inline static To& apply(const Source& from, Target& to)
+ inline static To& apply(Target& to, const Source& from)
 {
 to = from;
 return to;
@@ -164,13 +167,14 @@
 };
}
template < typename Target, typename Source >
-To& assign_to(const Source& from, Target& to) {
- return partial_specialization_workaround::assign_to<Target,Source>::apply(from, to);
+To& assign_to(Target& to, const Source& from) {
+ return partial_specialization_workaround::assign_to<Target,Source>::apply(to, from);
}
</pre>

 For classes that are explicitly convertible and having a self assignment
- operator it is easy to make a specialization of assign_to as follows.
+ operator it is easy to make a specialization of <code class="computeroutput">assign_to</code>
+ as follows.
 
<pre class="programlisting">to = convert_to<Target>(from);
</pre>
@@ -178,7 +182,27 @@
 The rationale is that if there was not a copy constructor from a Source seems
 reasonable to think that there will not be an assignment operator. So in
 most of the cases, once we have specialized the convert_to function we recover
- a reasonable implementation for the assign_to function.
+ a reasonable implementation for the <code class="computeroutput">assign_to</code>
+ function.
+ 
+
+ When doing multiple assignements we use to do
+ 
+<pre class="programlisting">a = b = c;
+</pre>
+
+ With <code class="computeroutput">assign_to</code> we could do
+ 
+<pre class="programlisting">assign_to(a, assign_to(b, c));
+</pre>
+
+ and if we find this not really readable we can try with
+ 
+<pre class="programlisting">mca(a) = mca(b) = c;
+</pre>
+
+ The behavior of mca recall the tie function of Boost.Tuple, but instead of
+ allowing multiple assignations, allows a single assign_to call.
 

 We can even generalize this, so classes or algorithms relying on a member

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -7,7 +7,7 @@
<link rel="start" href="../../index.html" title="Toward Boost.Conversion">
<link rel="up" href="../../index.html" title="Toward Boost.Conversion">
<link rel="prev" href="users_guide/ext_references.html" title=" References">
-<link rel="next" href="reference/convert_to_hpp.html" title=" Header <boost/conversion/convert_to.hpp>">
+<link rel="next" href="reference/conversion_hpp.html" title=" Header <boost/conversion.hpp>">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -20,25 +20,51 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="users_guide/ext_references.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference/convert_to_hpp.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="users_guide/ext_references.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference/conversion_hpp.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost.conversion.reference"></a>Reference
</h2></div></div></div>
<div class="toc"><dl>
-<dt> Header <boost/conversion/convert_to.hpp></dt>
-<dt> Header <boost/conversion/assign_to.hpp></dt>
-<dt> Header <boost/conversion/std/complex.hpp></dt>
-<dt> Header <boost/conversion/std/pair.hpp></dt>
-<dt> Header <boost/conversion/std/string.hpp></dt>
-<dt> Header <boost/conversion/boost/rational.hpp></dt>
-<dt><a href="reference/chrono_posix_time_hpp.html"> Header
- <code class="computeroutput"><boost/conversion/boost/chrono_posix_time.hpp></code></a></dt>
-<dt> Header <boost/conversion/boost/interval.hpp></dt>
-<dt> Header <boost/conversion/boost/optional.hpp></dt>
-<dt> Header <boost/conversion/boost/array.hpp></dt>
-<dt> Header <boost/conversion/boost/tuple.hpp></dt>
+<dt> Header <boost/conversion.hpp></dt>
+<dt>Core</dt>
+<dd><dl>
+<dt><a href="reference/core.html#boost.conversion.reference.core.convert_to_hpp"> Header
+ <code class="computeroutput"><boost/conversion/convert_to.hpp></code></a></dt>
+<dt><a href="reference/core.html#boost.conversion.reference.core.assign_to_hpp"> Header
+ <code class="computeroutput"><boost/conversion/assign_to.hpp></code></a></dt>
+<dt><a href="reference/core.html#boost.conversion.reference.core.convert_to_via_hpp">
+ Header <code class="computeroutput"><boost/conversion/convert_to_via.hpp></code></a></dt>
+<dt><a href="reference/core.html#boost.conversion.reference.core.ca_wrapper_hpp"> Header
+ <code class="computeroutput"><boost/conversion/ca_wrapper.hpp></code></a></dt>
+</dl></dd>
+<dt><a href="reference/c___standard_classes_specializations.html">C++
+ Standard classes specializations</a></dt>
+<dd><dl>
+<dt><a href="reference/c___standard_classes_specializations.html#boost.conversion.reference.c___standard_classes_specializations.complex_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/complex.hpp></code></a></dt>
+<dt><a href="reference/c___standard_classes_specializations.html#boost.conversion.reference.c___standard_classes_specializations.pair_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/pair.hpp></code></a></dt>
+<dt><a href="reference/c___standard_classes_specializations.html#boost.conversion.reference.c___standard_classes_specializations.string_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/string.hpp></code></a></dt>
+</dl></dd>
+<dt><a href="reference/boost_classes_specializations.html">Boost
+ classes specializations</a></dt>
+<dd><dl>
+<dt><a href="reference/boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.rational_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/rational.hpp></code></a></dt>
+<dt><a href="reference/boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.chrono_posix_time_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/chrono_posix_time.hpp></code></a></dt>
+<dt><a href="reference/boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.interval_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/interval.hpp></code></a></dt>
+<dt><a href="reference/boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.optional_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/optional.hpp></code></a></dt>
+<dt><a href="reference/boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.array_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/array.hpp></code></a></dt>
+<dt><a href="reference/boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.tuple_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/tuple.hpp></code></a></dt>
+</dl></dd>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
@@ -51,7 +77,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="users_guide/ext_references.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference/convert_to_hpp.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="users_guide/ext_references.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference/conversion_hpp.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/array_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/array_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,60 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header <boost/conversion/boost/array.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="optional_hpp.html" title=" Header <boost/conversion/boost/optional.hpp>">
-<link rel="next" href="tuple_hpp.html" title=" Header <boost/conversion/boost/tuple.hpp>">
-</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">
-<a accesskey="p" href="optional_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tuple_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.array_hpp"></a> Header <boost/conversion/boost/array.hpp>
-</h3></div></div></div>
-
- Include this file when using conversions between arrays of convertible types.
- 
-<pre class="programlisting">namespace boost {
-
- namespace partial_specialization_workaround {
- template < typename T1, typename T2, std::size_t N>
- struct convert_to< array<T1,N>, array<T2,N> > {
- inline static array<T1,N> apply(array<T2,N> const & from);
- };
- template < typename T1, typename T2, std::size_t N>
- struct assign_to< array<T1,N>, array<T2,N> > {
- inline static array<T1,N>& apply(array<T2,N> const & from, array<T1,N>& to);
- };
- }
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="optional_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tuple_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/assign_to_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/assign_to_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,59 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header <boost/conversion/assign_to.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="convert_to_hpp.html" title=" Header <boost/conversion/convert_to.hpp>">
-<link rel="next" href="complex_hpp.html" title=" Header <boost/conversion/std/complex.hpp>">
-</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">
-<a accesskey="p" href="convert_to_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="complex_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.assign_to_hpp"></a> Header <boost/conversion/assign_to.hpp>
-</h3></div></div></div>
-<pre class="programlisting">namespace boost {
- namespace partial_specialization_workaround {
- template < typename To, typename From >
- struct assign_to {
- static void apply(const From& from, To& to);
- };
- template < typename To, typename From, std::size_t N >
- struct assign_to<To[N],From[N]> {
- static void apply(const From(& from)[N], To (&to)[N]);
- };
- }
-
- template < typename To, typename From >
- void assign_to(const From& from, To& to);
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="convert_to_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="complex_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Added: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/boost_classes_specializations.html
==============================================================================
--- (empty file)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/boost_classes_specializations.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -0,0 +1,253 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost
+ classes specializations</title>
+<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="c___standard_classes_specializations.html" title="C++
+ Standard classes specializations">
+<link rel="next" href="../examples.html" title="Examples">
+</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">
+<a accesskey="p" href="c___standard_classes_specializations.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations"></a><a href="boost_classes_specializations.html" title="Boost
+ classes specializations">Boost
+ classes specializations</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.rational_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/rational.hpp></code></a></dt>
+<dt><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.chrono_posix_time_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/chrono_posix_time.hpp></code></a></dt>
+<dt><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.interval_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/interval.hpp></code></a></dt>
+<dt><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.optional_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/optional.hpp></code></a></dt>
+<dt><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.array_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/array.hpp></code></a></dt>
+<dt><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.tuple_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/tuple.hpp></code></a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.rational_hpp"></a><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.rational_hpp" title="
+ Header <boost/conversion/boost/rational.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/rational.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between rational of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+ namespace partial_specialization_workaround {
+ template < class T, class U>
+ struct convert_to< rational<T>, rational<U> > {
+ inline static rational<T> apply(rational<U> const & from);
+ };
+ template < class T, class U>
+ struct assign_to< rational<T>, rational<U> > {
+ inline static rational<T>& apply(rational<T>& to, const rational<U>& from);
+ };
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.chrono_posix_time_hpp"></a><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.chrono_posix_time_hpp" title="
+ Header <boost/conversion/boost/chrono_posix_time.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/chrono_posix_time.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between chrono and posix_time
+ time and duration types.
+ 
+<pre class="programlisting">namespace boost {
+ namespace partial_specialization_workaround {
+ template < class Rep, class Period>
+ struct convert_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
+ static posix_time::time_duration apply(
+ chrono::duration<Rep, Period> const & from);
+ };
+ template < class Rep, class Period>
+ struct assign_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
+ static posix_time::time_duration& apply(
+ posix_time::time_duration& to,
+ const chrono::duration<Rep, Period>& from
+ );
+ };
+
+ template < class Rep, class Period>
+ struct convert_to<chrono::duration<Rep, Period>, posix_time::time_duration> {
+ static chrono::duration<Rep, Period> apply(posix_time::time_duration const & from);
+ };
+ template < class Rep, class Period>
+ struct assign_to<chrono::duration<Rep, Period>, posix_time::time_duration> {
+ static chrono::duration<Rep, Period> & apply(
+ chrono::duration<Rep, Period> & to,
+ const posix_time::time_duration& from);
+ };
+ }
+}
+
+namespace boost {
+ namespace partial_specialization_workaround {
+ template < class Clock, class Duration>
+ struct convert_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
+ static posix_time::ptime apply(const chrono::time_point<Clock, Duration>& from);
+ };
+ template < class Clock, class Duration>
+ struct assign_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
+ static posix_time::ptime& apply(posix_time::ptime& to,
+ const chrono::time_point<Clock, Duration>& from);
+ };
+
+ template < class Clock, class Duration>
+ struct convert_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
+ static chrono::time_point<Clock, Duration> apply(const posix_time::ptime& from);
+ };
+ template < class Clock, class Duration>
+ struct assign_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
+ static chrono::time_point<Clock, Duration>& apply(
+ chrono::time_point<Clock, Duration>& to,
+ const posix_time::ptime& from);
+ };
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.interval_hpp"></a><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.interval_hpp" title="
+ Header <boost/conversion/boost/interval.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/interval.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between intervals of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+ namespace partial_specialization_workaround {
+ template < class T, class PT, class U, class PU>
+ struct convert_to< interval<T,PT>, interval<U,PU> > {
+ static interval<T,PT> apply(interval<U,PU> const & from);
+ };
+ template < class T, class PT, class U, class PU>
+ struct assign_to< interval<T,PT>, interval<U,PU> > {
+ static interval<T,PT>& apply(
+ interval<T,PT>& to, const interval<U,PU>& from);
+ };
+
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.optional_hpp"></a><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.optional_hpp" title="
+ Header <boost/conversion/boost/optional.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/optional.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between optional of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+ namespace partial_specialization_workaround {
+ template < class Target, class Source>
+ struct convert_to< optional<Target>, optional<Source> > {
+ static optional<Target> apply(optional<Source> const & from);
+ };
+ template < class Target, class Source>
+ struct assign_to< optional<Target>, optional<Source> > {
+ static optional<Target>& apply(
+ optional<Target>& to, const optional<Target>& from);
+ };
+
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.array_hpp"></a><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.array_hpp" title="
+ Header <boost/conversion/boost/array.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/array.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between arrays of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+
+ namespace partial_specialization_workaround {
+ template < typename T1, typename T2, std::size_t N>
+ struct convert_to< array<T1,N>, array<T2,N> > {
+ static array<T1,N> apply(array<T2,N> const & from);
+ };
+ template < typename T1, typename T2, std::size_t N>
+ struct assign_to< array<T1,N>, array<T2,N> > {
+ static array<T1,N>& apply(array<T1,N>& to, array<T2,N> const & from);
+ };
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.tuple_hpp"></a><a href="boost_classes_specializations.html#boost.conversion.reference.boost_classes_specializations.tuple_hpp" title="
+ Header <boost/conversion/boost/tuple.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/tuple.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between fusion::tuple of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+ namespace partial_specialization_workaround {
+ template < class T1, ..., class Tn, class U1, ..., class Un>
+ struct convert_to< boost::fusion::tuple<T1,...,T3>, boost::fusion::tuple<U1,...,U3> > {
+ inline static boost::fusion::tuple<T1,...,T3>
+ apply(boost::fusion::tuple<U1,...,U3> const & from);
+ };
+ template < class T1, ..., class Tn, class U1, ..., class Un>
+ struct assign_to< boost::fusion::tuple<T1,...,T3>, boost::fusion::tuple<U1,...,U3> > {
+ inline static boost::fusion::tuple<T1,...,T3>
+ apply(boost::fusion::tuple<T1,...,T3>& to, boost::fusion::tuple<U1,...,U3> const & from);
+ };
+
+ }
+}
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
+ 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></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="c___standard_classes_specializations.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/c___standard_classes_specializations.html
==============================================================================
--- (empty file)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/c___standard_classes_specializations.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -0,0 +1,136 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>C++
+ Standard classes specializations</title>
+<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="core.html" title="Core">
+<link rel="next" href="boost_classes_specializations.html" title="Boost
+ classes specializations">
+</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">
+<a accesskey="p" href="core.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="boost_classes_specializations.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.reference.c___standard_classes_specializations"></a><a href="c___standard_classes_specializations.html" title="C++
+ Standard classes specializations">C++
+ Standard classes specializations</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="c___standard_classes_specializations.html#boost.conversion.reference.c___standard_classes_specializations.complex_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/complex.hpp></code></a></dt>
+<dt><a href="c___standard_classes_specializations.html#boost.conversion.reference.c___standard_classes_specializations.pair_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/pair.hpp></code></a></dt>
+<dt><a href="c___standard_classes_specializations.html#boost.conversion.reference.c___standard_classes_specializations.string_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/string.hpp></code></a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.c___standard_classes_specializations.complex_hpp"></a><a href="c___standard_classes_specializations.html#boost.conversion.reference.c___standard_classes_specializations.complex_hpp" title="
+ Header <boost/conversion/std/complex.hpp>">
+ Header <code class="computeroutput"><boost/conversion/std/complex.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between complex of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+ namespace partial_specialization_workaround {
+ template < class T, class U>
+ struct convert_to< std::complex<T>, std::complex<U> > {
+ static std::complex<T> apply(std::complex<U> const & from);
+ };
+ template < class T, class U>
+ struct convert_to< std::complex<T>, std::complex<U> > {
+ static std::complex<T>& apply(const std::complex<U>& from, std::complex<T>& to);
+ };
+
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.c___standard_classes_specializations.pair_hpp"></a><a href="c___standard_classes_specializations.html#boost.conversion.reference.c___standard_classes_specializations.pair_hpp" title="
+ Header <boost/conversion/std/pair.hpp>">
+ Header <code class="computeroutput"><boost/conversion/std/pair.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between pairs of convertible types.
+ 
+<pre class="programlisting">namespace boost {
+ namespace partial_specialization_workaround {
+ template < class T1, class T2, class U1, class U2>
+ struct convert_to< std::pair<T1,T2>, std::pair<U1,U2> > {
+ static std::pair<T1,T2> apply(std::pair<U1,U2> const & from);
+ };
+ template < class T1, class T2, class U1, class U2>
+ struct assign_to< std::pair<T1,T2>, std::pair<U1,U2> > {
+ static std::pair<T1,T2>& apply(std::pair<T1,T2>& to, const std::pair<U1,U2>&amp
; from);
+ };
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.c___standard_classes_specializations.string_hpp"></a><a href="c___standard_classes_specializations.html#boost.conversion.reference.c___standard_classes_specializations.string_hpp" title="
+ Header <boost/conversion/std/string.hpp>">
+ Header <code class="computeroutput"><boost/conversion/std/string.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions to std::string.
+ 
+<pre class="programlisting">namespace boost {
+ namespace partial_specialization_workaround {
+ template<typename T, typename CharT, typename Traits, typename Alloc>
+ struct convert_to< std::basic_string<CharT,Traits,Alloc>, T > {
+ static std::basic_string<CharT,Traits,Alloc> apply(T const & from);
+ }
+ template<typename T, typename CharT, typename Traits, typename Alloc>
+ struct assign_to< std::basic_string<CharT,Traits,Alloc>, T > {
+ static std::basic_string<CharT,Traits,Alloc>& apply(
+ std::basic_string<CharT,Traits,Alloc>& to, const T& from);
+ };
+ template<typename T, typename CharT, typename Traits, typename Alloc>
+ struct convert_to< T, std::basic_string<CharT,Traits,Alloc>> {
+ static T apply(std::basic_string<CharT,Traits,Alloc> const & from);
+ };
+ template<typename T, typename CharT, typename Traits, typename Alloc>
+ struct assign_to< T, std::basic_string<CharT,Traits,Alloc>> {
+ static void apply(T& to
+ const std::basic_string<CharT,Traits,Alloc>& from);
+ };
+ }
+}
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
+ 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></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="core.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="boost_classes_specializations.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/chrono_posix_time_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/chrono_posix_time_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,103 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header
- <boost/conversion/boost/chrono_posix_time.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="rational_hpp.html" title=" Header <boost/conversion/boost/rational.hpp>">
-<link rel="next" href="interval_hpp.html" title=" Header <boost/conversion/boost/interval.hpp>">
-</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">
-<a accesskey="p" href="rational_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="interval_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.chrono_posix_time_hpp"></a><a href="chrono_posix_time_hpp.html" title=" Header
- <boost/conversion/boost/chrono_posix_time.hpp>"> Header
- <code class="computeroutput"><boost/conversion/boost/chrono_posix_time.hpp></code></a>
-</h3></div></div></div>
-
- Include this file when using conversions between chrono and posix_time time
- and duration types.
- 
-<pre class="programlisting">namespace boost {
- namespace partial_specialization_workaround {
- template < class Rep, class Period>
- struct convert_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
- static posix_time::time_duration apply(
- chrono::duration<Rep, Period> const & from);
- };
- template < class Rep, class Period>
- struct assign_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
- static posix_time::time_duration& apply(
- const chrono::duration<Rep, Period>& from,
- posix_time::time_duration& to);
- };
-
- template < class Rep, class Period>
- struct convert_to<chrono::duration<Rep, Period>, posix_time::time_duration> {
- static chrono::duration<Rep, Period> apply(posix_time::time_duration const & from);
- };
- template < class Rep, class Period>
- struct assign_to<chrono::duration<Rep, Period>, posix_time::time_duration> {
- static chrono::duration<Rep, Period> & apply(
- const posix_time::time_duration& from,
- chrono::duration<Rep, Period> & to);
- };
- }
-}
-
-namespace boost {
- namespace partial_specialization_workaround {
- template < class Clock, class Duration>
- struct convert_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
- static posix_time::ptime apply(const chrono::time_point<Clock, Duration>& from);
- };
- template < class Clock, class Duration>
- struct assign_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
- static posix_time::ptime& apply(
- const chrono::time_point<Clock, Duration>& from,
- posix_time::ptime& to);
- };
-
- template < class Clock, class Duration>
- struct convert_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
- static chrono::time_point<Clock, Duration> apply(const posix_time::ptime& from);
- };
- template < class Clock, class Duration>
- struct assign_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
- static chrono::time_point<Clock, Duration>& apply(
- const posix_time::ptime& from,
- chrono::time_point<Clock, Duration>& to);
- };
- }
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="rational_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="interval_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/complex_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/complex_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,60 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header <boost/conversion/std/complex.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="assign_to_hpp.html" title=" Header <boost/conversion/assign_to.hpp>">
-<link rel="next" href="pair_hpp.html" title=" Header <boost/conversion/std/pair.hpp>">
-</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">
-<a accesskey="p" href="assign_to_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="pair_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.complex_hpp"></a> Header <boost/conversion/std/complex.hpp>
-</h3></div></div></div>
-
- Include this file when using conversions between complex of convertible types.
- 
-<pre class="programlisting">namespace boost {
- namespace partial_specialization_workaround {
- template < class T, class U>
- struct convert_to< std::complex<T>, std::complex<U> > {
- static std::complex<T> apply(std::complex<U> const & from);
- };
- template < class T, class U>
- struct convert_to< std::complex<T>, std::complex<U> > {
- static std::complex<T>& apply(const std::complex<U>& from, std::complex<T>& to);
- };
-
- }
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="assign_to_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="pair_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Added: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/conversion_hpp.html
==============================================================================
--- (empty file)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/conversion_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -0,0 +1,53 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Header <boost/conversion.hpp></title>
+<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="../reference.html" title="Reference">
+<link rel="next" href="core.html" title="Core">
+</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">
+<a accesskey="p" href="../reference.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="core.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.reference.conversion_hpp"></a> Header <boost/conversion.hpp>
+</h3></div></div></div>
+
+ Include all the core conversion public header files. Note thatyou will need
+ to include explicitly the C++ standard or Boost specific files when usin
+ specific classes.
+ 
+<pre class="programlisting">#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/conversion/convert_to_via.hpp>
+#include <boost/conversion/ca_wrapper.hpp>
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
+ 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></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../reference.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="core.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/convert_to_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/convert_to_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,60 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header <boost/conversion/convert_to.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="../reference.html" title="Reference">
-<link rel="next" href="assign_to_hpp.html" title=" Header <boost/conversion/assign_to.hpp>">
-</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">
-<a accesskey="p" href="../reference.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="assign_to_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.convert_to_hpp"></a> Header <boost/conversion/convert_to.hpp>
-</h3></div></div></div>
-<pre class="programlisting">namespace boost {
- namespace partial_specialization_workaround {
- template < typename To, typename From >
- struct convert_to {
- static To apply(const From& val);
- };
-
- template < typename To, typename From, std::size_t N >
- struct convert_to<To[N],From[N]> {
- static To[N] apply(const From (& val)[N]);
- };
- }
-
- template < typename To, typename From >
- To convert_to(const From& val);
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="../reference.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="assign_to_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Added: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/core.html
==============================================================================
--- (empty file)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/core.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -0,0 +1,367 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Core</title>
+<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="conversion_hpp.html" title=" Header <boost/conversion.hpp>">
+<link rel="next" href="c___standard_classes_specializations.html" title="C++
+ Standard classes specializations">
+</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">
+<a accesskey="p" href="conversion_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="c___standard_classes_specializations.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.reference.core"></a>Core
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="core.html#boost.conversion.reference.core.convert_to_hpp"> Header
+ <code class="computeroutput"><boost/conversion/convert_to.hpp></code></a></dt>
+<dd><dl><dt><a href="core.html#boost.conversion.reference.core.convert_to_hpp.function__convert_to___">Function
+ <code class="computeroutput">convert_to()</code></a></dt></dl></dd>
+<dt><a href="core.html#boost.conversion.reference.core.assign_to_hpp"> Header
+ <code class="computeroutput"><boost/conversion/assign_to.hpp></code></a></dt>
+<dd><dl><dt><a href="core.html#boost.conversion.reference.core.assign_to_hpp.function__assign_to___">Function
+ <code class="computeroutput">assign_to()</code></a></dt></dl></dd>
+<dt><a href="core.html#boost.conversion.reference.core.convert_to_via_hpp">
+ Header <code class="computeroutput"><boost/conversion/convert_to_via.hpp></code></a></dt>
+<dd><dl><dt><a href="core.html#boost.conversion.reference.core.convert_to_via_hpp.function__convert_to_via_____">Function
+ <code class="computeroutput">convert_to_via<>()</code></a></dt></dl></dd>
+<dt><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp"> Header
+ <code class="computeroutput"><boost/conversion/ca_wrapper.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___">Template
+ Class <code class="computeroutput">ca_wrapper<></code></a></dt>
+<dt><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____">Function
+ <code class="computeroutput">mca<>()</code></a></dt>
+</dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.convert_to_hpp"></a><a href="core.html#boost.conversion.reference.core.convert_to_hpp" title=" Header
+ <boost/conversion/convert_to.hpp>"> Header
+ <code class="computeroutput"><boost/conversion/convert_to.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="core.html#boost.conversion.reference.core.convert_to_hpp.function__convert_to___">Function
+ <code class="computeroutput">convert_to()</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ namespace partial_specialization_workaround {
+ template < typename To, typename From >
+ struct convert_to {
+ static To apply(const From& val);
+ };
+ }
+
+ template < typename To, typename From >
+ To convert_to(const From& from);
+}
+</pre>
+
+ Defines a free function <code class="computeroutput">convert_to</code>
+ which converts the <code class="computeroutput">from</code>
+ parameter to a <code class="computeroutput">To</code> type.
+ The default implementation applies the conversion <code class="computeroutput">To</code>
+ operator of the <code class="computeroutput">From</code> class
+ or the copy constructor of the <code class="computeroutput">To</code>
+ class. A user adapting another type could need to specialize the <code class="computeroutput">convert_to</code> free function if the default
+ behavior is not satisfactory.
+ 
+
+ As for the moment we can not partially specialize a function a trick is
+ used: instead of calling directly to the <code class="computeroutput">convert_to</code>
+ member function, <code class="computeroutput">convert_to</code>
+ calls to the static operation <code class="computeroutput">apply</code>
+ on a class with the same name in the namespace __partial_specializationworkaround_. Thus the user can specialize partially
+ this class.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.conversion.reference.core.convert_to_hpp.function__convert_to___"></a><a href="core.html#boost.conversion.reference.core.convert_to_hpp.function__convert_to___" title="Function
+ convert_to()">Function
+ <code class="computeroutput">convert_to()</code></a>
+</h5></div></div></div>
+<pre class="programlisting">template < typename To, typename From >
+To convert_to(const From& from);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Converts the from parameter to an instance of the To type, using
+ by default the conversion operator or copy constructor.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Whatever the underlying conversion <code class="computeroutput">To</code>
+ operator of the <code class="computeroutput">From</code>
+ class or the copy constructor of the <code class="computeroutput">To</code>
+ class throws.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.assign_to_hpp"></a><a href="core.html#boost.conversion.reference.core.assign_to_hpp" title=" Header
+ <boost/conversion/assign_to.hpp>"> Header
+ <code class="computeroutput"><boost/conversion/assign_to.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="core.html#boost.conversion.reference.core.assign_to_hpp.function__assign_to___">Function
+ <code class="computeroutput">assign_to()</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ namespace partial_specialization_workaround {
+ template < typename To, typename From >
+ struct assign_to {
+ static void apply(To& toconst From& from);
+ };
+ template < typename To, typename From, std::size_t N >
+ struct assign_to<To[N],From[N]> {
+ static void apply(To (&to)[N], const From(& from)[N]);
+ };
+ }
+
+ template < typename To, typename From >
+ void assign_to(To& to, const From& from);
+}
+</pre>
+
+ Defines a free function <code class="computeroutput">assign_to</code>
+ which assigns the <code class="computeroutput">from</code>
+ parameter to the <code class="computeroutput">to</code> parameter.
+ The default implementation applies the the assignement operator of the
+ <code class="computeroutput">To</code> class. A user adapting
+ another type could need to specialize the <code class="computeroutput">assign_to</code>
+ free function if the default behavior is not satisfactory.
+ 
+
+ As for the moment we can not partially specialize a function a trick is
+ used: instead of calling directly to the <code class="computeroutput">assign_to</code>
+ member function, <code class="computeroutput">assign_to</code>
+ calls to the static operation apply on a class with the same name in the
+ namespace __partial_specializationworkaround_.
+ This the user can specialize partially this class.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.conversion.reference.core.assign_to_hpp.function__assign_to___"></a><a href="core.html#boost.conversion.reference.core.assign_to_hpp.function__assign_to___" title="Function
+ assign_to()">Function
+ <code class="computeroutput">assign_to()</code></a>
+</h5></div></div></div>
+<pre class="programlisting">template < typename To, typename From >
+void assign_to(To& to, const From& from);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Assigns the <code class="computeroutput">from</code>
+ parameter to the <code class="computeroutput">to</code>
+ parameter, using by default the assignement operator of the <code class="computeroutput">To</code> class.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Whatever the underlying the assignement operator of the <code class="computeroutput">To</code> class throws.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.convert_to_via_hpp"></a><a href="core.html#boost.conversion.reference.core.convert_to_via_hpp" title="
+ Header <boost/conversion/convert_to_via.hpp>">
+ Header <code class="computeroutput"><boost/conversion/convert_to_via.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="core.html#boost.conversion.reference.core.convert_to_via_hpp.function__convert_to_via_____">Function
+ <code class="computeroutput">convert_to_via<>()</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+
+ template < typename To, typename Via, typename From >
+ To convert_to_via(const From& val) {
+ convert_to<To>(convert_to<Via>(val));
+ }
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.conversion.reference.core.convert_to_via_hpp.function__convert_to_via_____"></a><a href="core.html#boost.conversion.reference.core.convert_to_via_hpp.function__convert_to_via_____" title="Function
+ convert_to_via<>()">Function
+ <code class="computeroutput">convert_to_via<>()</code></a>
+</h5></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Converts the from parameter to an instance of the To type using a
+ intermediary Via type.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Whatever the underlying conversions functions throws.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp"></a><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp" title=" Header
+ <boost/conversion/ca_wrapper.hpp>"> Header
+ <code class="computeroutput"><boost/conversion/ca_wrapper.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___">Template
+ Class <code class="computeroutput">ca_wrapper<></code></a></dt>
+<dt><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____">Function
+ <code class="computeroutput">mca<>()</code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost {
+
+ template <typename T> class ca_wrapper;
+ template <typename T> ca_wrapper<T> mca(T& r);
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___"></a><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___" title="Template
+ Class ca_wrapper<>">Template
+ Class <code class="computeroutput">ca_wrapper<></code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt>Constructor</dt>
+<dt><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___.conversion_operator">Conversion
+ operator</a></dt>
+<dt><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___.assignement_operator">Assignement
+ operator</a></dt>
+</dl></div>
+<pre class="programlisting">template <typename T>
+class ca_wrapper {
+public:
+ ca_wrapper(T& r);
+ template <typename U> operator U();
+ template <typename U> T& operator =(U const& u);
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___.constructor"></a>Constructor
+</h6></div></div></div>
+<pre class="programlisting">ca_wrapper(T& r);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Stores the reference to type.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___.conversion_operator"></a><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___.conversion_operator" title="Conversion
+ operator">Conversion
+ operator</a>
+</h6></div></div></div>
+<pre class="programlisting">template <typename U> operator U();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call to the <code class="computeroutput">convert_to<U></code> on the stored reference.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Whatever <code class="computeroutput">convert_to</code>
+ throws.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___.assignement_operator"></a><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp.template_class__ca_wrapper___.assignement_operator" title="Assignement
+ operator">Assignement
+ operator</a>
+</h6></div></div></div>
+<pre class="programlisting">template <typename U> T& operator =(U const& u);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call to the <code class="computeroutput">assignt_to<T,U></code> with the stored reference and
+ the passed parameter <code class="computeroutput">u</code>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Whatever <code class="computeroutput">assign_to</code>
+ throws.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____"></a><a href="core.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____" title="Function
+ mca<>()">Function
+ <code class="computeroutput">mca<>()</code></a>
+</h5></div></div></div>
+<pre class="programlisting">template <typename T> ca_wrapper<T> mca(T& r);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Creates a ca_wrapper.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
+ 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></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="conversion_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="c___standard_classes_specializations.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/interval_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/interval_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,63 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header <boost/conversion/boost/interval.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="chrono_posix_time_hpp.html" title=" Header
- <boost/conversion/boost/chrono_posix_time.hpp>">
-<link rel="next" href="optional_hpp.html" title=" Header <boost/conversion/boost/optional.hpp>">
-</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">
-<a accesskey="p" href="chrono_posix_time_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="optional_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.interval_hpp"></a> Header <boost/conversion/boost/interval.hpp>
-</h3></div></div></div>
-
- Include this file when using conversions between intervals of convertible
- types.
- 
-<pre class="programlisting">namespace boost {
- namespace partial_specialization_workaround {
- template < class T, class PT, class U, class PU>
- struct convert_to< interval<T,PT>, interval<U,PU> > {
- static interval<T,PT> apply(interval<U,PU> const & from);
- };
- template < class T, class PT, class U, class PU>
- struct assign_to< interval<T,PT>, interval<U,PU> > {
- static interval<T,PT>& apply(
- const interval<U,PU>& from, interval<T,PT>& to);
- };
-
- }
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="chrono_posix_time_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="optional_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/optional_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/optional_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,62 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header <boost/conversion/boost/optional.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="interval_hpp.html" title=" Header <boost/conversion/boost/interval.hpp>">
-<link rel="next" href="array_hpp.html" title=" Header <boost/conversion/boost/array.hpp>">
-</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">
-<a accesskey="p" href="interval_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="array_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.optional_hpp"></a> Header <boost/conversion/boost/optional.hpp>
-</h3></div></div></div>
-
- Include this file when using conversions between optional of convertible
- types.
- 
-<pre class="programlisting">namespace boost {
- namespace partial_specialization_workaround {
- template < class Target, class Source>
- struct convert_to< optional<Target>, optional<Source> > {
- static optional<Target> apply(optional<Source> const & from);
- };
- template < class Target, class Source>
- struct assign_to< optional<Target>, optional<Source> > {
- static optional<Target>& apply(
- const optional<Target>& from, optional<Target>& to);
- };
-
- }
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="interval_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="array_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/pair_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/pair_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,59 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header <boost/conversion/std/pair.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="complex_hpp.html" title=" Header <boost/conversion/std/complex.hpp>">
-<link rel="next" href="string_hpp.html" title=" Header <boost/conversion/std/string.hpp>">
-</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">
-<a accesskey="p" href="complex_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="string_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.pair_hpp"></a> Header <boost/conversion/std/pair.hpp>
-</h3></div></div></div>
-
- Include this file when using conversions between pairs of convertible types.
- 
-<pre class="programlisting">namespace boost {
- namespace partial_specialization_workaround {
- template < class T1, class T2, class U1, class U2>
- struct convert_to< std::pair<T1,T2>, std::pair<U1,U2> > {
- static std::pair<T1,T2> apply(std::pair<U1,U2> const & from);
- };
- template < class T1, class T2, class U1, class U2>
- struct assign_to< std::pair<T1,T2>, std::pair<U1,U2> > {
- static std::pair<T1,T2>& apply(const std::pair<U1,U2>& from, std::pair<T1,T2>&a
mp; to);
- };
- }
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="complex_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="string_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/rational_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/rational_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,61 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header <boost/conversion/boost/rational.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="string_hpp.html" title=" Header <boost/conversion/std/string.hpp>">
-<link rel="next" href="chrono_posix_time_hpp.html" title=" Header
- <boost/conversion/boost/chrono_posix_time.hpp>">
-</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">
-<a accesskey="p" href="string_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="chrono_posix_time_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.rational_hpp"></a> Header <boost/conversion/boost/rational.hpp>
-</h3></div></div></div>
-
- Include this file when using conversions between rational of convertible
- types.
- 
-<pre class="programlisting">namespace boost {
- namespace partial_specialization_workaround {
- template < class T, class U>
- struct convert_to< rational<T>, rational<U> > {
- inline static rational<T> apply(rational<U> const & from);
- };
- template < class T, class U>
- struct assign_to< rational<T>, rational<U> > {
- inline static rational<T>& apply(const rational<U>& from, rational<T>& to);
- };
- }
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="string_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="chrono_posix_time_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/string_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/string_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,69 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header <boost/conversion/std/string.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="pair_hpp.html" title=" Header <boost/conversion/std/pair.hpp>">
-<link rel="next" href="rational_hpp.html" title=" Header <boost/conversion/boost/rational.hpp>">
-</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">
-<a accesskey="p" href="pair_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="rational_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.string_hpp"></a> Header <boost/conversion/std/string.hpp>
-</h3></div></div></div>
-
- Include this file when using conversions to std::string.
- 
-<pre class="programlisting">namespace boost {
- namespace partial_specialization_workaround {
- template<typename T, typename CharT, typename Traits, typename Alloc>
- struct convert_to< std::basic_string<CharT,Traits,Alloc>, T > {
- static std::basic_string<CharT,Traits,Alloc> apply(T const & from);
- }
- template<typename T, typename CharT, typename Traits, typename Alloc>
- struct assign_to< std::basic_string<CharT,Traits,Alloc>, T > {
- static std::basic_string<CharT,Traits,Alloc>& apply(
- const T& from, std::basic_string<CharT,Traits,Alloc>& to);
- };
- template<typename T, typename CharT, typename Traits, typename Alloc>
- struct convert_to< T, std::basic_string<CharT,Traits,Alloc>> {
- static T apply(std::basic_string<CharT,Traits,Alloc> const & from);
- };
- template<typename T, typename CharT, typename Traits, typename Alloc>
- struct assign_to< T, std::basic_string<CharT,Traits,Alloc>> {
- static void apply(
- const std::basic_string<CharT,Traits,Alloc>& from, T& to);
- };
- }
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="pair_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="rational_hpp.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/tuple_hpp.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/reference/tuple_hpp.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
+++ (empty file)
@@ -1,63 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Header <boost/conversion/boost/tuple.hpp></title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="../../../index.html" title="Toward Boost.Conversion">
-<link rel="up" href="../reference.html" title="Reference">
-<link rel="prev" href="array_hpp.html" title=" Header <boost/conversion/boost/array.hpp>">
-<link rel="next" href="../examples.html" title="Examples">
-</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">
-<a accesskey="p" href="array_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost.conversion.reference.tuple_hpp"></a> Header <boost/conversion/boost/tuple.hpp>
-</h3></div></div></div>
-
- Include this file when using conversions between fusion::tuple of convertible
- types.
- 
-<pre class="programlisting">namespace boost {
- namespace partial_specialization_workaround {
- template < class T1, ..., class Tn, class U1, ..., class Un>
- struct convert_to< boost::fusion::tuple<T1,...,T3>, boost::fusion::tuple<U1,...,U3> > {
- inline static boost::fusion::tuple<T1,...,T3>
- apply(boost::fusion::tuple<U1,...,U3> const & from);
- };
- template < class T1, ..., class Tn, class U1, ..., class Un>
- struct assign_to< boost::fusion::tuple<T1,...,T3>, boost::fusion::tuple<U1,...,U3> > {
- inline static boost::fusion::tuple<T1,...,T3>
- apply(boost::fusion::tuple<U1,...,U3> const & from, boost::fusion::tuple<T1,...,T3>& to);
- };
-
- }
-}
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2009 Vicente J. Botet Escriba
- 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></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="array_hpp.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/users_guide/getting_started.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/users_guide/getting_started.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/users_guide/getting_started.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -42,21 +42,21 @@
 Installing Conversion</a>
</h4></div></div></div>
<a name="boost.conversion.users_guide.getting_started.install.getting_boost_conversion"></a><h5>
-<a name="id4759865"></a>
+<a name="id4813769"></a>
 <a href="getting_started.html#boost.conversion.users_guide.getting_started.install.getting_boost_conversion">Getting
 Boost.Conversion</a>
 </h5>

 You can get the last stable release of Boost.Conversion by downloading
- <code class="literal">conversion.zip</code> from the <a href="http://www.boost-consulting.com/vault/index.php?directory=Concurrent%20Programming" target="_top">Boost
- Vault</a>
+ <code class="literal">conversion.zip</code> from the <a href="http://www.boostpro.com/vault/index.php?action=downloadfile&filename=conversion.zip&directory=Utilities&" target="_top">Boost
+ Vault Utilities directory</a>
 

 You can also access the latest (unstable?) state from the <a href="https://svn.boost.org/svn/boost/sandbox/conversion" target="_top">Boost
 Sandbox</a>.
 
<a name="boost.conversion.users_guide.getting_started.install.building_boost_conversion"></a><h5>
-<a name="id4759915"></a>
+<a name="id4813820"></a>
 <a href="getting_started.html#boost.conversion.users_guide.getting_started.install.building_boost_conversion">Building
 Boost.Conversion</a>
 </h5>
@@ -66,7 +66,7 @@
 in your compiler include path.
 
<a name="boost.conversion.users_guide.getting_started.install.requirements"></a><h5>
-<a name="id4759949"></a>
+<a name="id4813852"></a>
 <a href="getting_started.html#boost.conversion.users_guide.getting_started.install.requirements">Requirements</a>
 </h5>

@@ -77,7 +77,7 @@
 (even if Boost version 1.35.x should works also).
 
<a name="boost.conversion.users_guide.getting_started.install.exceptions_safety"></a><h5>
-<a name="id4812994"></a>
+<a name="id4813887"></a>
 <a href="getting_started.html#boost.conversion.users_guide.getting_started.install.exceptions_safety">Exceptions
 safety</a>
 </h5>
@@ -86,7 +86,7 @@
 of exception safety as long as the underlying parameters provide it.
 
<a name="boost.conversion.users_guide.getting_started.install.thread_safety"></a><h5>
-<a name="id4813020"></a>
+<a name="id4813913"></a>
 <a href="getting_started.html#boost.conversion.users_guide.getting_started.install.thread_safety">Thread
 safety</a>
 </h5>
@@ -94,7 +94,7 @@
 All functions in the library are thread-unsafe except when noted explicitly.
 
<a name="boost.conversion.users_guide.getting_started.install.tested_compilers"></a><h5>
-<a name="id4813045"></a>
+<a name="id4813938"></a>
 <a href="getting_started.html#boost.conversion.users_guide.getting_started.install.tested_compilers">Tested
 compilers</a>
 </h5>

Modified: sandbox/conversion/libs/conversion/doc/html/boost/conversion/users_guide/tutorial.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/boost/conversion/users_guide/tutorial.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/boost/conversion/users_guide/tutorial.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -45,10 +45,11 @@
</h4></div></div></div>

 When you need to make a generic explicit conversion or assignation you
- just need to include the file boost/conversion/convert_to.hpp or boost/conversion/assign_to.hpp
- and just use the boost conversion function.
+ just need to include the file <code class="computeroutput">boost/conversion/convert_to.hpp</code>
+ or <code class="computeroutput">boost/conversion/assign_to.hpp</code> and just use the boost conversion
+ function.
 
-<pre class="programlisting">#include <boost/conversion/std/pair.hpp>
+<pre class="programlisting">#include <boost/conversion/convert_to.hpp>

// ...

@@ -62,8 +63,8 @@
 specific conversions</a>
</h4></div></div></div>

- When you need make a specific conversion you will need to include the specific
- conversion file. E.g.
+ When you need to make a specific conversion you will need to include the
+ specific conversion file. E.g.
 
<pre class="programlisting">#include <boost/conversion/std/pair.hpp>

@@ -72,10 +73,13 @@
</pre>

 Do not forget to include this files when you use a generic class or algorithm
- using the generic convert_to or assign_to, otherwise your program should
- not compile. E.g. if you want to convert a pair of chrono::time_point<>
- to a pair of posix_time::ptime do not forget to include in addition to
- the boost/conversion/std/pair.hpp the file boost/conversion/boost/chrono_posix_time.hpp
+ using the generic <code class="computeroutput">convert_to</code>
+ or <code class="computeroutput">assign_to</code>, otherwise
+ your program should not compile. E.g. if you want to convert a pair of
+ <code class="computeroutput">chrono::time_point<></code>
+ to a pair of <code class="computeroutput">posix_time::ptime</code>
+ do not forget to include in addition to the <code class="computeroutput">boost/conversion/std/pair.hpp</code>
+ the file <code class="computeroutput">boost/conversion/boost/chrono_posix_time.hpp</code>
 
</div>
<div class="section" lang="en">
@@ -85,10 +89,11 @@
 to completly specialize the conversion functions</a>
</h4></div></div></div>

- You can completly specialize the convert_to and assign_to functions as
- you will do for other functions. Just add an complete overload. E.g. if
- you want to add an explicit convertion from a type F to a type T do the
- following:
+ You can completly specialize the <code class="computeroutput">convert_to</code>
+ and <code class="computeroutput">assign_to</code> functions
+ as you will do for other functions. Just add an complete overload. E.g.
+ if you want to add an explicit convertion from a type <code class="computeroutput">F</code>
+ to a type <code class="computeroutput">T</code> do the following:
 
<pre class="programlisting">T convert_to(const F& from);
</pre>
@@ -101,9 +106,10 @@
</h4></div></div></div>

 As it has been explained in the introduction, until you use a C++ compiler
- supporting the new partial specialization of function templates you will
- need to follow partial specialization workaround and partialy specialize
- the partial_specialization_workaround::convert_to class.
+ supporting the partial specialization of function templates you will need
+ to follow partial specialization workaround and partialy specialize the
+ <code class="computeroutput">partial_specialization_workaround::convert_to</code>
+ class.
 
</div>
</div>

Modified: sandbox/conversion/libs/conversion/doc/html/index.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/index.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/index.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -50,18 +50,12 @@
</dl></dd>
<dt>Reference</dt>
<dd><dl>
-<dt> Header <boost/conversion/convert_to.hpp></dt>
-<dt> Header <boost/conversion/assign_to.hpp></dt>
-<dt> Header <boost/conversion/std/complex.hpp></dt>
-<dt> Header <boost/conversion/std/pair.hpp></dt>
-<dt> Header <boost/conversion/std/string.hpp></dt>
-<dt> Header <boost/conversion/boost/rational.hpp></dt>
-<dt><a href="boost/conversion/reference/chrono_posix_time_hpp.html"> Header
- <code class="computeroutput"><boost/conversion/boost/chrono_posix_time.hpp></code></a></dt>
-<dt> Header <boost/conversion/boost/interval.hpp></dt>
-<dt> Header <boost/conversion/boost/optional.hpp></dt>
-<dt> Header <boost/conversion/boost/array.hpp></dt>
-<dt> Header <boost/conversion/boost/tuple.hpp></dt>
+<dt> Header <boost/conversion.hpp></dt>
+<dt>Core</dt>
+<dt><a href="boost/conversion/reference/c___standard_classes_specializations.html">C++
+ Standard classes specializations</a></dt>
+<dt><a href="boost/conversion/reference/boost_classes_specializations.html">Boost
+ classes specializations</a></dt>
</dl></dd>
<dt>Examples</dt>
<dd><dl>
@@ -98,7 +92,7 @@
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: October 05, 2009 at 16:16:23 GMT</td>
+<td align="left">Last revised: October 22, 2009 at 13:57:46 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Modified: sandbox/conversion/libs/conversion/doc/html/standalone_HTML.manifest
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/standalone_HTML.manifest (original)
+++ sandbox/conversion/libs/conversion/doc/html/standalone_HTML.manifest 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -6,17 +6,10 @@
boost/conversion/users_guide/tutorial.html
boost/conversion/users_guide/ext_references.html
boost/conversion/reference.html
-boost/conversion/reference/convert_to_hpp.html
-boost/conversion/reference/assign_to_hpp.html
-boost/conversion/reference/complex_hpp.html
-boost/conversion/reference/pair_hpp.html
-boost/conversion/reference/string_hpp.html
-boost/conversion/reference/rational_hpp.html
-boost/conversion/reference/chrono_posix_time_hpp.html
-boost/conversion/reference/interval_hpp.html
-boost/conversion/reference/optional_hpp.html
-boost/conversion/reference/array_hpp.html
-boost/conversion/reference/tuple_hpp.html
+boost/conversion/reference/conversion_hpp.html
+boost/conversion/reference/core.html
+boost/conversion/reference/c___standard_classes_specializations.html
+boost/conversion/reference/boost_classes_specializations.html
boost/conversion/examples.html
boost/conversion/examples/chrono__time_point_and_posix_time__ptime.html
boost/conversion/examples/boost__optional.html

Added: sandbox/conversion/libs/conversion/doc/index.html
==============================================================================
--- (empty file)
+++ sandbox/conversion/libs/conversion/doc/index.html 2009-10-22 09:59:50 EDT (Thu, 22 Oct 2009)
@@ -0,0 +1,9 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=html/index.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+../../doc/html/conversion.html
+</body>
+</html>

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