Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r72300 - in sandbox/conversion/libs/conversion_ext/doc/html: . boost
From: vicente.botet_at_[hidden]
Date: 2011-05-31 06:05:44

Next message: vexocide_at_[hidden]: "[Boost-commit] svn:boost r72301 - sandbox/coerce/boost/coerce"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r72299 - in sandbox/conversion/boost/conversion: . boost"

Author: viboes
Date: 2011-05-31 06:05:43 EDT (Tue, 31 May 2011)
New Revision: 72300
URL: http://svn.boost.org/trac/boost/changeset/72300

Log:
Conversion: doc cleanup
Removed:
   sandbox/conversion/libs/conversion_ext/doc/html/boost/
Text files modified:
   sandbox/conversion/libs/conversion_ext/doc/html/index.html | 232 ++++++++++++++++++---------------------
   sandbox/conversion/libs/conversion_ext/doc/html/standalone_HTML.manifest | 83 ++++++-------
   2 files changed, 149 insertions(+), 166 deletions(-)

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-31 06:05:43 EDT (Tue, 31 May 2011)
@@ -917,7 +917,7 @@
 namespace chrono {
 template < class Clock, class Duration>
 inline posix_time::ptime convert_to(const chrono::time_point<Clock, Duration>& from
- , boost::dummy::type_tag<posix_time::ptime> const&)
+ , conversion::dummy::type_tag<posix_time::ptime> const&)
 {
 typedef chrono::time_point<Clock, Duration> time_point_t;
 typedef chrono::nanoseconds duration_t;
@@ -937,7 +937,6 @@

 template < class Clock, class Duration>
 inline chrono::time_point<Clock, Duration>& assign_to(chrono::time_point<Clock, Duration>& to, const posix_time::ptime& from
- , boost::dummy::type_tag<chrono::time_point<Clock, Duration> > const&
 )
 {
 to = boost::conversion::convert_to<chrono::time_point<Clock, Duration> >(from);
@@ -949,7 +948,7 @@
 namespace posix_time {
 template < class TP>
 inline TP convert_to(const ptime& from
- , boost::dummy::type_tag<TP > const&)
+ , conversion::dummy::type_tag<TP > const&)
 {
 time_duration const time_since_epoch=from-from_time_t(0);
 TP t=chrono::system_clock::from_time_t(time_since_epoch.total_seconds());
@@ -960,7 +959,6 @@

 template < class Clock, class Duration>
 inline ptime& assign_to(ptime& to, const chrono::time_point<Clock, Duration>& from
- , boost::dummy::type_tag<posix_time::ptime> const&
 )
 {
 to = boost::conversion::convert_to<ptime>(from);
@@ -991,10 +989,12 @@
#include <boost/conversion/convert_to.hpp>
#include <boost/conversion/assign_to.hpp>
#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/utility/enable_if.hpp>

namespace boost {

- #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING && ! defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING && ! defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
 namespace conversion {
 namespace overload_workaround {
 template < class Target, class Source>
@@ -1035,45 +1035,63 @@
 }
 }
#else
+ #if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ namespace conversion {
+ namespace detail {
+ template <typename T>
+ struct is_optional : mpl::false_ {};
+ template <typename T>
+ struct is_optional< ::boost::optional<T> > : mpl::true_ {};

+ }
+ }
+ #endif
 //! @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&)
+ inline
+ typename enable_if<typename conversion::detail::is_optional<Target>::type,Target>::type
+ convert_to(
+ optional<Source> const & from
+ , conversion::dummy::type_tag<Target> const&p=conversion::dummy::type_tag<Target>()
+ )
 {
- return (from?optional<Target>(boost::conversion::convert_to<Target>(from.get())):optional<Target>());
+ (void)p; // warning removal
+ return (from?Target(boost::conversion::convert_to<typename Target::value_type>(from.get())):Target());
 }
-
+
+#if 0
 //! @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.
+ //! We can see this overloading as a try_convert_to function.
+ //! @Returns If the source is convertible to the target @c value_type @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&)
+ inline
+ typename enable_if<typename conversion::detail::is_optional<Target>::type,Target>::type
+ convert_to(Source const & from
+ , conversion::dummy::type_tag<Target> const&p=conversion::dummy::type_tag<Target>()
+ )
 {
 try
 {
- return optional<Target>(boost::conversion::convert_to<Target>(from));
+ return Target(boost::conversion::convert_to<typename Target::value_type>(from));
 }
 catch (...)
 {
- return optional<Target>();
+ return 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>();
@@ -1241,22 +1259,17 @@
<div class="titlepage"><div><div><h4 class="title">
<a name="header.boost.conversion.assign_to_hpp"></a>Header <boost/conversion/assign_to.hpp></h4></div></div></div>
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">overload_workaround</code>. Thus the user can specialize partially this class. 
+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 uses the <code class="computeroutput">convert_to</code> to convert the source to the target and use the copy assignment of the <code class="computeroutput">Target</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::overload_workaround</code> namespace. 
<pre class="synopsis">namespace boost {
 namespace conversion {
 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 >());
+ Target & <a class="link" href="boost/conversion/assign_to_id35974515.html" title="Function template assign_to">assign_to</a>(Target &, const Source &);
 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>;
+ template<typename To, typename From, typename Enable = void>
+ struct <a class="link" href="boost/conversion/overload_workaround/assign_to.html" title="Struct template assign_to">assign_to</a>;
 }
 }
- 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>
<div class="section">
@@ -1274,24 +1287,24 @@
<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 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 <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. 
+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 <code class="computeroutput">std</code> namespace, so we need a different technique. In this case the user can partially specialize the <code class="computeroutput"><a class="link" href="boost/conversion/overload_workaround/convert_to.html" title="Struct template convert_to">boost::conversion::overload_workaround::convert_to</a></code> struct. 
<pre class="synopsis">namespace boost {
 namespace conversion {
 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 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 >());
+ Target <a class="link" href="boost/conversion/convert_to_id35975289.html" title="Function template convert_to">convert_to</a>(Source const &,
+ <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a>< Target > const & = <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a>< Target >());
+ namespace dummy {
+ template<typename T> struct <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">base_tag</a>;
+ template<typename T> struct <a class="link" href="boost/conversion/dummy/type_tag.html" title="Struct template type_tag">type_tag</a>;
+ }
 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>;
+ template<typename To, typename From, typename Enable = void>
+ 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>;
- template<typename T> struct <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">type_tag</a>;
- }
}</pre>
</div>
<div class="section">
@@ -1300,8 +1313,11 @@
<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 &);
+ struct <a class="link" href="boost/conversion/enable_functor_T__typen_id35975418.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_converter_type <a class="link" href="boost/conversion/make_converter_to.html" title="Function template make_converter_to">make_converter_to</a>(U const &);
+ template<typename T, typename U>
+ unspecified_converter_type <a class="link" href="boost/conversion/convert_to_id35975523.html" title="Function template convert_to">convert_to</a>(U const &);
 }
}</pre>
</div>
@@ -1310,18 +1326,15 @@
<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 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 fallback 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 &);
+ template<typename Target, typename Source, typename Fallback>
+ Target <a class="link" href="boost/conversion/convert_to_or_fallback_id35975775.html" title="Function template convert_to_or_fallback">convert_to_or_fallback</a>(Source const &, Fallback const &,
+ <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a>< Target > const & = <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a>< Target >());
 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>;
@@ -1353,22 +1366,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_id35975535.html" title="Function template pack">pack</a>(T1 const &, T2 const &);
+ <a class="link" href="boost/conversion/pack_id35975985.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_id35975568.html" title="Function template pack">pack</a>(T1 const &, T2 &);
+ <a class="link" href="boost/conversion/pack_id35976018.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_id35975600.html" title="Function template pack">pack</a>(T1 const &, T2 const &, T3 const &);
+ <a class="link" href="boost/conversion/pack_id35976051.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_id35975643.html" title="Function template pack">pack</a>(T1 const &, T2 const &, T3 &);
+ <a class="link" href="boost/conversion/pack_id35976094.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_id35975686.html" title="Function template pack">pack</a>(T1 const &, T2 &, T3 const &);
+ <a class="link" href="boost/conversion/pack_id35976136.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_id35975728.html" title="Function template pack">pack</a>(T1 const &, T2 &, T3 &);
+ <a class="link" href="boost/conversion/pack_id35976179.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_>
@@ -1385,12 +1398,10 @@
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 &);
+ template<typename Target, typename Source>
+ bool <a class="link" href="boost/conversion/try_assign_to_id35976374.html" title="Function template try_assign_to">try_assign_to</a>(Target &, const Source &,
+ <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a>< Target > const & = <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a>< Target >());
 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>;
 }
@@ -1402,7 +1413,7 @@
<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 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 succeeds 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. 
@@ -1410,17 +1421,15 @@
 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 >());
+ <a class="link" href="boost/conversion/try_convert_to_id35976690.html" title="Function template try_convert_to">try_convert_to</a>(Source const &,
+ <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a>< Target > const & = <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a>< Target >());
 namespace overload_workaround {
+ template<typename Target, typename Source>
+ struct <a class="link" href="boost/conversion/overload_workaround/convert_to_Target__Sour_id35976538.html" title="Struct template convert_to<Target, Source, typename enable_if< typename conversion::detail::is_optional< Target >::type >::type>">convert_to</a><Target, Source, typename enable_if< typename conversion::detail::is_optional< Target >::type >::type>;
+
 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>
@@ -1479,16 +1488,6 @@
<div class="titlepage"><div><div><h4 class="title">
<a name="header.boost.array_hpp"></a>Header <boost/array.hpp></h4></div></div></div>
Include this file when using conversions between <code class="computeroutput">boost::array<></code> of convertible types. 
-<pre class="synopsis">namespace boost {
- template<typename T1, typename T2, std::size_t N>
- array< T1, N >
- <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 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>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
@@ -1498,22 +1497,20 @@
 namespace chrono {
 template<typename Rep, typename Period>
 posix_time::time_duration
- <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 &);
+ <a class="link" href="boost/chrono/convert_to_id35973076.html" title="Function template convert_to">convert_to</a>(chrono::duration< Rep, Period > const &,
+ conversion::dummy::type_tag< posix_time::time_duration > const &);
 template<typename Rep, typename Period>
 chrono::duration< Rep, Period > &
- <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 &);
+ <a class="link" href="boost/chrono/assign_to_id35973125.html" title="Function template assign_to">assign_to</a>(chrono::duration< Rep, Period > &,
+ const posix_time::time_duration &);
 }
 namespace posix_time {
 template<typename Duration>
- 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 &);
+ Duration <a class="link" href="boost/posix_time/convert_to_id35973189.html" title="Function template convert_to">convert_to</a>(time_duration const &,
+ conversion::dummy::type_tag< Duration > const &);
 template<typename Rep, typename Period>
 time_duration &
- <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 &);
+ <a class="link" href="boost/posix_time/assign_to_id35973236.html" title="Function template assign_to">assign_to</a>(time_duration &, const chrono::duration< Rep, Period > &);
 }
}</pre>
</div>
@@ -1525,21 +1522,20 @@
 namespace chrono {
 template<typename Clock, typename Duration>
 posix_time::ptime
- <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 &);
+ <a name="boost.chrono.convert_to_id35973319"></a>convert_to(const chrono::time_point< Clock, Duration > & from,
+ conversion::dummy::type_tag< posix_time::ptime > const &);
 template<typename Clock, typename Duration>
 chrono::time_point< Clock, Duration > &
- <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 &);
+ <a name="boost.chrono.assign_to_id35973347"></a>assign_to(chrono::time_point< Clock, Duration > & to,
+ const posix_time::ptime & from);
 }
 namespace posix_time {
 template<typename TP>
- TP <a name="boost.posix_time.convert_to_id35973080"></a>convert_to(const ptime & from, boost::dummy::type_tag< TP > const &);
+ TP <a name="boost.posix_time.convert_to_id35973377"></a>convert_to(const ptime & from,
+ conversion::dummy::type_tag< TP > const &);
 template<typename Clock, typename Duration>
- 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 &);
+ ptime & <a name="boost.posix_time.assign_to_id35973400"></a>assign_to(ptime & to,
+ const chrono::time_point< Clock, Duration > & from);
 }
}</pre>
</div>
@@ -1551,12 +1547,11 @@
 namespace numeric {
 template<typename T, typename PT, typename U, typename PU>
 interval< T, PT >
- <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 &);
+ <a class="link" href="boost/numeric/convert_to_id35973443.html" title="Function template convert_to">convert_to</a>(interval< U, PU > const &,
+ ::boost::conversion::dummy::type_tag< interval< T, PT > > const & = ::boost::conversion::dummy::type_tag< interval< T, PT > >());
 template<typename T, typename PT, typename U, typename PU>
 interval< T, PT > &
- <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 &);
+ <a name="boost.numeric.assign_to_id35973498"></a>assign_to(interval< T, PT > & to, const interval< U, PU > & from);
 }
}</pre>
</div>
@@ -1566,17 +1561,11 @@
Include this file when using conversions between <code class="computeroutput">boost::optional<></code> of convertible types. 
<pre class="synopsis">namespace boost {
 template<typename Target, typename Source>
- optional< Target >
- <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 &);
+ unspecified <a class="link" href="boost/convert_to_id35973547.html" title="Function template convert_to">convert_to</a>(optional< Source > const &,
+ conversion::dummy::type_tag< Target > const & = conversion::dummy::type_tag< Target >());
 template<typename Target, typename Source>
 optional< Target > &
- <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 &);
+ <a class="link" href="boost/assign_to_id35972319.html" title="Function template assign_to">assign_to</a>(optional< Target > &, const optional< Source > &);
}</pre>
</div>
<div class="section">
@@ -1585,13 +1574,10 @@
Include this file when using conversions between <code class="computeroutput">boost::rational<></code> of convertible types. 
<pre class="synopsis">namespace boost {
 template<typename T, typename U>
- rational< T >
- <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 &);
+ unspecified <a class="link" href="boost/convert_to_id35976822.html" title="Function template convert_to">convert_to</a>(rational< U > const &,
+ conversion::dummy::type_tag< T > const & = conversion::dummy::type_tag< T >());
 template<typename T, typename U>
- rational< T > &
- <a name="boost.assign_to_id35976604"></a>assign_to(rational< T > & to, const rational< U > & from,
- boost::dummy::type_tag< rational< T > > const &);
+ rational< T > & <a name="boost.assign_to_id35976870"></a>assign_to(rational< T > & to, const rational< U > & from);
}</pre>
</div>
<div class="section">
@@ -1853,7 +1839,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="id36377583"></a>
+<a name="id36376402"></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>
@@ -1909,7 +1895,7 @@
}
</pre>
<a name="boost.conversion.appendices.rationale.trick_to_avoid_the_use_of_the_tag_on_the_user_side"></a><h5>
-<a name="id36378460"></a>
+<a name="id36377414"></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>
@@ -1931,7 +1917,7 @@
<pre class="programlisting">a= convert_to<A>(b);
</pre>
<a name="boost.conversion.appendices.rationale.mathematical_background"></a><h5>
-<a name="id36378784"></a>
+<a name="id36377739"></a>
 <a class="link" href="index.html#boost.conversion.appendices.rationale.mathematical_background">Mathematical
 background</a>
 </h5>
@@ -1985,7 +1971,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="id36379274"></a>
+<a name="id36378229"></a>
 <a class="link" href="index.html#boost.conversion.appendices.rationale.ambiguity_of_multiple_overloadins">Ambiguity
 of multiple overloadins</a>
 </h5>
@@ -2005,7 +1991,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="id36379316"></a>
+<a name="id36378271"></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>
@@ -3156,12 +3142,12 @@
 plans</a>
</h3></div></div></div>
<a name="boost.conversion.appendices.todo.tasks_to_do_before_review"></a><h5>
-<a name="id36381707"></a>
+<a name="id36380657"></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="id36381726"></a>
+<a name="id36380676"></a>
 <a class="link" href="index.html#boost.conversion.appendices.todo.for_later_releases">For later
 releases</a>
 </h5>
@@ -3174,7 +3160,7 @@
 </li>
</ul></div>
<a name="boost.conversion.appendices.todo.make_a_proposal_to_the_c___standard"></a><h5>
-<a name="id36381763"></a>
+<a name="id36380713"></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>
@@ -3238,7 +3224,7 @@
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: May 25, 2011 at 22:15:20 GMT</td>
+<td align="left">Last revised: May 31, 2011 at 09:59:03 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

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-31 06:05:43 EDT (Tue, 31 May 2011)
@@ -1,54 +1,51 @@
index.html
boost/conversion/overload_workaround/assign_to.html
-boost/conversion/assign_to_id35974124.html
-boost/conversion_2/assign_to_id35974194.html
+boost/conversion/assign_to_id35974515.html
boost/conversion/ca_wrapper.html
boost/mca.html
+boost/conversion/dummy/base_tag.html
+boost/conversion/dummy/type_tag.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/conversion/enable_functor_T__typen_id35974986.html
-boost/conversion/convert_to_id35975024.html
+boost/conversion/convert_to_id35975289.html
+boost/conversion/enable_functor_T__typen_id35975418.html
+boost/conversion/make_converter_to.html
+boost/conversion/convert_to_id35975523.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/convert_to_or_fallback_id35975775.html
boost/conversion/result_of/pack2.html
boost/conversion/result_of/pack3.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/pack_id35975985.html
+boost/conversion/pack_id35976018.html
+boost/conversion/pack_id35976051.html
+boost/conversion/pack_id35976094.html
+boost/conversion/pack_id35976136.html
+boost/conversion/pack_id35976179.html
boost/conversion/overload_workaround/try_assign_to.html
-boost/conversion/try_assign_to_id35975910.html
-boost/try_assign_to_id35975967.html
+boost/conversion/try_assign_to_id35976374.html
+boost/conversion/overload_workaround/convert_to_Target__Sour_id35976538.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
+boost/conversion/try_convert_to_id35976690.html
+boost/conversion/overload_workaround/convert_to_std_complex__id35974287.html
+boost/conversion/overload_workaround/assign_to_std_complex_T_id35974320.html
+boost/conversion/overload_workaround/convert_to_std_pair_T1__id35974376.html
+boost/conversion/overload_workaround/assign_to_std_pair_T1___id35973624.html
+boost/conversion/overload_workaround/convert_to_std_basic_st_id35973692.html
+boost/conversion/overload_workaround/convert_to_T__std_basic_id35972354.html
+boost/conversion/overload_workaround/assign_to_std_basic_str_id35972399.html
+boost/conversion/overload_workaround/assign_to_T__std_basic__id35972450.html
+boost/conversion/overload_workaround/convert_to_std_string___id35972501.html
+boost/conversion/overload_workaround/convert_to_bool__std_st_id35972526.html
+boost/conversion/overload_workaround/convert_to_std_vector_T_id35972571.html
+boost/conversion/overload_workaround/assign_to_std_vector_T1_id35972619.html
+boost/conversion/overload_workaround/convert_to_std_vector_T_id35972674.html
+boost/conversion/overload_workaround/convert_to_array_T1__N__id35972932.html
+boost/conversion/overload_workaround/assign_to_array_T1__N___id35972989.html
+boost/chrono/convert_to_id35973076.html
+boost/chrono/assign_to_id35973125.html
+boost/posix_time/convert_to_id35973189.html
+boost/posix_time/assign_to_id35973236.html
+boost/numeric/convert_to_id35973443.html
+boost/convert_to_id35973547.html
+boost/assign_to_id35972319.html
+boost/convert_to_id35976822.html

Next message: vexocide_at_[hidden]: "[Boost-commit] svn:boost r72301 - sandbox/coerce/boost/coerce"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r72299 - in sandbox/conversion/boost/conversion: . boost"

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