Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r72171 - in sandbox/conversion/libs/conversion_ext/doc: . html html/boost
From: vicente.botet_at_[hidden]
Date: 2011-05-25 18:30:58

Author: viboes
Date: 2011-05-25 18:30:57 EDT (Wed, 25 May 2011)
New Revision: 72171
URL: http://svn.boost.org/trac/boost/changeset/72171

Log:
Conversion: Moved to conversion namespace+ updated doc
Removed:
   sandbox/conversion/libs/conversion_ext/doc/html/boost/
Text files modified:
   sandbox/conversion/libs/conversion_ext/doc/Jamfile.v2 | 5
   sandbox/conversion/libs/conversion_ext/doc/html/index.html | 400 ++++++++++++++++++++++++++--------------
   sandbox/conversion/libs/conversion_ext/doc/html/standalone_HTML.manifest | 68 ++++--
   3 files changed, 310 insertions(+), 163 deletions(-)

Modified: sandbox/conversion/libs/conversion_ext/doc/Jamfile.v2
==============================================================================
--- sandbox/conversion/libs/conversion_ext/doc/Jamfile.v2 (original)
+++ sandbox/conversion/libs/conversion_ext/doc/Jamfile.v2 2011-05-25 18:30:57 EDT (Wed, 25 May 2011)
@@ -104,7 +104,7 @@

 project : requirements
 #doxygen common parameters
- <doxygen:param>"PREDEFINED=\"BOOST_ENUMS_DOXYGEN_INVOKED=1\" \\
+ <doxygen:param>"PREDEFINED=\"BOOST_CONVERSION_DOXYGEN_INVOKED=1\" \\
 \"BOOST_STATIC_CONSTEXPR=constexpr\" \\
 \"BOOST_DEDUCED_TYPENAME=typename\" \\
 \"BOOST_EXPLICIT=explicit\" \\
@@ -167,6 +167,7 @@
 :
 [ glob ../../../boost/conversion.hpp ]
 [ glob ../../../boost/conversion/*.hpp ]
+ [ glob ../../../boost/conversion/fp/convert_to.hpp ]
 :
 <xsl:param>"boost.doxygen.reftitle=Core"
 ;
@@ -248,7 +249,7 @@
path-constant boost-root : [ modules.peek : BOOST ] ;
install css-install : $(boost-root)/doc/src/boostbook.css : <location>html ;

-install png-install : [ glob $(boost-root)/doc/src/images/*.png $(boost-root)/boost.png ] : <location>html/images ;
+install png-install : [ glob $(boost-root)/doc/src/images/*.png ] : <location>html/images ;
install svg-install : [ glob $(boost-root)/doc/src/images/*.svg ] : <location>html/images ;

install pdf-install : standalone : <install-type>PDF <location>. <name>enums.pdf ;

Modified: sandbox/conversion/libs/conversion_ext/doc/html/index.html
==============================================================================
--- sandbox/conversion/libs/conversion_ext/doc/html/index.html (original)
+++ sandbox/conversion/libs/conversion_ext/doc/html/index.html 2011-05-25 18:30:57 EDT (Wed, 25 May 2011)
@@ -5,7 +5,7 @@
<link rel="stylesheet" href="./boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.76.0">
<link rel="home" href="index.html" title="Toward Boost.Conversion 0.6.0">
-<link rel="next" href="boost/conversion/partial_specialization__id35972110/assign_to.html" title="Struct template assign_to">
+<link rel="next" href="boost/conversion/overload_workaround/assign_to.html" title="Struct template assign_to">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -17,7 +17,7 @@
<td align="center">More</td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="boost/conversion/partial_specialization__id35972110/assign_to.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="boost/conversion/overload_workaround/assign_to.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
<div class="article">
<div class="titlepage">
<div>
@@ -718,7 +718,7 @@
<pre class="programlisting">#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);
+std::pair<double,double> pdouble=boost::conversion::convert_to<std::pair<double,double> >(pint);
</pre>

 Do not forget to include this files when you use a generic class or algorithm
@@ -864,8 +864,8 @@
#include <boost/config.hpp>

namespace boost {
- #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
- namespace conversion { namespace partial_specialization_workaround {
+ #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING && ! defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ namespace conversion { namespace overload_workaround {
 template < class Clock, class Duration>
 struct convert_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
 inline static posix_time::ptime apply(const chrono::time_point<Clock, Duration>& from)
@@ -889,7 +889,7 @@
 struct assign_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
 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);
+ to = boost::conversion::convert_to<posix_time::ptime>(from);
 return to;
 }
 };
@@ -908,7 +908,7 @@
 struct assign_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
 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);
+ to = boost::conversion::convert_to<chrono::time_point<Clock, Duration> >(from);
 return to;
 }
 };
@@ -940,7 +940,7 @@
 , boost::dummy::type_tag<chrono::time_point<Clock, Duration> > const&
 )
 {
- to = boost::convert_to<chrono::time_point<Clock, Duration> >(from);
+ to = boost::conversion::convert_to<chrono::time_point<Clock, Duration> >(from);
 return to;
 }

@@ -963,7 +963,7 @@
 , boost::dummy::type_tag<posix_time::ptime> const&
 )
 {
- to = boost::convert_to<ptime>(from);
+ to = boost::conversion::convert_to<ptime>(from);
 return to;
 }

@@ -994,42 +994,92 @@

namespace boost {

- #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
- namespace conversion { namespace partial_specialization_workaround {
- template < class Target, class Source>
- struct convert_to< optional<Target>, optional<Source> > {
- inline static optional<Target> apply(optional<Source> const & from)
- {
- return (from?optional<Target>(boost::convert_to<Target>(from.get())):optional<Target>());
- }
- };
- template < class Target, class Source>
- struct assign_to< optional<Target>, optional<Source> > {
- inline static optional<Target>& apply(optional<Target>& to, const optional<Source>& from)
- {
- to = from?boost::convert_to<Target>(from.get()):optional<Target>();
- return to;
- }
- };
-
- }}
- #else
- template < class Target, class Source>
- inline optional<Target> convert_to(optional<Source> const & from
- , boost::dummy::type_tag<optional<Target> > const&)
- {
- return (from?optional<Target>(boost::convert_to<Target>(from.get())):optional<Target>());
+ #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING && ! defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ namespace conversion {
+ namespace overload_workaround {
+ template < class Target, class Source>
+ struct convert_to< optional<Target>, optional<Source> >
+ {
+ inline static optional<Target> apply(optional<Source> const & from)
+ {
+ return (from?optional<Target>(boost::conversion::convert_to<Target>(from.get())):optional<Target>());
+ }
+ };
+
+ template < class Target, class Source>
+ struct convert_to< optional<Target>, Source >
+ {
+ inline static optional<Target> apply(Source const & from)
+ {
+ try
+ {
+ return optional<Target>(boost::conversion::convert_to<Target>(from));
+ }
+ catch (...)
+ {
+ return optional<Target>();
+ }
+ }
+ };
+
+ template < class Target, class Source>
+ struct assign_to< optional<Target>, optional<Source> >
+ {
+ inline static optional<Target>& apply(optional<Target>& to, const optional<Source>& from)
+ {
+ to = from?optional<Target>(boost::conversion::convert_to<Target>(from.get())):optional<Target>();
+ return to;
+ }
+ };
+
 }
+ }
+#else

- template < class Target, class Source>
- inline optional<Target>& assign_to(optional<Target>& to, const optional<Source>& from
- , boost::dummy::type_tag<optional<Target> > const&
- )
+ //! @brief @c convert_to overloading for source and target been @c boost::optional.
+ //!
+ //! @Returns If the optional source is initialized @c boost::optional<Target> initialized to the conversion of the optional value.
+ //! Uninitialized @c boost::optional<Target otherwise.
+ template < class Target, class Source>
+ inline optional<Target> convert_to(optional<Source> const & from
+ , boost::dummy::type_tag<optional<Target> > const&)
+ {
+ return (from?optional<Target>(boost::conversion::convert_to<Target>(from.get())):optional<Target>());
+ }
+
+ //! @brief @c convert_to overloading to try to convert the source to the target.
+ //!
+ //! We can see this specialization as a try_convert_to function.
+ //! @Returns If the source is convertible to the target @c boost::optional<Target> initialized to the result of the conversion.
+ //! Uninitialized @c boost::optional<Target otherwise.
+ template < class Target, class Source>
+ inline optional<Target> convert_to(Source const & from
+ , boost::dummy::type_tag<optional<Target> > const&)
+ {
+ try
+ {
+ return optional<Target>(boost::conversion::convert_to<Target>(from));
+ }
+ catch (...)
 {
- to = from?boost::convert_to<Target>(from.get()):optional<Target>();
- return to;
+ return optional<Target>();
 }
- #endif
+ }
+
+ //! @brief @c assign_to overloading for source and target been @c boost::optional.
+ //!
+ //! @Effects As if <c>to = boost::conversion::convert_to<optional<Target> >(from)</c>.
+ //! @Returns The @c to parameter reference.
+ template < class Target, class Source>
+ inline optional<Target>& assign_to(optional<Target>& to, const optional<Source>& from
+ , boost::dummy::type_tag<optional<Target> > const&
+ )
+ {
+ to = boost::conversion::convert_to<optional<Target> >(from);
+ //to = from?optional<Target>(boost::conversion::convert_to<Target>(from.get())):optional<Target>();
+ return to;
+ }
+#endif
}

#endif
@@ -1055,20 +1105,20 @@
namespace boost { namespace conversion {

 // std namespace can not be overloaded
- namespace partial_specialization_workaround {
+ namespace overload_workaround {
 template < class T1, class T2, class U1, class U2>
 struct convert_to< std::pair<T1,T2>, std::pair<U1,U2> > {
 inline static std::pair<T1,T2> apply(std::pair<U1,U2> const & from)
 {
- return std::pair<T1,T2>(boost::convert_to<T1>(from.first), boost::convert_to<T2>(from.second));
+ return std::pair<T1,T2>(boost::conversion::convert_to<T1>(from.first), boost::conversion::convert_to<T2>(
from.second));
 }
 };
 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(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);
+ to.first = boost::conversion::convert_to<T1>(from.first);
+ to.second = boost::conversion::convert_to<T2>(from.second);
 return to;
 }
 };
@@ -1138,9 +1188,13 @@
<dt>Header <boost/conversion/assign_to.hpp></dt>
<dt>Header <boost/conversion/ca_wrapper.hpp></dt>
<dt>Header <boost/conversion/convert_to.hpp></dt>
+<dt>Header <boost/conversion/fp/convert_to.hpp></dt>
+<dt>Header <boost/conversion/convert_to_or_fallback.hpp></dt>
<dt>Header <boost/conversion/convert_to_via.hpp></dt>
<dt>Header <boost/conversion/include.hpp></dt>
<dt>Header <boost/conversion/pack.hpp></dt>
+<dt>Header <boost/conversion/try_assign_to.hpp></dt>
+<dt>Header <boost/conversion/try_convert_to.hpp></dt>
</dl></dd>
<dt>C++ Standard classes specializations</dt>
<dd><dl>
@@ -1170,10 +1224,18 @@
<dd><dl></dl></dd>
<dt>Header <boost/conversion/convert_to.hpp></dt>
<dd><dl></dl></dd>
+<dt>Header <boost/conversion/fp/convert_to.hpp></dt>
+<dd><dl></dl></dd>
+<dt>Header <boost/conversion/convert_to_or_fallback.hpp></dt>
+<dd><dl></dl></dd>
<dt>Header <boost/conversion/convert_to_via.hpp></dt>
<dt>Header <boost/conversion/include.hpp></dt>
<dt>Header <boost/conversion/pack.hpp></dt>
<dd><dl></dl></dd>
+<dt>Header <boost/conversion/try_assign_to.hpp></dt>
+<dd><dl></dl></dd>
+<dt>Header <boost/conversion/try_convert_to.hpp></dt>
+<dd><dl></dl></dd>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
@@ -1181,22 +1243,19 @@
Defines the free function <code class="computeroutput">assign_to</code>. 
The function <code class="computeroutput">assign_to</code> assigns the <code class="computeroutput">from</code> parameter to the <code class="computeroutput">to</code> parameter. The default implementation applies the the assignment 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.
The user can add the <code class="computeroutput">assign_to</code> overloading on the namespace of the Source or Target classes. But sometimes as it is the case for the standard classes, we can not add new functions on the std namespace, so we need a different technique.
-The technique consists in partially specialize on the function <code class="computeroutput">assign_to</code> on the <code class="computeroutput">boost::conversion</code> namespace. For compilers for which 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 <code class="computeroutput">partial_specialization_workaround</code>. Thus the user can specialize partially this class. 
+The technique consists in partially specialize on the function <code class="computeroutput">assign_to</code> on the <code class="computeroutput">boost::conversion</code> namespace. For compilers for which 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 <code class="computeroutput">overload_workaround</code>. Thus the user can specialize partially this class. 
<pre class="synopsis">namespace boost {
- template<typename Target, typename Source>
- Target & <a class="link" href="boost/assign_to_id35972207.html" title="Function template assign_to">assign_to</a>(Target &, const Source &,
- <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target > const & = <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target >());
 namespace conversion {
- template<typename To, typename From>
- To & <a name="boost.conversion.assign_to_id35972146"></a>assign_to(To & to, const From & from,
- <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">dummy::type_tag</a>< To > const &);
- namespace partial_specialization_workaround {
- template<typename To, typename From> struct <a class="link" href="boost/conversion/partial_specialization__id35972110/assign_to.html" title="Struct template assign_to">assign_to</a>;
+ template<typename Target, typename Source>
+ Target & <a class="link" href="boost/conversion/assign_to_id35974124.html" title="Function template assign_to">assign_to</a>(Target &, const Source &,
+ <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target > const & = <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target >());
+ namespace overload_workaround {
+ template<typename To, typename From> struct <a class="link" href="boost/conversion/overload_workaround/assign_to.html" title="Struct template assign_to">assign_to</a>;
 }
 }
- namespace conversion_impl {
- template<typename Target, typename Source>
- Target & <a name="boost.conversion_impl.assign_to_impl"></a>assign_to_impl(Target & to, const Source & from);
+ namespace conversion_2 {
+ template<typename To, typename From>
+ To & <a class="link" href="boost/conversion_2/assign_to_id35974194.html" title="Function template assign_to">assign_to</a>(To &, const From &, <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">dummy::type_tag</a>< To > const &);
 }
}</pre>
</div>
@@ -1215,24 +1274,19 @@
<div class="titlepage"><div><div><h4 class="title">
<a name="header.boost.conversion.convert_to_hpp"></a>Header <boost/conversion/convert_to.hpp></h4></div></div></div>
Defines the free function <code class="computeroutput">convert_to</code>. 
-The <code class="computeroutput">convert_to</code> function 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. Of course if both exist the conversion is ambiguous. 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.
+The <code class="computeroutput">convert_to</code> function 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. Of course if both exist the conversion is ambiguous. A user adapting another type could need to overload the <code class="computeroutput">convert_to</code> free function if the default behavior is not satisfactory.
The user can add the <code class="computeroutput">convert_to</code> overloading on any namespace found by ADL from the <code class="computeroutput">Source</code> or the <code class="computeroutput">Target</code>. A trick is used to overload on the return type by adding a dummy parameter having the Target.
-But sometimes, as it is the case for the standard classes, we can not add new functions on the std namespace, so we need a different technique.
-The technique consists in partially specialize on the function <code class="computeroutput">convert_to</code> on the <code class="computeroutput">boost::conversion</code> namespace. For compilers for which 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 apply on a class with the same name in the namespace <code class="computeroutput">partial_specialization_workaround</code>. Thus the user can specialize partially this class. 
+But sometimes, as it is the case for the standard classes, we can not add new functions on the <code class="computeroutput">std</code> namespace, so we need a different technique.
+Instead of calling directly to the conversion operator, <code class="computeroutput">convert_to</code> calls to the static operation apply on a class with the same name in the namespace <code class="computeroutput">boost::conversion::overload_workaround</code>. Thus the user can specialize partially this class. 
<pre class="synopsis">namespace boost {
- template<typename Target, typename Source>
- Target <a class="link" href="boost/convert_to_id35972717.html" title="Function template convert_to">convert_to</a>(Source const &,
- <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target > const & = <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target >());
 namespace conversion {
- template<typename To, typename From>
- To <a name="boost.conversion.convert_to_id35972637"></a>convert_to(const From & val, <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">dummy::type_tag</a>< To > const &);
- namespace partial_specialization_workaround {
- template<typename To, typename From> struct <a class="link" href="boost/conversion/partial_specialization__id35972604/convert_to.html" title="Struct template convert_to">convert_to</a>;
- }
- }
- namespace conversion_impl {
+ template<typename T, typename Enabled = void> struct <a class="link" href="boost/conversion/enable_functor.html" title="Struct template enable_functor">enable_functor</a>;
 template<typename Target, typename Source>
- Target <a name="boost.conversion_impl.convert_to_impl"></a>convert_to_impl(Source const & from);
+ Target <a class="link" href="boost/conversion/convert_to_id35974710.html" title="Function template convert_to">convert_to</a>(Source const &,
+ <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target > const & = <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target >());
+ namespace overload_workaround {
+ template<typename To, typename From> struct <a class="link" href="boost/conversion/overload_workaround/convert_to.html" title="Struct template convert_to">convert_to</a>;
+ }
 }
 namespace dummy {
 template<typename T> struct <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">base_tag</a>;
@@ -1242,6 +1296,41 @@
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
+<a name="header.boost.conversion.fp.convert_to_hpp"></a>Header <boost/conversion/fp/convert_to.hpp></h4></div></div></div>
+<pre class="synopsis">namespace boost {
+ namespace conversion {
+ template<typename T>
+ struct <a class="link" href="boost/conversion/enable_functor_T__typen_id35974986.html" title="Struct template enable_functor<T, typename enable_if< phoenix::is_actor< T > >::type>">enable_functor</a><T, typename enable_if< phoenix::is_actor< T > >::type>;
+ template<typename T, typename U> unspecified <a class="link" href="boost/conversion/convert_to_id35975024.html" title="Function template convert_to">convert_to</a>(U const &);
+ }
+}</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="header.boost.conversion.convert_to_or_fallback_hpp"></a>Header <boost/conversion/convert_to_or_fallback.hpp></h4></div></div></div>
+Defines the free function <code class="computeroutput">convert_to_or_fallback</code>. 
+The <code class="computeroutput">convert_to_or_fallback</code> function converts the <code class="computeroutput">from</code> parameter to a <code class="computeroutput">To</code> type. If the conversion fails the fallback value is used to construct a To <code class="computeroutput">instance</code>.
+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. When an exception is thrown the falback is returned. Of course if both exist the conversion is ambiguous. A user adapting another type could need to specialize the <code class="computeroutput">convert_to_or_fallback</code> free function if the default behavior is not satisfactory.
+The user can add the <code class="computeroutput">convert_to_or_fallback</code> overloading on any namespace found by ADL from the <code class="computeroutput">Source</code> or the <code class="computeroutput">Target</code>. A trick is used to overload on the return type by adding a dummy parameter having the Target.
+But sometimes, as it is the case for the standard classes, we can not add new functions on the std namespace, so we need a different technique.
+The technique consists in partially specialize on the function <code class="computeroutput">convert_to_or_fallback</code> on the <code class="computeroutput">boost::conversion</code> namespace. For compilers for which we can not partially specialize a function a trick is used: instead of calling directly to the <code class="computeroutput">convert_to_or_fallback</code> member function, <code class="computeroutput">convert_to_or_fallback</code> calls to the static operation apply on a class with the same name in the namespace <code class="computeroutput">overload_workaround</code>. Thus the user can specialize partially this class. 
+<pre class="synopsis">namespace boost {
+ template<typename Target, typename Source, typename Fallback>
+ Target <a class="link" href="boost/convert_to_or_fallback_id35975332.html" title="Function template convert_to_or_fallback">convert_to_or_fallback</a>(Source const &, Fallback const &,
+ <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target > const & = <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target >());
+ namespace conversion {
+ template<typename To, typename From, typename Fallback>
+ To <a class="link" href="boost/conversion/convert_to_or_fallback_id35975263.html" title="Function template convert_to_or_fallback">convert_to_or_fallback</a>(const From &, Fallback const &,
+ <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">dummy::type_tag</a>< To > const &);
+ namespace overload_workaround {
+ template<typename To, typename From, typename Fallback>
+ struct <a class="link" href="boost/conversion/overload_workaround/convert_to_or_fallback.html" title="Struct template convert_to_or_fallback">convert_to_or_fallback</a>;
+ }
+ }
+}</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
<a name="header.boost.conversion.convert_to_via_hpp"></a>Header <boost/conversion/convert_to_via.hpp></h4></div></div></div>
<pre class="synopsis">namespace boost {
 namespace conversion {
@@ -1264,22 +1353,22 @@
 namespace conversion {
 template<typename T1, typename T2>
 <a class="link" href="boost/conversion/result_of/pack2.html" title="Struct template pack2">boost::conversion::result_of::pack2</a>< T1 const, T2 const >::type
- <a class="link" href="boost/conversion/pack_id35972919.html" title="Function template pack">pack</a>(T1 const &, T2 const &);
+ <a class="link" href="boost/conversion/pack_id35975535.html" title="Function template pack">pack</a>(T1 const &, T2 const &);
 template<typename T1, typename T2>
 <a class="link" href="boost/conversion/result_of/pack2.html" title="Struct template pack2">boost::conversion::result_of::pack2</a>< T1 const, T2 >::type
- <a class="link" href="boost/conversion/pack_id35972952.html" title="Function template pack">pack</a>(T1 const &, T2 &);
+ <a class="link" href="boost/conversion/pack_id35975568.html" title="Function template pack">pack</a>(T1 const &, T2 &);
 template<typename T1, typename T2, typename T3>
 <a class="link" href="boost/conversion/result_of/pack3.html" title="Struct template pack3">boost::conversion::result_of::pack3</a>< T1 const, T2 const, T3 const >::type
- <a class="link" href="boost/conversion/pack_id35972984.html" title="Function template pack">pack</a>(T1 const &, T2 const &, T3 const &);
+ <a class="link" href="boost/conversion/pack_id35975600.html" title="Function template pack">pack</a>(T1 const &, T2 const &, T3 const &);
 template<typename T1, typename T2, typename T3>
 <a class="link" href="boost/conversion/result_of/pack3.html" title="Struct template pack3">boost::conversion::result_of::pack3</a>< T1 const, T2 const, T3 >::type
- <a class="link" href="boost/conversion/pack_id35973027.html" title="Function template pack">pack</a>(T1 const &, T2 const &, T3 &);
+ <a class="link" href="boost/conversion/pack_id35975643.html" title="Function template pack">pack</a>(T1 const &, T2 const &, T3 &);
 template<typename T1, typename T2, typename T3>
 <a class="link" href="boost/conversion/result_of/pack3.html" title="Struct template pack3">boost::conversion::result_of::pack3</a>< T1 const, T2, T3 const >::type
- <a class="link" href="boost/conversion/pack_id35973070.html" title="Function template pack">pack</a>(T1 const &, T2 &, T3 const &);
+ <a class="link" href="boost/conversion/pack_id35975686.html" title="Function template pack">pack</a>(T1 const &, T2 &, T3 const &);
 template<typename T1, typename T2, typename T3>
 <a class="link" href="boost/conversion/result_of/pack3.html" title="Struct template pack3">boost::conversion::result_of::pack3</a>< T1 const, T2, T3 >::type
- <a class="link" href="boost/conversion/pack_id35973112.html" title="Function template pack">pack</a>(T1 const &, T2 &, T3 &);
+ <a class="link" href="boost/conversion/pack_id35975728.html" title="Function template pack">pack</a>(T1 const &, T2 &, T3 &);
 namespace result_of {
 template<typename T1, typename T2> struct <a class="link" href="boost/conversion/result_of/pack2.html" title="Struct template pack2">pack2</a>;
 template<typename T1, typename T2, typename T3 = fusion::void_>
@@ -1288,6 +1377,52 @@
 }
}</pre>
</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="header.boost.conversion.try_assign_to_hpp"></a>Header <boost/conversion/try_assign_to.hpp></h4></div></div></div>
+Defines the free function <code class="computeroutput">try_assign_to</code>. 
+The function <code class="computeroutput">try_assign_to</code> assigns the <code class="computeroutput">from</code> parameter to the <code class="computeroutput">to</code> parameter. Return <code class="computeroutput">true</code> if assignation done and <code class="computeroutput">false</code> otherwise. The default implementation applies the the assignment operator of the <code class="computeroutput">To</code> class. A user adapting another type could need to specialize the <code class="computeroutput">try_assign_to</code> free function if the default behavior is not satisfactory ot if it can improve the performances
+The user can add the <code class="computeroutput">try_assign_to</code> overloading on the namespace of the Source or Target classes. But sometimes as it is the case for the standard classes, we can not add new functions on the std namespace, so we need a different technique.
+The technique consists in partially specialize on the function <code class="computeroutput">try_assign_to</code> on the <code class="computeroutput">boost::conversion</code> namespace. For compilers for which we can not partially specialize a function a trick is used: instead of calling directly to the <code class="computeroutput">try_assign_to</code> member function, <code class="computeroutput">try_assign_to</code> calls to the static operation apply on a class with the same name in the namespace <code class="computeroutput">overload_workaround</code>. Thus the user can specialize partially this class. 
+<pre class="synopsis">namespace boost {
+ template<typename Target, typename Source>
+ bool <a class="link" href="boost/try_assign_to_id35975967.html" title="Function template try_assign_to">try_assign_to</a>(Target &, const Source &,
+ <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target > const & = <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target >());
+ namespace conversion {
+ template<typename To, typename From>
+ bool <a class="link" href="boost/conversion/try_assign_to_id35975910.html" title="Function template try_assign_to">try_assign_to</a>(To &, const From &, <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">dummy::type_tag</a>< To > const &);
+ namespace overload_workaround {
+ template<typename To, typename From> struct <a class="link" href="boost/conversion/overload_workaround/try_assign_to.html" title="Struct template try_assign_to">try_assign_to</a>;
+ }
+ }
+}</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="header.boost.conversion.try_convert_to_hpp"></a>Header <boost/conversion/try_convert_to.hpp></h4></div></div></div>
+Defines the free function <code class="computeroutput">try_convert_to</code>. 
+The <code class="computeroutput">try_convert_to</code> function converts the <code class="computeroutput">from</code> parameter to a <code class="computeroutput">To</code> type and returns an optional<To>, uninitialized if conversion fails.
+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 on a try-catch block and returns optional with the converted value if suceeds and an uninitialized optional otherwise. Of course if both exist the conversion is ambiguous. A user adapting specific types could need to specialize the <code class="computeroutput">try_convert_to</code> free function if the default behavior is not satisfactory or if the specialization can perform better.
+The user can add the <code class="computeroutput">try_convert_to</code> overloading on any namespace found by ADL from the <code class="computeroutput">Source</code> or the <code class="computeroutput">Target</code>. A trick is used to overload on the return type by adding a dummy parameter having the Target.
+But sometimes, as it is the case for the standard classes, we can not add new functions on the std namespace, so we need a different technique.
+The technique consists in partially specialize on the function <code class="computeroutput">try_convert_to</code> on the <code class="computeroutput">boost::conversion</code> namespace. For compilers for which we can not partially specialize a function a trick is used: instead of calling directly to the <code class="computeroutput">try_convert_to</code> member function, <code class="computeroutput">try_convert_to</code> calls to the static operation apply on a class with the same name in the namespace <code class="computeroutput">overload_workaround</code>. Thus the user can specialize partially this class. 
+<pre class="synopsis">namespace boost {
+ namespace conversion {
+ template<typename Target, typename Source>
+ optional< Target >
+ <a class="link" href="boost/conversion/try_convert_to_id35976188.html" title="Function template try_convert_to">try_convert_to</a>(Source const &,
+ <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target > const & = <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a>< Target >());
+ namespace overload_workaround {
+ template<typename To, typename From> struct <a class="link" href="boost/conversion/overload_workaround/try_convert_to.html" title="Struct template try_convert_to">try_convert_to</a>;
+ }
+ }
+ namespace conversion_2 {
+ template<typename To, typename From>
+ optional< To >
+ <a class="link" href="boost/conversion_2/try_convert_to_id35976260.html" title="Function template try_convert_to">try_convert_to</a>(const From &, <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">dummy::type_tag</a>< To > const &);
+ }
+}</pre>
+</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -1328,11 +1463,16 @@
<a name="boost_classes_specializations"></a>Boost classes specializations</h3></div></div></div>
<div class="toc"><dl>
<dt>Header <boost/array.hpp></dt>
+<dd><dl></dl></dd>
<dt>Header <boost/chrono_duration_to_posix_time_duration.hpp></dt>
+<dd><dl></dl></dd>
<dt>Header <boost/chrono_time_point_to_posix_time_ptime.hpp></dt>
<dt>Header <boost/interval.hpp></dt>
+<dd><dl></dl></dd>
<dt>Header <boost/optional.hpp></dt>
+<dd><dl></dl></dd>
<dt>Header <boost/rational.hpp></dt>
+<dd><dl></dl></dd>
<dt>Header <boost/tuple.hpp></dt>
</dl></div>
<div class="section">
@@ -1342,11 +1482,11 @@
<pre class="synopsis">namespace boost {
 template<typename T1, typename T2, std::size_t N>
 array< T1, N >
- <a name="boost.convert_to_id35973470"></a>convert_to(array< T2, N > const & from,
+ <a class="link" href="boost/convert_to_id35972629.html" title="Function template convert_to">convert_to</a>(array< T2, N > const &,
 boost::dummy::type_tag< array< T1, N > > const &);
 template<typename T1, typename T2, std::size_t N>
 array< T1, N > &
- <a name="boost.assign_to_id35973501"></a>assign_to(array< T1, N > & to, array< T2, N > const & from,
+ <a class="link" href="boost/assign_to_id35972676.html" title="Function template assign_to">assign_to</a>(array< T1, N > &, array< T2, N > const &,
 boost::dummy::type_tag< array< T1, N > > const &);
}</pre>
</div>
@@ -1358,22 +1498,21 @@
 namespace chrono {
 template<typename Rep, typename Period>
 posix_time::time_duration
- <a name="boost.chrono.convert_to_id35973559"></a>convert_to(chrono::duration< Rep, Period > const & from,
+ <a class="link" href="boost/chrono/convert_to_id35972763.html" title="Function template convert_to">convert_to</a>(chrono::duration< Rep, Period > const &,
 boost::dummy::type_tag< posix_time::time_duration > const &);
 template<typename Rep, typename Period>
 chrono::duration< Rep, Period > &
- <a name="boost.chrono.assign_to_id35973587"></a>assign_to(chrono::duration< Rep, Period > & to,
- const posix_time::time_duration & from,
+ <a class="link" href="boost/chrono/assign_to_id35972810.html" title="Function template assign_to">assign_to</a>(chrono::duration< Rep, Period > &,
+ const posix_time::time_duration &,
 boost::dummy::type_tag< chrono::duration< Rep, Period > > const &);
 }
 namespace posix_time {
 template<typename Duration>
- Duration <a name="boost.posix_time.convert_to_id35973623"></a>convert_to(time_duration const & from,
+ Duration <a class="link" href="boost/posix_time/convert_to_id35972880.html" title="Function template convert_to">convert_to</a>(time_duration const &,
 boost::dummy::type_tag< Duration > const &);
 template<typename Rep, typename Period>
 time_duration &
- <a name="boost.posix_time.assign_to_id35973646"></a>assign_to(time_duration & to,
- const chrono::duration< Rep, Period > & from,
+ <a class="link" href="boost/posix_time/assign_to_id35972927.html" title="Function template assign_to">assign_to</a>(time_duration &, const chrono::duration< Rep, Period > &,
 boost::dummy::type_tag< posix_time::time_duration > const &);
 }
}</pre>
@@ -1386,19 +1525,19 @@
 namespace chrono {
 template<typename Clock, typename Duration>
 posix_time::ptime
- <a name="boost.chrono.convert_to_id35973702"></a>convert_to(const chrono::time_point< Clock, Duration > & from,
+ <a name="boost.chrono.convert_to_id35973016"></a>convert_to(const chrono::time_point< Clock, Duration > & from,
 boost::dummy::type_tag< posix_time::ptime > const &);
 template<typename Clock, typename Duration>
 chrono::time_point< Clock, Duration > &
- <a name="boost.chrono.assign_to_id35973729"></a>assign_to(chrono::time_point< Clock, Duration > & to,
+ <a name="boost.chrono.assign_to_id35973044"></a>assign_to(chrono::time_point< Clock, Duration > & to,
 const posix_time::ptime & from,
 boost::dummy::type_tag< chrono::time_point< Clock, Duration > > const &);
 }
 namespace posix_time {
 template<typename TP>
- TP <a name="boost.posix_time.convert_to_id35973766"></a>convert_to(const ptime & from, boost::dummy::type_tag< TP > const &);
+ TP <a name="boost.posix_time.convert_to_id35973080"></a>convert_to(const ptime & from, boost::dummy::type_tag< TP > const &);
 template<typename Clock, typename Duration>
- ptime & <a name="boost.posix_time.assign_to_id35973788"></a>assign_to(ptime & to,
+ ptime & <a name="boost.posix_time.assign_to_id35973103"></a>assign_to(ptime & to,
 const chrono::time_point< Clock, Duration > & from,
 boost::dummy::type_tag< posix_time::ptime > const &);
 }
@@ -1412,11 +1551,11 @@
 namespace numeric {
 template<typename T, typename PT, typename U, typename PU>
 interval< T, PT >
- <a name="boost.numeric.convert_to_id35973837"></a>convert_to(interval< U, PU > const & from,
+ <a class="link" href="boost/numeric/convert_to_id35973151.html" title="Function template convert_to">convert_to</a>(interval< U, PU > const &,
 boost::dummy::type_tag< interval< T, PT > > const &);
 template<typename T, typename PT, typename U, typename PU>
 interval< T, PT > &
- <a name="boost.numeric.assign_to_id35973873"></a>assign_to(interval< T, PT > & to, const interval< U, PU > & from,
+ <a name="boost.numeric.assign_to_id35971986"></a>assign_to(interval< T, PT > & to, const interval< U, PU > & from,
 boost::dummy::type_tag< interval< T, PT > > const &);
 }
}</pre>
@@ -1428,11 +1567,15 @@
<pre class="synopsis">namespace boost {
 template<typename Target, typename Source>
 optional< Target >
- <a name="boost.convert_to_id35973927"></a>convert_to(optional< Source > const & from,
+ <a class="link" href="boost/convert_to_id35976383.html" title="Function template convert_to">convert_to</a>(optional< Source > const &,
+ boost::dummy::type_tag< optional< Target > > const &);
+ template<typename Target, typename Source>
+ optional< Target >
+ <a class="link" href="boost/convert_to_id35976434.html" title="Function template convert_to">convert_to</a>(Source const &,
 boost::dummy::type_tag< optional< Target > > const &);
 template<typename Target, typename Source>
 optional< Target > &
- <a name="boost.assign_to_id35973954"></a>assign_to(optional< Target > & to, const optional< Source > & from,
+ <a class="link" href="boost/assign_to_id35976485.html" title="Function template assign_to">assign_to</a>(optional< Target > &, const optional< Source > &,
 boost::dummy::type_tag< optional< Target > > const &);
}</pre>
</div>
@@ -1443,11 +1586,11 @@
<pre class="synopsis">namespace boost {
 template<typename T, typename U>
 rational< T >
- <a name="boost.convert_to_id35974000"></a>convert_to(rational< U > const & from,
+ <a class="link" href="boost/convert_to_id35976560.html" title="Function template convert_to">convert_to</a>(rational< U > const &,
 boost::dummy::type_tag< rational< T > > const &);
 template<typename T, typename U>
 rational< T > &
- <a name="boost.assign_to_id35974027"></a>assign_to(rational< T > & to, const rational< U > & from,
+ <a name="boost.assign_to_id35976604"></a>assign_to(rational< T > & to, const rational< U > & from,
 boost::dummy::type_tag< rational< T > > const &);
}</pre>
</div>
@@ -1455,29 +1598,6 @@
<div class="titlepage"><div><div><h4 class="title">
<a name="header.boost.tuple_hpp"></a>Header <boost/tuple.hpp></h4></div></div></div>
Include this file when using conversions between <code class="computeroutput">boost::fusion::tuple<></code> of convertible types. 
-<pre class="synopsis">namespace boost {
- namespace fusion {
- template<typename T1, typename T2, typename U1, typename U2>
- tuple< T1, T2 >
- <a name="boost.fusion.convert_to_id35974075"></a>convert_to(tuple< U1, U2 > const & from,
- boost::dummy::type_tag< tuple< T1, T2 > > const &);
- template<typename T1, typename T2, typename U1, typename U2>
- tuple< T1, T2 > &
- <a name="boost.fusion.assign_to_id35974111"></a>assign_to(tuple< T1, T2 > & to, tuple< U1, U2 > const & from,
- boost::dummy::type_tag< tuple< T1, T2 > > const &);
- template<typename T1, typename T2, typename T3, typename U1, typename U2,
- typename U3>
- tuple< T1, T2, T3 >
- <a name="boost.fusion.convert_to_id35974153"></a>convert_to(tuple< U1, U2, U3 > const & from,
- boost::dummy::type_tag< tuple< T1, T2, T3 > > const &);
- template<typename T1, typename T2, typename T3, typename U1, typename U2,
- typename U3>
- tuple< T1, T2, T3 >
- <a name="boost.fusion.assign_to_id35974197"></a>assign_to(tuple< T1, T2, T3 > & to,
- boost::fusion::tuple< U1, U2, U3 > const & from,
- boost::dummy::type_tag< tuple< T1, T2, T3 > > const &);
- }
-}</pre>
</div>
</div>
</div>
@@ -1733,7 +1853,7 @@
<a name="boost.conversion.appendices.rationale"></a><a class="link" href="index.html#boost.conversion.appendices.rationale" title="Appendix B: Rationale">Appendix B: Rationale</a>
</h3></div></div></div>
<a name="boost.conversion.appendices.rationale.trick_to_avoid_recursion_on_the_convert_to_calls"></a><h5>
-<a name="id36369754"></a>
+<a name="id36377583"></a>
 <a class="link" href="index.html#boost.conversion.appendices.rationale.trick_to_avoid_recursion_on_the_convert_to_calls">Trick
 to avoid recursion on the convert_to calls</a>
 </h5>
@@ -1743,23 +1863,23 @@
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
 <code class="computeroutput">conversion_impl</code> is put
- outside the boost namespace, to avoid infinite recursion (causing stack
- overflow) when converting objects of a primitive type.
+ outside the boost::conversion namespace, to avoid infinite recursion
+ (causing stack overflow) when converting objects of a primitive type.
 </li>
<li class="listitem">
 <code class="computeroutput">conversion_impl</code> has a
 using-directive <code class="computeroutput">using namespace
- boost::conversion;</code>,
+ boost::conversion_2;</code>,
 rather than a using-declaration, because some compilers (including MSVC
 7.1, Borland 5.9.3, and Intel 8.1) don't do argument-dependent lookup
 when it has a using-declaration instead.
 </li>
<li class="listitem">
- <code class="computeroutput">boost::convert_to</code> has an additional template
+ <code class="computeroutput">boost::conversion::convert_to</code> has an additional template
 argument, a tag, to avoid ambiguity between the <code class="computeroutput">boost::conversion::convert_to</code>
- and <code class="computeroutput">boost::convert_to</code> and the when converting
- from objects of a Boost type that does not have its own <code class="computeroutput">boost::convert_to</code> overload. This additional
- argument is a reference to a base tag class <code class="computeroutput">dummy::base_tag<Target> const&</code> for the <code class="computeroutput">boost::convert_to</code>
+ and <code class="computeroutput">boost::conversion_2::convert_to</code> and the when converting
+ from objects of a Boost type that does not have its own <code class="computeroutput">boost::conversion::convert_to</code> overload. This additional
+ argument is a reference to a base tag class <code class="computeroutput">dummy::base_tag<Target> const&</code> for the <code class="computeroutput">boost::conversion::convert_to</code>
 and a reference derived tag class <code class="computeroutput">dummy::type_tag<To> const&</code> for all others.
 </li>
</ul></div>
@@ -1772,24 +1892,24 @@
 In this way
 
<pre class="programlisting">template <typename Target, typename Source>
-Target boost::convert_to(Source const& from, dummy::base_tag<Target> const& p=dummy::base_tag<Target>()) {
+Target boost::conversion::convert_to(Source const& from, dummy::base_tag<Target> const& p=dummy::base_tag<Target>()) {
</pre>

 would be never chosen when called in this context
 
-<pre class="programlisting">using namespace boost::conversion;
+<pre class="programlisting">using namespace boost::conversion_2;
return convert_to(from, dummy::type_tag<Target>());
</pre>

 as the library defines
 
-<pre class="programlisting">namespace conversion {
+<pre class="programlisting">namespace conversion_2 {
 template < typename To, typename From >
- To boost::convert_to(const From& val, dummy::type_tag<To> const&);
+ To boost::conversion::convert_to(const From& val, dummy::type_tag<To> const&);
}
</pre>
<a name="boost.conversion.appendices.rationale.trick_to_avoid_the_use_of_the_tag_on_the_user_side"></a><h5>
-<a name="id36370581"></a>
+<a name="id36378460"></a>
 <a class="link" href="index.html#boost.conversion.appendices.rationale.trick_to_avoid_the_use_of_the_tag_on_the_user_side">Trick
 to avoid the use of the tag on the user side</a>
 </h5>
@@ -1803,7 +1923,7 @@
 To avoid to pass it as parameter the tag parameter has a default value boost::dummy::base_tag<Target>().
 
<pre class="programlisting">template <typename Target, typename Source>
-Target boost::convert_to(Source const& from, boost::dummy::base_tag<Target> const& p=boost::dummy::base_tag<Target>()) {
+Target boost::conversion::convert_to(Source const& from, boost::dummy::base_tag<Target> const& p=boost::dummy::base_tag<Target>()) {
</pre>

 This default value needs however to give the Target template parameter
@@ -1811,7 +1931,7 @@
<pre class="programlisting">a= convert_to<A>(b);
</pre>
<a name="boost.conversion.appendices.rationale.mathematical_background"></a><h5>
-<a name="id36370897"></a>
+<a name="id36378784"></a>
 <a class="link" href="index.html#boost.conversion.appendices.rationale.mathematical_background">Mathematical
 background</a>
 </h5>
@@ -1865,7 +1985,7 @@
 The library provides a convert_to_via function which helps to implement that.
 
<a name="boost.conversion.appendices.rationale.ambiguity_of_multiple_overloadins"></a><h5>
-<a name="id36371386"></a>
+<a name="id36379274"></a>
 <a class="link" href="index.html#boost.conversion.appendices.rationale.ambiguity_of_multiple_overloadins">Ambiguity
 of multiple overloadins</a>
 </h5>
@@ -1885,7 +2005,7 @@
 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_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><h5>
-<a name="id36371428"></a>
+<a name="id36379316"></a>
 <a class="link" href="index.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 implemented using <code class="computeroutput">boost::fusion::transform</code>?</a>
@@ -3036,12 +3156,12 @@
 plans</a>
</h3></div></div></div>
<a name="boost.conversion.appendices.todo.tasks_to_do_before_review"></a><h5>
-<a name="id36373816"></a>
+<a name="id36381707"></a>
 <a class="link" href="index.html#boost.conversion.appendices.todo.tasks_to_do_before_review">Tasks
 to do before review</a>
 </h5>
<a name="boost.conversion.appendices.todo.for_later_releases"></a><h5>
-<a name="id36373834"></a>
+<a name="id36381726"></a>
 <a class="link" href="index.html#boost.conversion.appendices.todo.for_later_releases">For later
 releases</a>
 </h5>
@@ -3054,7 +3174,7 @@
 </li>
</ul></div>
<a name="boost.conversion.appendices.todo.make_a_proposal_to_the_c___standard"></a><h5>
-<a name="id36373871"></a>
+<a name="id36381763"></a>
 <a class="link" href="index.html#boost.conversion.appendices.todo.make_a_proposal_to_the_c___standard">Make
 a proposal to the C++ standard</a>
 </h5>
@@ -3118,10 +3238,10 @@
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: April 10, 2011 at 15:19:12 GMT</td>
+<td align="left">Last revised: May 25, 2011 at 22:15:20 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="boost/conversion/partial_specialization__id35972110/assign_to.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="boost/conversion/overload_workaround/assign_to.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
</body>
</html>

Modified: sandbox/conversion/libs/conversion_ext/doc/html/standalone_HTML.manifest
==============================================================================
--- sandbox/conversion/libs/conversion_ext/doc/html/standalone_HTML.manifest (original)
+++ sandbox/conversion/libs/conversion_ext/doc/html/standalone_HTML.manifest 2011-05-25 18:30:57 EDT (Wed, 25 May 2011)
@@ -1,28 +1,54 @@
index.html
-boost/conversion/partial_specialization__id35972110/assign_to.html
-boost/assign_to_id35972207.html
+boost/conversion/overload_workaround/assign_to.html
+boost/conversion/assign_to_id35974124.html
+boost/conversion_2/assign_to_id35974194.html
boost/conversion/ca_wrapper.html
boost/mca.html
-boost/conversion/partial_specialization__id35972604/convert_to.html
+boost/conversion/overload_workaround/convert_to.html
+boost/conversion/enable_functor.html
+boost/conversion/convert_to_id35974710.html
boost/dummy/base_tag.html
boost/dummy/type_tag.html
-boost/convert_to_id35972717.html
+boost/conversion/enable_functor_T__typen_id35974986.html
+boost/conversion/convert_to_id35975024.html
+boost/conversion/overload_workaround/convert_to_or_fallback.html
+boost/conversion/convert_to_or_fallback_id35975263.html
+boost/convert_to_or_fallback_id35975332.html
boost/conversion/result_of/pack2.html
boost/conversion/result_of/pack3.html
-boost/conversion/pack_id35972919.html
-boost/conversion/pack_id35972952.html
-boost/conversion/pack_id35972984.html
-boost/conversion/pack_id35973027.html
-boost/conversion/pack_id35973070.html
-boost/conversion/pack_id35973112.html
-boost/conversion/partial_specialization__id35971370/convert_to_std_complex__id35971372.html
-boost/conversion/partial_specialization__id35971370/assign_to_std_complex_T_id35971406.html
-boost/conversion/partial_specialization__id35971458/convert_to_std_pair_T1__id35971461.html
-boost/conversion/partial_specialization__id35971458/assign_to_std_pair_T1___id35971507.html
-boost/conversion/partial_specialization__id35971572/convert_to_std_basic_st_id35971575.html
-boost/conversion/partial_specialization__id35971572/assign_to_std_basic_str_id35971620.html
-boost/conversion/partial_specialization__id35971572/convert_to_T__std_basic_id35971671.html
-boost/conversion/partial_specialization__id35971572/assign_to_T__std_basic__id35971717.html
-boost/conversion/partial_specialization__id35971784/convert_to_std_vector_T_id35971787.html
-boost/conversion/partial_specialization__id35971784/assign_to_std_vector_T1_id35973164.html
-boost/conversion/partial_specialization__id35971784/convert_to_std_vector_T_id35973218.html
+boost/conversion/pack_id35975535.html
+boost/conversion/pack_id35975568.html
+boost/conversion/pack_id35975600.html
+boost/conversion/pack_id35975643.html
+boost/conversion/pack_id35975686.html
+boost/conversion/pack_id35975728.html
+boost/conversion/overload_workaround/try_assign_to.html
+boost/conversion/try_assign_to_id35975910.html
+boost/try_assign_to_id35975967.html
+boost/conversion/overload_workaround/try_convert_to.html
+boost/conversion/try_convert_to_id35976188.html
+boost/conversion_2/try_convert_to_id35976260.html
+boost/conversion/overload_workaround/convert_to_std_complex__id35973887.html
+boost/conversion/overload_workaround/assign_to_std_complex_T_id35973920.html
+boost/conversion/overload_workaround/convert_to_std_pair_T1__id35973976.html
+boost/conversion/overload_workaround/assign_to_std_pair_T1___id35973205.html
+boost/conversion/overload_workaround/convert_to_std_basic_st_id35973273.html
+boost/conversion/overload_workaround/convert_to_T__std_basic_id35971993.html
+boost/conversion/overload_workaround/assign_to_std_basic_str_id35972039.html
+boost/conversion/overload_workaround/assign_to_T__std_basic__id35972089.html
+boost/conversion/overload_workaround/convert_to_std_string___id35972140.html
+boost/conversion/overload_workaround/convert_to_bool__std_st_id35972165.html
+boost/conversion/overload_workaround/convert_to_std_vector_T_id35972210.html
+boost/conversion/overload_workaround/assign_to_std_vector_T1_id35972258.html
+boost/conversion/overload_workaround/convert_to_std_vector_T_id35972313.html
+boost/convert_to_id35972629.html
+boost/assign_to_id35972676.html
+boost/chrono/convert_to_id35972763.html
+boost/chrono/assign_to_id35972810.html
+boost/posix_time/convert_to_id35972880.html
+boost/posix_time/assign_to_id35972927.html
+boost/numeric/convert_to_id35973151.html
+boost/convert_to_id35976383.html
+boost/convert_to_id35976434.html
+boost/assign_to_id35976485.html
+boost/convert_to_id35976560.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