Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r65557 - in sandbox/conversion/libs/conversion/doc: . html
From: vicente.botet_at_[hidden]
Date: 2010-09-23 15:35:39

Next message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r65558 - sandbox/conversion/libs/conversion/doc/html/boost"
Previous message: troyer_at_[hidden]: "[Boost-commit] svn:boost r65556 - trunk/boost/mpi"

Author: viboes
Date: 2010-09-23 15:35:35 EDT (Thu, 23 Sep 2010)
New Revision: 65557
URL: http://svn.boost.org/trac/boost/changeset/65557

Log:
COnversion 0.5: Update doc
Added:
   sandbox/conversion/libs/conversion/doc/conversion.pdf (contents, props changed)
Text files modified:
   sandbox/conversion/libs/conversion/doc/Jamfile.v2 | 2
   sandbox/conversion/libs/conversion/doc/conversion.qbk | 239 +-
   sandbox/conversion/libs/conversion/doc/html/index.html | 3496 +++++++++++++++++++++++++++++++++++++++
   sandbox/conversion/libs/conversion/doc/html/standalone_HTML.manifest | 23
   4 files changed, 3587 insertions(+), 173 deletions(-)

Modified: sandbox/conversion/libs/conversion/doc/Jamfile.v2
==============================================================================
--- sandbox/conversion/libs/conversion/doc/Jamfile.v2 (original)
+++ sandbox/conversion/libs/conversion/doc/Jamfile.v2 2010-09-23 15:35:35 EDT (Thu, 23 Sep 2010)
@@ -33,7 +33,7 @@
 # Use graphics not text for navigation:
 <xsl:param>navig.graphics=1
 # How far down we chunk nested sections, basically all of them:
- <xsl:param>chunk.section.depth=2
+ <xsl:param>chunk.section.depth=0
 # Don't put the first section on the same page as the TOC:
 <xsl:param>chunk.first.sections=1
 # How far down sections get TOC's

Added: sandbox/conversion/libs/conversion/doc/conversion.pdf
==============================================================================
Binary file. No diff available.

Modified: sandbox/conversion/libs/conversion/doc/conversion.qbk
==============================================================================
--- sandbox/conversion/libs/conversion/doc/conversion.qbk (original)
+++ sandbox/conversion/libs/conversion/doc/conversion.qbk 2010-09-23 15:35:35 EDT (Thu, 23 Sep 2010)
@@ -8,8 +8,9 @@

[article Toward Boost.Conversion
 [quickbook 1.4]
+ [version 0.5.0]
 [authors [Botet Escriba, Vicente J.]]
- [copyright 2009 Vicente J. Botet Escriba]
+ [copyright 2009-2010 Vicente J. Botet Escriba]
 [id boost.conversion]
 [dirname conversion]
 [purpose Conversion utilities]
@@ -428,7 +429,7 @@
[endsect]

-[section:ext_references References]
+[section:ext_references External Resources]
[variablelist
[
 [[@http://www.boostpro.com/vault/index.php?action=downloadfile&filename=boost-string-convert.zip&directory=&
@@ -446,6 +447,30 @@
 [Optimized Policy-based Numeric Conversions from Fernando Cacciola.]
]

+[
+ [[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2380.pdf [*N2380 - Explicit Conversion Operator Draft Working Paper (revision 2)]]]
+ [Lois Goldthwaite, Michael Wong, Jens Mauer, Alisdair Meredith.]
+]
+[
+ [[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2200.pdf [*N2200 - Operator Overloading]]]
+ [Gary Powell, Doug Gregor, Jaakko Jarvi.]
+]
+
+[
+ [[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1671.pdf [*N1671 - Overloading operator.() & operator.*()]]]
+ [Gary Powell, Doug Gregor, Jaakko Jarvi.]
+]
+
+[
+ [[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1676.htm [*N1676 - Non-member overloaded copy assignment operator]]]
+ [Bronek Kozicki.]
+]
+
+[
+ [[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1694.html [*N1694 - A Proposal to Extend the Function Call Operator]]]
+ [Bronek Kozicki.]
+]
+
]

[endsect]
@@ -465,7 +490,7 @@
 #include <boost/conversion/assign_to.hpp>
 #include <boost/conversion/convert_to_via.hpp>
 #include <boost/conversion/ca_wrapper.hpp>
- #include <boost/conversion/paxk.hpp>
+ #include <boost/conversion/pack.hpp>

[endsect]

@@ -851,17 +876,13 @@
Include this file when using conversions between rational of convertible types.

 namespace boost {
- namespace conversion {
- namespace partial_specialization_workaround {
- template < class T, class U>
- struct convert_to< rational<T>, rational > {
- inline static rational<T> apply(rational const & from);
- };
- template < class T, class U>
- struct assign_to< rational<T>, rational > {
- inline static rational<T>& apply(rational<T>& to, const rational& from);
- };
- }}
+ template < class T, class U>
+ rational<T> convert_to(rational const & from
+ , boost::dummy::type_tag<rational<T> > const&);
+
+ template < class T, class U>
+ rational<T>& assign_to(rational<T>& to, const rational& from
+ , boost::dummy::type_tag<rational<T> > const&);
 }

[endsect]
@@ -872,58 +893,45 @@
Include this file when using conversions between chrono and posix_time time and duration types.

 namespace boost {
- namespace conversion {
- namespace partial_specialization_workaround {
- template < class Rep, class Period>
- struct convert_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
- static posix_time::time_duration apply(
- chrono::duration<Rep, Period> const & from);
- };
- template < class Rep, class Period>
- struct assign_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
- static posix_time::time_duration& apply(
- posix_time::time_duration& to,
- const chrono::duration<Rep, Period>& from
- );
- };
+ namespace chrono {
+ template < class Clock, class Duration>
+ posix_time::ptime convert_to(const chrono::time_point<Clock, Duration>& from
+ , boost::dummy::type_tag<posix_time::ptime> const&);
+
+ template < class Clock, class Duration>
+ 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&);;

- template < class Rep, class Period>
- struct convert_to<chrono::duration<Rep, Period>, posix_time::time_duration> {
- static chrono::duration<Rep, Period> apply(posix_time::time_duration const & from);
- };
- template < class Rep, class Period>
- struct assign_to<chrono::duration<Rep, Period>, posix_time::time_duration> {
- static chrono::duration<Rep, Period> & apply(
- chrono::duration<Rep, Period> & to,
- const posix_time::time_duration& from);
- };
- }}
 }
+ namespace posix_time {
+ template < class Clock, class Duration>
+ chrono::time_point<Clock, Duration> convert_to(const ptime& from
+ , boost::dummy::type_tag<chrono::time_point<Clock, Duration> > const&);

- namespace boost {
- namespace conversion {
- namespace partial_specialization_workaround {
- template < class Clock, class Duration>
- struct convert_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
- static posix_time::ptime apply(const chrono::time_point<Clock, Duration>& from);
- };
- template < class Clock, class Duration>
- struct assign_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
- static posix_time::ptime& apply(posix_time::ptime& to,
- const chrono::time_point<Clock, Duration>& from);
- };
+ template < class Clock, class Duration>
+ ptime& assign_to(ptime& to, const chrono::time_point<Clock, Duration>& from
+ , boost::dummy::type_tag<posix_time::ptime> const&);
+ }

- template < class Clock, class Duration>
- struct convert_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
- static chrono::time_point<Clock, Duration> apply(const posix_time::ptime& from);
- };
- template < class Clock, class Duration>
- struct assign_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
- static chrono::time_point<Clock, Duration>& apply(
- chrono::time_point<Clock, Duration>& to,
- const posix_time::ptime& from);
- };
- }}
+ namespace chrono {
+ template < class Rep, class Period>
+ inline posix_time::time_duration convert_to(chrono::duration<Rep, Period> const & from
+ , boost::dummy::type_tag<posix_time::time_duration> const&);
+
+ template < class Rep, class Period>
+ inline chrono::duration<Rep, Period> & assign_to(chrono::duration<Rep, Period> & to, const posix_time::time_duration& from
+ , boost::dummy::type_tag<chrono::duration<Rep, Period> > const&);
+ }
+
+ namespace posix_time {
+ template < class Rep, class Period>
+ inline chrono::duration<Rep, Period> convert_to(time_duration const & from
+ , boost::dummy::type_tag<chrono::duration<Rep, Period> > const&);
+
+ template < class Rep, class Period>
+ inline time_duration& assign_to(time_duration& to, const chrono::duration<Rep, Period>& from
+ , boost::dummy::type_tag<posix_time::time_duration> const&);
+ }
 }

[endsect]
@@ -934,18 +942,15 @@
Include this file when using conversions between intervals of convertible types.

 namespace boost {
- namespace conversion {
- namespace partial_specialization_workaround {
- template < class T, class PT, class U, class PU>
- struct convert_to< interval<T,PT>, interval<U,PU> > {
- static interval<T,PT> apply(interval<U,PU> const & from);
- };
- template < class T, class PT, class U, class PU>
- struct assign_to< interval<T,PT>, interval<U,PU> > {
- static interval<T,PT>& apply(
- interval<T,PT>& to, const interval<U,PU>& from);
- };
- }}
+ namespace numeric {
+ template < class T, class PT, class U, class PU>
+ interval<T,PT> convert_to(interval<U,PU> const & from
+ , boost::dummy::type_tag<interval<T,PT> > const&);
+
+ template < class T, class PT, class U, class PU>
+ inline interval<T,PT>& assign_to(interval<T,PT>& to, const interval<U,PU>& from
+ , boost::dummy::type_tag<interval<T,PT> > const&);
+ }
 }

[endsect]
@@ -956,18 +961,13 @@
Include this file when using conversions between optional of convertible types.

 namespace boost {
- namespace conversion {
- namespace partial_specialization_workaround {
- template < class Target, class Source>
- struct convert_to< optional<Target>, optional<Source> > {
- static optional<Target> apply(optional<Source> const & from);
- };
- template < class Target, class Source>
- struct assign_to< optional<Target>, optional<Source> > {
- static optional<Target>& apply(
- optional<Target>& to, const optional<Target>& from);
- };
- }}
+ template < class Target, class Source>
+ optional<Target> convert_to(optional<Source> const & from
+ , boost::dummy::type_tag<optional<Target> > const&);
+
+ template < class Target, class Source>
+ optional<Target>& assign_to(optional<Target>& to, const optional<Source>& from
+ , boost::dummy::type_tag<optional<Target> > const&);
 }

[endsect]
@@ -979,17 +979,13 @@
Include this file when using conversions between arrays of convertible types.

 namespace boost {
- namespace conversion {
- namespace partial_specialization_workaround {
- template < typename T1, typename T2, std::size_t N>
- struct convert_to< array<T1,N>, array<T2,N> > {
- static array<T1,N> apply(array<T2,N> const & from);
- };
- template < typename T1, typename T2, std::size_t N>
- struct assign_to< array<T1,N>, array<T2,N> > {
- static array<T1,N>& apply(array<T1,N>& to, array<T2,N> const & from);
- };
- }}
+ template < typename T1, typename T2, std::size_t N>
+ array<T1,N> convert_to(array<T2,N> const & from
+ , boost::dummy::type_tag<array<T1,N> > const&);;
+
+ template < typename T1, typename T2, std::size_t N>
+ array<T1,N>& assign_to(array<T1,N>& to, array<T2,N> const & from
+ , boost::dummy::type_tag<array<T1,N> > const&);
 }

@@ -1002,20 +998,23 @@
Include this file when using conversions between fusion::tuple of convertible types.

 namespace boost {
- namespace conversion {
- namespace partial_specialization_workaround {
- template < class T1, ..., class Tn, class U1, ..., class Un>
- struct convert_to< boost::fusion::tuple<T1,...,T3>, boost::fusion::tuple<U1,...,U3> > {
- inline static boost::fusion::tuple<T1,...,T3>
- apply(boost::fusion::tuple<U1,...,U3> const & from);
- };
- template < class T1, ..., class Tn, class U1, ..., class Un>
- struct assign_to< boost::fusion::tuple<T1,...,T3>, boost::fusion::tuple<U1,...,U3> > {
- inline static boost::fusion::tuple<T1,...,T3>
- apply(boost::fusion::tuple<T1,...,T3>& to, boost::fusion::tuple<U1,...,U3> const & from);
- };
-
- }}
+ namespace fusion {
+ template < class T1, class T2, class U1, class U2>
+ tuple<T1,T2> convert_to(tuple<U1,U2> const & from
+ , boost::dummy::type_tag<tuple<T1,T2> > const&);
+
+ template < class T1, class T2, class U1, class U2>
+ tuple<T1,T2>& assign_to(tuple<T1,T2>& to, tuple<U1,U2> const & from
+ , boost::dummy::type_tag<tuple<T1,T2> > const&);
+
+ template < class T1, class T2, class T3, class U1, class U2, class U3>
+ tuple<T1,T2,T3> convert_to(tuple<U1,U2,U3> const & from
+ , boost::dummy::type_tag<tuple<T1,T2,T3> > const&);;
+
+ template < class T1, class T2, class T3, class U1, class U2, class U3>
+ tuple<T1,T2,T3> assign_to(tuple<T1,T2,T3>& to, boost::fusion::tuple<U1,U2,U3> const & from
+ , boost::dummy::type_tag<tuple<T1,T2,T3> > const&);;
+ }
 }

[endsect]
@@ -1057,6 +1056,7 @@

* Added is_asignable_to metafunction.

+[endsect]

[section [*Version 0.4.0, October 27, 2009] ['Applying the same technique that boost::swap applies making use of ADL]]
[*New Features:]
@@ -1311,19 +1311,19 @@

[heading Make a proposal to the C++ standard]

-C++1x has added explicit conversion operators, but they must always be defined in the Source class. The same applies to the assignment operator, it must be defined on the Target class.
+C++1x has added explicit conversion operators, but they must always be defined in the source class. The same applies to the assignment operator, it must be defined on the Target class.

What it will interesting is to be able to add constructors and assignments operators to the class std::pair, so we can say that two pairs are convertible if the parameters are explicitly convertible using a convert_to function

 template<class U , class V>
 //requires HasConvertTo<T1, const U&> && HasConvertTo<T2, const V&>
 std::pair& operator=(const std::pair& p) {
- return std::make_pair(convert_to<T1>(p.first), convert_to<T1>(p.second));
+ return std::make_pair(convert_to<T1>(p.first), convert_to<T2>(p.second));
 }

But this is not possible. We can not add operations to a class.

-Another possibility could be to make an evolution to the standard, so the convertible concept takes car of extrinsic conversions. We could be able to implicitly or explicitly add extrinsic conversion operators between unrelated types. Assignment operators could also be specialized.
+Another possibility could be to make an evolution to the standard, so the convertible concept takes car of extrinsic conversions. We could be able to implicitly or explicitly add extrinsic conversion operators between unrelated types. Non-member assignment operators could also be specialized.

 template < typename To, typename From >
 operator To(const From& val);
@@ -1331,10 +1331,10 @@
 template < typename To, typename From >
 To& operator=(To& to, const From& from);

-For example we could specialize the conversion from as chrono::time_point<Clock, Duration> to posix_time::ptime follows
+For example we could define the explicit conversion from as chrono::time_point<Clock, Duration> to posix_time::ptime follows

 template < class Clock, class Duration>
- operator boost::posix_time::ptime(const boost::chrono::time_point<Clock, Duration>& from) {
+ explicit operator boost::posix_time::ptime(const boost::chrono::time_point<Clock, Duration>& from) {
 typedef boost::chrono::time_point<Clock, Duration> time_point_t;
 typedef boost::chrono::nanoseconds duration_t;
 typedef boost::duration_t::rep rep_t;
@@ -1346,6 +1346,13 @@
 boost::posix_time::nanoseconds(nsec);
 }

+With this explicit conversion and the equivalen for duration, the actual definition of std::pair will allows to
+
+ std::pair<chrono::time_point<Clock, Duration>, boost::chrono::duration<Rep, Period> > tp_dur_pair;
+ std::pair<boost::posix_time::ptime, boost::posix_time::time_duration> ppt;
+ ppt = tp_dur_pair;
+
+
[endsect]
[endsect]

Modified: sandbox/conversion/libs/conversion/doc/html/index.html
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/index.html (original)
+++ sandbox/conversion/libs/conversion/doc/html/index.html 2010-09-23 15:35:35 EDT (Thu, 23 Sep 2010)
@@ -1,11 +1,10 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Toward Boost.Conversion</title>
+<title>Toward Boost.Conversion 0.5.0</title>
<link rel="stylesheet" href="../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
-<link rel="start" href="index.html" title="Toward Boost.Conversion">
-<link rel="next" href="boost/conversion/overview.html" title="Overview">
+<link rel="start" href="index.html" title="Toward Boost.Conversion 0.5.0">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -17,18 +16,18 @@
<td align="center">More</td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="boost/conversion/overview.html"><img src="../../../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"></div>
<div class="article" lang="en">
<div class="titlepage">
<div>
<div><h2 class="title">
-<a name="boost.conversion"></a>Toward Boost.Conversion</h2></div>
+<a name="boost.conversion"></a>Toward Boost.Conversion 0.5.0</h2></div>
<div><div class="authorgroup"><div class="author"><h3 class="author">
Vicente J. Botet Escriba
</h3></div></div></div>
-<div>Copyright © 2009 Vicente J. Botet Escriba</div>
+<div>Copyright © 2009 -2010 Vicente J. Botet Escriba</div>
<div><div class="legalnotice">
-<a name="id4762501"></a>
+<a name="id4987067"></a>
 Distributed under the Boost Software License, Version 1.0. (See accompanying
 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -39,63 +38,3494 @@
<div class="toc">
Table of Contents
<dl>
-<dt>Overview</dt>
-<dd><dl><dt>Motivation</dt></dl></dd>
-<dt> Users' Guide</dt>
+<dt>Overview</dt>
+<dd><dl><dt>Motivation</dt></dl></dd>
+<dt> Users' Guide</dt>
<dd><dl>
-<dt><a href="boost/conversion/users_guide/getting_started.html"> Getting
+<dt><a href="index.html#boost.conversion.users_guide.getting_started"> Getting
 Started</a></dt>
-<dt>Tutorial</dt>
-<dt> References</dt>
+<dt>Tutorial</dt>
+<dt><a href="index.html#boost.conversion.users_guide.ext_references"> External
+ Resources</a></dt>
</dl></dd>
-<dt>Reference</dt>
+<dt>Reference</dt>
<dd><dl>
-<dt> Header <boost/conversion.hpp></dt>
-<dt>Core</dt>
-<dt><a href="boost/conversion/reference/c___standard_classes_specializations.html">C++
+<dt> Header <boost/conversion.hpp></dt>
+<dt>Core</dt>
+<dt><a href="index.html#boost.conversion.reference.c___standard_classes_specializations">C++
 Standard classes specializations</a></dt>
-<dt><a href="boost/conversion/reference/boost_classes_specializations.html">Boost
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations">Boost
 classes specializations</a></dt>
</dl></dd>
-<dt>Examples</dt>
+<dt>Examples</dt>
<dd><dl>
-<dt><a href="boost/conversion/examples/chrono__time_point_and_posix_time__ptime.html">chrono::time_point
+<dt><a href="index.html#boost.conversion.examples.chrono__time_point_and_posix_time__ptime">chrono::time_point
 and posix_time::ptime</a></dt>
-<dt>boost::optional</dt>
-<dt>std::pair</dt>
+<dt>boost::optional</dt>
+<dt>std::pair</dt>
</dl></dd>
-<dt>Appendices</dt>
+<dt>Appendices</dt>
<dd><dl>
-<dt> Appendix A: History</dt>
-<dt> Appendix B: Rationale</dt>
-<dt><a href="boost/conversion/appendices/implementation.html"> Appendix
+<dt> Appendix A: History</dt>
+<dt> Appendix B: Rationale</dt>
+<dt><a href="index.html#boost.conversion.appendices.implementation"> Appendix
 C: Implementation Notes</a></dt>
-<dt><a href="boost/conversion/appendices/acknowledgements.html"> Appendix
+<dt><a href="index.html#boost.conversion.appendices.acknowledgements"> Appendix
 D: Acknowledgements</a></dt>
-<dt><a href="boost/conversion/appendices/appendix_e__tests.html">Appendix
+<dt><a href="index.html#boost.conversion.appendices.appendix_e__tests">Appendix
 E: Tests</a></dt>
-<dt><a href="boost/conversion/appendices/appendix_f__tickets.html">Appendix
+<dt><a href="index.html#boost.conversion.appendices.appendix_f__tickets">Appendix
 F: Tickets</a></dt>
-<dt><a href="boost/conversion/appendices/todo.html"> Appendix F: Future
+<dt><a href="index.html#boost.conversion.appendices.todo"> Appendix F: Future
 plans</a></dt>
</dl></dd>
</dl>
</div>
<div class="warning"><table border="0" summary="Warning">
<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../doc/html/images/warning.png"></td>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../doc/src/images/warning.png"></td>
<th align="left">Warning</th>
</tr>
<tr><td align="left" valign="top">
 Conversion is not a part of the Boost libraries.
 </td></tr>
</table></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost.conversion.overview"></a>Overview
+</h2></div></div></div>
+<div class="toc"><dl><dt>Motivation</dt></dl></div>
+<a name="boost.conversion.overview.description"></a><h3>
+<a name="id4986977"></a>
+ Description
+ </h3>
+
+ Generic explicit conversion between unrelated types.
+ 
+
+ The template function <code class="computeroutput">convert_to</code>
+ allows to convert a source type to a target type, using argument dependent
+ lookup to select a specialized <code class="computeroutput">convert_to</code>
+ function if available. If no specialized <code class="computeroutput">convert_to</code>
+ function is available, <code class="computeroutput">boost::conversion::convert_to</code>
+ is used.
+ 
+
+ The generic <code class="computeroutput">convert_to</code> function
+ requires that the elements to be converted are assignable and copy constructible.
+ It is implemented using the Target copy construction from a Source or the Source
+ conversion operator Target - this is sometimes unavailable.
+ 
+
+ For standard types, we can not add a specialized <code class="computeroutput">convert_to</code>
+ function on the namespace std. The alternative to using argument dependent
+ lookup in this situation is to provide a template specialization of boost::conversion::convert_to
+ for every pair of standard types that requires a specialized <code class="computeroutput">convert_to</code>.
+ 
+
+ Boost.Conversion provides:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ a generic <code class="computeroutput">convert_to</code> function
+ which can be specialized by the user to make explicit conversion between
+ unrelated types.
+ </li>
+<li>
+ a generic <code class="computeroutput">assign_to</code> function
+ which can be specialized by the user to make explicit assignation between
+ unrelated types.
+ </li>
+<li>
+ a generic <code class="computeroutput">mca</code> function
+ returning a wrapper which replace assignments by a call to <code class="computeroutput">assign_to</code> and conversion operators by
+ a call <code class="computeroutput">convert_to</code>.
+ </li>
+<li>
+ a generic <code class="computeroutput">convert_to_via</code>
+ function which convert a type <code class="computeroutput">From</code>
+ to another <code class="computeroutput">To</code> using a temporary
+ one <code class="computeroutput">Via</code>.
+ </li>
+<li>
+ a generic <code class="computeroutput">pack</code> function
+ used to pack Source and target constructor arguments.
+ </li>
+<li>
+ conversion between <code class="computeroutput">std::complex</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">std::pair</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::optional</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::rational</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::interval</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::chrono::time_point</code>
+ and <code class="computeroutput">boost::ptime</code>.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::chrono::duration</code>
+ and <code class="computeroutput">boost::time_duration</code>.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::array</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between Boost.Fusion sequences of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">std::vector</code>
+ of explicitly convertible types.
+ </li>
+</ul></div>
+<a name="boost.conversion.overview.how_to_use_this_documentation"></a><h3>
+<a name="id4949128"></a>
+ <a href="index.html#boost.conversion.overview.how_to_use_this_documentation">How
+ to Use This Documentation</a>
+ </h3>
+
+ This documentation makes use of the following naming and formatting conventions.
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Code is in <code class="computeroutput">fixed width
+ font</code> and is syntax-highlighted.
+ </li>
+<li>
+ Replaceable text that you will need to supply is in <code>italics</code>.
+ </li>
+<li>
+ If a name refers to a free function, it is specified like this: <code class="computeroutput">free_function()</code>;
+ that is, it is in code font and its name is followed by <code class="computeroutput">()</code>
+ to indicate that it is a free function.
+ </li>
+<li>
+ If a name refers to a class template, it is specified like this: <code class="computeroutput">class_template<></code>;
+ that is, it is in code font and its name is followed by <code class="computeroutput"><></code>
+ to indicate that it is a class template.
+ </li>
+<li>
+ If a name refers to a function-like macro, it is specified like this:
+ <code class="computeroutput">MACRO()</code>;
+ that is, it is uppercase in code font and its name is followed by <code class="computeroutput">()</code> to indicate that it is a function-like
+ macro. Object-like macros appear without the trailing <code class="computeroutput">()</code>.
+ </li>
+<li>
+ Names that refer to concepts in the generic programming
+ sense are specified in CamelCase.
+ </li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ In addition, notes such as this one specify non-essential information that
+ provides additional background or rationale.
+ </td></tr>
+</table></div>
+
+ Finally, you can mentally add the following to any code fragments in this document:
+ 
+<pre class="programlisting">// Include all of the core Conversion files
+#include <boost/conversion.hpp>
+
+using namespace boost;
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.overview.motivation"></a>Motivation
+</h3></div></div></div>
+
+ I've needed recently to convert from boost::chrono::time_point<Clock,
+ Duration> to boost::posix_time::ptime and from boost::chrono::duration<Rep,
+ Period> to boost::posix_time::time_duration. This kind of conversions
+ are needed quite often when you use code from two different libraries that
+ have implemented the same concept using of course different representations
+ and have hard coded the library interface to its own implementation. Well
+ this is a normal situation we can't avoid. Life is life.
+ 
+
+ Quite often we need to convert unrelated types <code class="computeroutput">Source</code>
+ and <code class="computeroutput">Target</code>. As these classes
+ are unrelated, neither of them offers conversion operators to the other.
+ Usually we get it by defining a specific function such as
+ 
+<pre class="programlisting">Target ConvertToTarget(Source& v);
+</pre>
+
+ In my case I started by defining
+ 
+<pre class="programlisting">template <typename Rep, typename Period>
+boost::posix_time::time_duration convert_to_posix_time_time_duration(
+ const boost::chrono::duration<Rep, Period>& from);
+
+template <typename Clock, typename Duration>
+posix_time::ptime convert_to_posix_time_ptime(const chrono::time_point<Clock, Duration>& from);
+</pre>
+
+ Imagine now that you need to convert a <code class="computeroutput">std::pair<Source, Source></code> to a <code class="computeroutput">std::pair<Target, Target></code>. The standard defines conversions of
+ pairs if the related types are C++ convertible:
+ 
+<pre class="programlisting">template <typename T1, typename T2>
+struct pair {
+ ...
+ template<class U, class V>
+ //requires Constructible<T1, const U&> && Constructible<T2, const V&>
+ std::pair(const pair<U, V>& p);
+
+ template<class U , class V>
+ //requires HasAssign<T1, const U&> && HasAssign<T2, const V&>
+ std::pair& operator=(const std::pair<U , V>& p);
+ ...
+};
+</pre>
+
+ But as the types <code class="computeroutput">Target</code> and
+ <code class="computeroutput">Source</code> are not C++ convertible
+ other than using a specific function.
+ 
+
+ Well we can again define a specific function
+ 
+<pre class="programlisting">std::pair<Target,Target> ConvertToPairOfTarget(std::pair<Source,Source>& v) {
+ return std::make_pair(ConvertToTarget(v.fisrt), ConvertToTarget(v.second));
+}
+</pre>
+
+ While the <code class="computeroutput">ConvertToTarget</code>
+ could be specific, the <code class="computeroutput">ConvertToPairOfTarget</code>
+ should be generic
+ 
+<pre class="programlisting">template <typename Target1, typename Target2, typename Source1, typename Source2)
+std::pair<Target1,Target2> ConvertToPair(std::pair<Source1,Source2>& v);
+</pre>
+
+ In order to do that we need that the pair template parameters define a common
+ function, let it call <code class="computeroutput">convert_to</code>,
+ 
+<pre class="programlisting">template <typename Target, typename Source)
+Target convert_to(Source& v);
+</pre>
+
+ so <code class="computeroutput">ConvertToPair</code> can be defined
+ as
+ 
+<pre class="programlisting">template <typename Target1, typename Target2, typename Source1, typename Source2)
+std::pair<Target1,Target2> ConvertToPair(std::pair<Source1,Source2>& v) {
+ return std::make_pair(convert_to<Target1>(v.fisrt), convert_to<Target2>(v.second));
+}
+</pre>
+
+ We need to specialize the <code class="computeroutput">convert_to</code>
+ function for the specific classes <code class="computeroutput">Source</code>
+ and <code class="computeroutput">Target</code>. We can do it
+ as follows
+ 
+<pre class="programlisting">Target convert_to(Source& v) {return ConvertToTarget(v);}
+</pre>
+
+ In my case I needed
+ 
+<pre class="programlisting">template <typename Rep, typename Period>
+boost::posix_time::time_duration convert_to(const boost::chrono::duration<Rep, Period>& from)
+{
+ return convert_to_posix_time_time_duration(from);
+}
+
+template <typename Clock, typename Duration>
+boost::posix_time::ptime convert_to(const boost::chrono::time_point<Clock, Duration>& from)
+{
+ return convert_to_posix_time_ptime(from);
+}
+</pre>
+
+ So now I can convert
+ 
+<pre class="programlisting">std::pair<chrono::time_point<Clock, Duration>, boost::chrono::duration<Rep, Period> >
+</pre>
+
+ to
+ 
+<pre class="programlisting">std::pair<boost::posix_time::ptime, boost::posix_time::time_duration>
+</pre>
+
+ using the <code class="computeroutput">ConvertToPair</code> function.
+ 
+
+ What about converting <code class="computeroutput">std::pair<Source,std::pair<Source,Source> ></code> to <code class="computeroutput">std::pair<Target,std::pair<Target,Target> ></code>? The issue now is that <code class="computeroutput">convert_to(std::make_pair<to, std::make_pair<to,to> >)</code>
+ do not compiles because the conversion of <code class="computeroutput">std::pair</code>
+ is named <code class="computeroutput">ConvertToPair</code>. So
+ we need to specialize the function <code class="computeroutput">convert_to</code>
+ for pairs.
+ 
+<pre class="programlisting">template <typename T1, typename T2, typename S1, typename S2)
+static std::pair<T1,T2> convert_to(std::pair<Source1,Source2>& from) {
+{
+ return std::pair<T1,T2>(convert_to<T1>(from.first), convert_to<T2>(from.second));
+}
+</pre>
+
+ There is still a last point. The preceding design works well with unrelated
+ classes, but what about classes that already define some kind of conversion,
+ using a constructor or a conversion operator. Do we need to make specialization
+ for these conversion? The answer is no. We need just to define the default
+ implementation of convert_to function to just return the explicit conversion.
+ 
+<pre class="programlisting">template < typename Target, typename Source>
+Target convert_to(const Source& from)
+{
+ return Target(from);
+}
+</pre>
+
+ What have we learned? Classes or algorithms relying on a conversion by copy-construction
+ or by the conversion operator can be made more generic by relaying in a function
+ that explicitly states this conversion. Thus, instead of requiring
+ 
+<pre class="programlisting">Target(from)
+</pre>
+
+ requires
+ 
+<pre class="programlisting">convert_to<Target>(from)
+</pre>
+
+ The same applies to classes or algorithms relying on the assignment operator.
+ So instead of requiring
+ 
+<pre class="programlisting">to = from
+</pre>
+
+ requires
+ 
+<pre class="programlisting">assign_to(to, from);
+</pre>
+
+ The default implementation of <code class="computeroutput">assign_to</code>
+ relies on the assignment operator
+ 
+<pre class="programlisting">template < typename Target, typename Source >
+To& assign_to(Target& to, const Source& from)
+{
+ to = from;
+ return to;
+}
+</pre>
+
+ For classes that are explicitly convertible and having a self assignment
+ operator it is easy to make a specialization of <code class="computeroutput">assign_to</code>
+ as follows.
+ 
+<pre class="programlisting">to = convert_to<Target>(from);
+</pre>
+
+ The rationale is that if there was not a copy constructor from a Source seems
+ reasonable to think that there will not be an assignment operator. So in
+ most of the cases, once we have specialized the convert_to function we recover
+ a reasonable implementation for the <code class="computeroutput">assign_to</code>
+ function.
+ 
+
+ When doing multiple assignments we use to do
+ 
+<pre class="programlisting">a = b = c;
+</pre>
+
+ With <code class="computeroutput">assign_to</code> we could do
+ 
+<pre class="programlisting">assign_to(a, assign_to(b, c));
+</pre>
+
+ and if we find this not really readable we can try with
+ 
+<pre class="programlisting">mca(a) = mca(b) = c;
+</pre>
+
+ The behavior of mca recall the tie function of Boost.Tuple, but instead of
+ allowing multiple assignations, allows a single assign_to call.
+ 
+
+ We can even generalize this, so classes or algorithms relying on a member
+ function can be made more generic by relaying on a function. The default
+ function implementation could just to call to the member function with the
+ equivalent prototype, but this is out of the scope of this library.
+ 
+
+ So one of the advantages of using this common functions is uniformity. The
+ other is that now we are able to find all the explicit conversions to one
+ type, as we can do with explicit casts.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost.conversion.users_guide"></a> Users' Guide
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.conversion.users_guide.getting_started"> Getting
+ Started</a></dt>
+<dd><dl>
+<dt><a href="index.html#boost.conversion.users_guide.getting_started.install">
+ Installing Conversion</a></dt>
+<dt><a href="index.html#boost.conversion.users_guide.getting_started.hello_world__">Hello
+ World! </a></dt>
+</dl></dd>
+<dt>Tutorial</dt>
+<dd><dl>
+<dt><a href="index.html#boost.conversion.users_guide.tutorial.using_generic_conversions">Using
+ generic conversions</a></dt>
+<dt><a href="index.html#boost.conversion.users_guide.tutorial.using_specific_conversions">Using
+ specific conversions</a></dt>
+<dt><a href="index.html#boost.conversion.users_guide.tutorial.how_to_specialize_the_conversion_functions">How
+ to specialize the conversion functions</a></dt>
+<dt><a href="index.html#boost.conversion.users_guide.tutorial.how_to_partially_specialize_the_conversion_functions_for_standadr_types_">How
+ to partially specialize the conversion functions for standadr types?</a></dt>
+<dt><a href="index.html#boost.conversion.users_guide.tutorial.how_to_convert_to_types_needing_some_constructors_arguments_">How
+ to convert to types needing some constructors arguments?</a></dt>
+</dl></dd>
+<dt><a href="index.html#boost.conversion.users_guide.ext_references"> External
+ Resources</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.users_guide.getting_started"></a><a href="index.html#boost.conversion.users_guide.getting_started" title=" Getting
+ Started"> Getting
+ Started</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.conversion.users_guide.getting_started.install">
+ Installing Conversion</a></dt>
+<dt><a href="index.html#boost.conversion.users_guide.getting_started.hello_world__">Hello
+ World! </a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.users_guide.getting_started.install"></a><a href="index.html#boost.conversion.users_guide.getting_started.install" title="
+ Installing Conversion">
+ Installing Conversion</a>
+</h4></div></div></div>
+<a name="boost.conversion.users_guide.getting_started.install.getting_boost_conversion"></a><h5>
+<a name="id4998214"></a>
+ <a href="index.html#boost.conversion.users_guide.getting_started.install.getting_boost_conversion">Getting
+ Boost.Conversion</a>
+ </h5>
+
+ You can get the last stable release of Boost.Conversion by downloading
+ <code class="literal">conversion.zip</code> from the <a href="http://www.boostpro.com/vault/index.php?action=downloadfile&filename=conversion.zip&directory=Utilities&" target="_top">Boost
+ Vault Utilities directory</a>
+ 
+
+ You can also access the latest (unstable?) state from the <a href="https://svn.boost.org/svn/boost/sandbox/conversion" target="_top">Boost
+ Sandbox</a>.
+ 
+<a name="boost.conversion.users_guide.getting_started.install.building_boost_conversion"></a><h5>
+<a name="id4998265"></a>
+ <a href="index.html#boost.conversion.users_guide.getting_started.install.building_boost_conversion">Building
+ Boost.Conversion</a>
+ </h5>
+
+ There is no need to compile Boost.Conversion,
+ since it's a header only library. Just include your Boost header directory
+ in your compiler include path.
+ 
+<a name="boost.conversion.users_guide.getting_started.install.requirements"></a><h5>
+<a name="id4998297"></a>
+ Requirements
+ </h5>
+
+ The genric part of Boost.Conversion depends
+ only on Boost.Config. Of course it depends on the specific libraries when
+ specific conversion are used.
+ 
+<a name="boost.conversion.users_guide.getting_started.install.exceptions_safety"></a><h5>
+<a name="id4998329"></a>
+ <a href="index.html#boost.conversion.users_guide.getting_started.install.exceptions_safety">Exceptions
+ safety</a>
+ </h5>
+
+ All functions in the library are exception-neutral and provide strong guarantee
+ of exception safety as long as the underlying parameters provide it.
+ 
+<a name="boost.conversion.users_guide.getting_started.install.thread_safety"></a><h5>
+<a name="id4998355"></a>
+ <a href="index.html#boost.conversion.users_guide.getting_started.install.thread_safety">Thread
+ safety</a>
+ </h5>
+
+ All functions in the library are thread-unsafe except when noted explicitly.
+ 
+<a name="boost.conversion.users_guide.getting_started.install.tested_compilers"></a><h5>
+<a name="id4998380"></a>
+ <a href="index.html#boost.conversion.users_guide.getting_started.install.tested_compilers">Tested
+ compilers</a>
+ </h5>
+
+ Currently, Boost.Conversion has been tested
+ in the following compilers/platforms:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ GCC 3.4.4 Cygwin
+ </li>
+<li>
+ GCC 3.4.6 Linux
+ </li>
+<li>
+ GCC 4.1.2 Linux
+ </li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ Please send any questions, comments and bug reports to boost <at>
+ lists <dot> boost <dot> org.
+ </td></tr>
+</table></div>
+</div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.users_guide.getting_started.hello_world__"></a><a href="index.html#boost.conversion.users_guide.getting_started.hello_world__" title="Hello
+ World! ">Hello
+ World! </a>
+</h4></div></div></div></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.users_guide.tutorial"></a>Tutorial
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.conversion.users_guide.tutorial.using_generic_conversions">Using
+ generic conversions</a></dt>
+<dt><a href="index.html#boost.conversion.users_guide.tutorial.using_specific_conversions">Using
+ specific conversions</a></dt>
+<dt><a href="index.html#boost.conversion.users_guide.tutorial.how_to_specialize_the_conversion_functions">How
+ to specialize the conversion functions</a></dt>
+<dt><a href="index.html#boost.conversion.users_guide.tutorial.how_to_partially_specialize_the_conversion_functions_for_standadr_types_">How
+ to partially specialize the conversion functions for standadr types?</a></dt>
+<dt><a href="index.html#boost.conversion.users_guide.tutorial.how_to_convert_to_types_needing_some_constructors_arguments_">How
+ to convert to types needing some constructors arguments?</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.users_guide.tutorial.using_generic_conversions"></a><a href="index.html#boost.conversion.users_guide.tutorial.using_generic_conversions" title="Using
+ generic conversions">Using
+ generic conversions</a>
+</h4></div></div></div>
+
+ When you need to make a generic explicit conversion or assignation you
+ just need to include the file <code class="computeroutput">boost/conversion/convert_to.hpp</code>
+ or <code class="computeroutput">boost/conversion/assign_to.hpp</code> and just use the boost conversion
+ function.
+ 
+<pre class="programlisting">#include <boost/conversion/convert_to.hpp>
+
+// ...
+
+int i = convert_to<int>(3.5);
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.users_guide.tutorial.using_specific_conversions"></a><a href="index.html#boost.conversion.users_guide.tutorial.using_specific_conversions" title="Using
+ specific conversions">Using
+ specific conversions</a>
+</h4></div></div></div>
+
+ When you need to make a specific conversion you will need to include the
+ specific conversion file. E.g.
+ 
+<pre class="programlisting">#include <boost/conversion/std/pair.hpp>
+
+std::pair<int,int> pint(0,1);
+std::pair<double,double> pdouble=boost::convert_to<std::pair<double,double> >(pint);
+</pre>
+
+ Do not forget to include this files when you use a generic class or algorithm
+ using the generic <code class="computeroutput">convert_to</code>
+ or <code class="computeroutput">assign_to</code>, otherwise
+ your program should not compile. E.g. if you want to convert a pair of
+ <code class="computeroutput">chrono::time_point<></code>
+ to a pair of <code class="computeroutput">posix_time::ptime</code>
+ do not forget to include in addition to the <code class="computeroutput">boost/conversion/std/pair.hpp</code>
+ the file <code class="computeroutput">boost/conversion/boost/chrono_posix_time.hpp</code>
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.users_guide.tutorial.how_to_specialize_the_conversion_functions"></a><a href="index.html#boost.conversion.users_guide.tutorial.how_to_specialize_the_conversion_functions" title="How
+ to specialize the conversion functions">How
+ to specialize the conversion functions</a>
+</h4></div></div></div>
+
+ You can add an overload of <code class="computeroutput">convert_to</code>
+ and <code class="computeroutput">assign_to</code> functions
+ as you will do for the swap function for example, but we have to use a
+ trick to allow ADL and avoid infinite recursion and ambiguity. This trick
+ consists in adding a unused parameter representing the target type. E.g.
+ if you want to add an explicit conversion from a type <code class="computeroutput">A</code>
+ to a type <code class="computeroutput">B</code> do the following:
+ 
+<pre class="programlisting">namespace my_own_namespace {
+ B convert_to(const A& from, boost::dummy::type_tag<B> const&);
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.users_guide.tutorial.how_to_partially_specialize_the_conversion_functions_for_standadr_types_"></a><a href="index.html#boost.conversion.users_guide.tutorial.how_to_partially_specialize_the_conversion_functions_for_standadr_types_" title="How
+ to partially specialize the conversion functions for standadr types?">How
+ to partially specialize the conversion functions for standadr types?</a>
+</h4></div></div></div>
+
+ As it has been explained in the introduction, we can not use ADL for standard
+ types, as we can not add new functions on the standad std namespace. For
+ these types we need to specialize the boost::conversion::convert_to function.
+ 
+<pre class="programlisting">template < typename Target, typename Source >
+Target convert_to(const Source& val, boost::dummy::type_tag<Target> const&)
+</pre>
+
+ With compilers supporting partial specialization of function templates
+ there is no major problem. For the others, we need to use a trick; as it
+ allows partial specialization of classes we can define <code class="computeroutput">convert_to</code>
+ by as relying to a specific function of a class, as follows:
+ 
+<pre class="programlisting">namespace boost { namespace conversion {
+ namespace partial_specialization_workaround {
+ template < typename Target, typename Source >
+ struct convert_to {
+ static Target apply(const Source& val);
+ };
+ }
+
+ template < typename Target, typename Source >
+ Target convert_to(const Source& val, dummy::type_tag<Target> const&=dummy::type_tag<Target>()) {
+ return partial_specialization_workaround::convert_to<Target,Source>::apply(val);
+ }
+}}
+</pre>
+
+ So now we can specialize <code class="computeroutput">partial_specialization_workaround::convert_to</code>
+ for pairs as follows:
+ 
+<pre class="programlisting">namespace partial_specialization_workaround {
+ template <typename Target1, typename Target2, typename Source1, typename Source2)
+ struct convert_to< std::pair<Target1,Target2>, std::pair<Source1,Source2> > {
+ inline static std::pair<Target1,Target2> apply(std::pair<Source1,Source2>& v) {
+ {
+ return std::pair<T1,T2>(convert_to<T1>(from.first), convert_to<T2>(from.second));
+ }
+ };
+
+}
+</pre>
+
+ The same applies to the generic <code class="computeroutput">assign_to</code>
+ function.
+ 
+<pre class="programlisting">namespace partial_specialization_workaround {
+ template < typename Target, typename Source >
+ struct assign_to {
+ inline static To& apply(Target& to, const Source& from)
+ {
+ to = from;
+ return to;
+ }
+ };
+}
+template < typename Target, typename Source >
+To& assign_to(Target& to, const Source& from, dummy::type_tag<Target> const&) {
+ return partial_specialization_workaround::assign_to<Target,Source>::apply(to, from);
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.users_guide.tutorial.how_to_convert_to_types_needing_some_constructors_arguments_"></a><a href="index.html#boost.conversion.users_guide.tutorial.how_to_convert_to_types_needing_some_constructors_arguments_" title="How
+ to convert to types needing some constructors arguments?">How
+ to convert to types needing some constructors arguments?</a>
+</h4></div></div></div>
+
+ Sometimes we need the conversion construct the resulting type with some
+ arguments. This could be the case for example of std::vector, for which
+ we need to pass an allocator to the constructor. In order to maintain the
+ same signature, the library provides a <code class="computeroutput">pack</code>
+ function that will wrap the Source and the Target constructor parameters
+ in a single parameter. So the overloading must be done on the result of
+ this <code class="computeroutput">pack</code> function.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.users_guide.ext_references"></a><a href="index.html#boost.conversion.users_guide.ext_references" title=" External
+ Resources"> External
+ Resources</a>
+</h3></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>Boost.Convert</dt>
+<dd>
+ Vladimir Batov. Not yet scheduled
+ </dd>
+<dt>Boost.Conversion.LexicalCast</dt>
+<dd>
+ general literal text conversions, such as an int represented as a string,
+ or vice-versa from Kevlin Henney
+ </dd>
+<dt>Boost.NumericConversion</dt>
+<dd>
+ Optimized Policy-based Numeric Conversions from Fernando Cacciola.
+ </dd>
+<dt><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2380.pdf" target="_top">N2380 - Explicit Conversion Operator Draft Working Paper (revision
+ 2)</a></dt>
+<dd>
+ Lois Goldthwaite, Michael Wong, Jens Mauer, Alisdair Meredith.
+ </dd>
+<dt>N2200 - Operator Overloading</dt>
+<dd>
+ Gary Powell, Doug Gregor, Jaakko Jarvi.
+ </dd>
+<dt>N1671 - Overloading operator.() & operator.*()</dt>
+<dd>
+ Gary Powell, Doug Gregor, Jaakko Jarvi.
+ </dd>
+<dt>N1676 - Non-member overloaded copy assignment operator</dt>
+<dd>
+ Bronek Kozicki.
+ </dd>
+<dt>N1694 - A Proposal to Extend the Function Call Operator</dt>
+<dd>
+ Bronek Kozicki.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost.conversion.reference"></a>Reference
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt> Header <boost/conversion.hpp></dt>
+<dt>Core</dt>
+<dd><dl>
+<dt><a href="index.html#boost.conversion.reference.core.convert_to_hpp"> Header
+ <code class="computeroutput"><boost/conversion/convert_to.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.core.assign_to_hpp"> Header
+ <code class="computeroutput"><boost/conversion/assign_to.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.core.convert_to_via_hpp">
+ Header <code class="computeroutput"><boost/conversion/convert_to_via.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp"> Header
+ <code class="computeroutput"><boost/conversion/ca_wrapper.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.core.pack_hpp"> Header
+ <code class="computeroutput"><boost/conversion/pack.hpp></code></a></dt>
+</dl></dd>
+<dt><a href="index.html#boost.conversion.reference.c___standard_classes_specializations">C++
+ Standard classes specializations</a></dt>
+<dd><dl>
+<dt><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.complex_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/complex.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.pair_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/pair.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.vector_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/vector.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.string_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/string.hpp></code></a></dt>
+</dl></dd>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations">Boost
+ classes specializations</a></dt>
+<dd><dl>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.rational_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/rational.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.chrono_posix_time_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/chrono_posix_time.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.interval_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/interval.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.optional_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/optional.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.array_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/array.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.tuple_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/tuple.hpp></code></a></dt>
+</dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.reference.conversion_hpp"></a> Header <boost/conversion.hpp>
+</h3></div></div></div>
+
+ Include all the core conversion public header files. Note that you will need
+ to include explicitly the C++ standard or Boost specific files when using
+ specific classes.
+ 
+<pre class="programlisting">#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/conversion/convert_to_via.hpp>
+#include <boost/conversion/ca_wrapper.hpp>
+#include <boost/conversion/pack.hpp>
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.reference.core"></a>Core
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.conversion.reference.core.convert_to_hpp"> Header
+ <code class="computeroutput"><boost/conversion/convert_to.hpp></code></a></dt>
+<dd><dl><dt><a href="index.html#boost.conversion.reference.core.convert_to_hpp.function__convert_to___">Function
+ <code class="computeroutput">convert_to()</code></a></dt></dl></dd>
+<dt><a href="index.html#boost.conversion.reference.core.assign_to_hpp"> Header
+ <code class="computeroutput"><boost/conversion/assign_to.hpp></code></a></dt>
+<dd><dl><dt><a href="index.html#boost.conversion.reference.core.assign_to_hpp.function__assign_to___">Function
+ <code class="computeroutput">assign_to()</code></a></dt></dl></dd>
+<dt><a href="index.html#boost.conversion.reference.core.convert_to_via_hpp">
+ Header <code class="computeroutput"><boost/conversion/convert_to_via.hpp></code></a></dt>
+<dd><dl><dt><a href="index.html#boost.conversion.reference.core.convert_to_via_hpp.function__convert_to_via_____">Function
+ <code class="computeroutput">convert_to_via<>()</code></a></dt></dl></dd>
+<dt><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp"> Header
+ <code class="computeroutput"><boost/conversion/ca_wrapper.hpp></code></a></dt>
+<dd><dl><dt><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____">Function
+ <code class="computeroutput">mca<>()</code></a></dt></dl></dd>
+<dt><a href="index.html#boost.conversion.reference.core.pack_hpp"> Header
+ <code class="computeroutput"><boost/conversion/pack.hpp></code></a></dt>
+<dd><dl><dt><a href="index.html#boost.conversion.reference.core.pack_hpp.function__pack_____">Function
+ <code class="computeroutput">pack<>()</code></a></dt></dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.convert_to_hpp"></a><a href="index.html#boost.conversion.reference.core.convert_to_hpp" title=" Header
+ <boost/conversion/convert_to.hpp>"> Header
+ <code class="computeroutput"><boost/conversion/convert_to.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.conversion.reference.core.convert_to_hpp.function__convert_to___">Function
+ <code class="computeroutput">convert_to()</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ namespace dummy {
+ template <typename T> struct base_tag {};
+ template <typename T> struct type_tag : public base_tag<T> {};
+ }
+ template <typename T> struct type_tag;
+ namespace conversion {
+ namespace partial_specialization_workaround {
+ template < typename To, typename From >
+ struct convert_to {
+ static To apply(const From& val);
+ };
+ }
+
+ template < typename To, typename From >
+ To convert_to(const From& from, dummy::type_tag<To> const&);
+ }
+
+ template <typename Target, typename Source>
+ Target convert_to(Source const& from, dummy::base_tag<To> const&=dummy::base_tag<To>());
+}
+</pre>
+
+ Defines a free function <code class="computeroutput">convert_to</code>
+ which converts the <code class="computeroutput">from</code>
+ parameter to a <code class="computeroutput">To</code> type.
+ The default implementation applies the conversion <code class="computeroutput">To</code>
+ operator of the <code class="computeroutput">From</code> class
+ or the copy constructor of the <code class="computeroutput">To</code>
+ class. 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 user can add the <code class="computeroutput">convert_to</code>
+ overloading on the namespace of a specific Source. 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 is partially specialize on the function <code class="computeroutput">convert_to</code>
+ on the boost::conversion 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 <code class="computeroutput">apply</code>
+ on a class with the same name in the namespace __partial_specializationworkaround_. Thus the user can specialize partially
+ this class.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.conversion.reference.core.convert_to_hpp.function__convert_to___"></a><a href="index.html#boost.conversion.reference.core.convert_to_hpp.function__convert_to___" title="Function
+ convert_to()">Function
+ <code class="computeroutput">convert_to()</code></a>
+</h5></div></div></div>
+<pre class="programlisting">template < typename To, typename From >
+To convert_to(const From& from, dummy::type_tag<To> const&);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Converts the from parameter to an instance of the To type, using
+ by default the conversion operator or copy constructor.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Whatever the underlying conversion <code class="computeroutput">To</code>
+ operator of the <code class="computeroutput">From</code>
+ class or the copy constructor of the <code class="computeroutput">To</code>
+ class throws.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.assign_to_hpp"></a><a href="index.html#boost.conversion.reference.core.assign_to_hpp" title=" Header
+ <boost/conversion/assign_to.hpp>"> Header
+ <code class="computeroutput"><boost/conversion/assign_to.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.conversion.reference.core.assign_to_hpp.function__assign_to___">Function
+ <code class="computeroutput">assign_to()</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ namespace conversion {
+ namespace partial_specialization_workaround {
+ template < typename To, typename From >
+ struct assign_to {
+ static void apply(To& to, const From& from);
+ };
+ template < typename To, typename From, std::size_t N >
+ struct assign_to<To[N],From[N]> {
+ static void apply(To (&to)[N], const From(& from)[N]);
+ };
+ }
+
+ template < typename To, typename From >
+ void assign_to(To& to, const From& from, dummy::type_tag<To> const&);
+ }
+
+ template <typename Target, typename Source>
+ Target& assign_to(Target& to, const Source& from, dummy::base_tag<To> const&=dummy::base_tag<To>()) {
+ return ::boost_conversion_impl::assign_to_impl<Target, Source>(to, from);
+ }
+}
+</pre>
+
+ Defines a free function <code class="computeroutput">assign_to</code>
+ which assigns the <code class="computeroutput">from</code>
+ parameter to the <code class="computeroutput">to</code> parameter.
+ The default implementation applies the the 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 is partially specialize on the function <code class="computeroutput">assign_to</code>
+ on the boost::conversion 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
+ __partial_specializationworkaround_.
+ This the user can specialize partially this class.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.conversion.reference.core.assign_to_hpp.function__assign_to___"></a><a href="index.html#boost.conversion.reference.core.assign_to_hpp.function__assign_to___" title="Function
+ assign_to()">Function
+ <code class="computeroutput">assign_to()</code></a>
+</h5></div></div></div>
+<pre class="programlisting">template < typename To, typename From >
+void assign_to(To& to, const From& from);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Assigns the <code class="computeroutput">from</code>
+ parameter to the <code class="computeroutput">to</code>
+ parameter, using by default the assignment operator of the <code class="computeroutput">To</code> class.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Whatever the underlying the assignment operator of the <code class="computeroutput">To</code> class throws.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.convert_to_via_hpp"></a><a href="index.html#boost.conversion.reference.core.convert_to_via_hpp" title="
+ Header <boost/conversion/convert_to_via.hpp>">
+ Header <code class="computeroutput"><boost/conversion/convert_to_via.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.conversion.reference.core.convert_to_via_hpp.function__convert_to_via_____">Function
+ <code class="computeroutput">convert_to_via<>()</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+
+ template < typename To, typename Via, typename From >
+ To convert_to_via(const From& val) {
+ convert_to<To>(convert_to<Via>(val));
+ }
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.conversion.reference.core.convert_to_via_hpp.function__convert_to_via_____"></a><a href="index.html#boost.conversion.reference.core.convert_to_via_hpp.function__convert_to_via_____" title="Function
+ convert_to_via<>()">Function
+ <code class="computeroutput">convert_to_via<>()</code></a>
+</h5></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Converts the from parameter to an instance of the To type using
+ a intermediary Via type.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Whatever the underlying conversions functions throw.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp"></a><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp" title=" Header
+ <boost/conversion/ca_wrapper.hpp>"> Header
+ <code class="computeroutput"><boost/conversion/ca_wrapper.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____">Function
+ <code class="computeroutput">mca<>()</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ template <typename T> 'implementation_dependent<T>' mca(T& r);
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____"></a><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____" title="Function
+ mca<>()">Function
+ <code class="computeroutput">mca<>()</code></a>
+</h5></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____.template_class__implementation_dependent_">Template
+ Class <code class="computeroutput">implementation_dependent</code></a></dt></dl></div>
+<pre class="programlisting">template <typename T> 'implementation_dependent<T>' mca(T& r);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns a implementation dependent class able to transform conversion
+ by convert_to call and assignments by assign_to calls.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+</dl>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____.template_class__implementation_dependent_"></a><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____.template_class__implementation_dependent_" title="Template
+ Class implementation_dependent">Template
+ Class <code class="computeroutput">implementation_dependent</code></a>
+</h6></div></div></div>
+<div class="toc"><dl>
+<dt>Constructor</dt>
+<dt><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____.template_class__implementation_dependent_.conversion_operator">Conversion
+ operator</a></dt>
+<dt><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____.template_class__implementation_dependent_.assignment_operator">Assignment
+ operator</a></dt>
+</dl></div>
+<pre class="programlisting">template <typename T>
+class implementation_dependent {
+public:
+ implementation_dependent(T& r);
+ template <typename U> operator U();
+ template <typename U> T& operator =(U const& u);
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____.template_class__implementation_dependent_.constructor"></a>Constructor
+</h6></div></div></div>
+<pre class="programlisting">implementation_dependent(T& r);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Stores the reference to type.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____.template_class__implementation_dependent_.conversion_operator"></a><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____.template_class__implementation_dependent_.conversion_operator" title="Conversion
+ operator">Conversion
+ operator</a>
+</h6></div></div></div>
+<pre class="programlisting">template <typename U> operator U();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call to the <code class="computeroutput">convert_to<U></code> on the stored reference.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Whatever <code class="computeroutput">convert_to</code>
+ throws.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____.template_class__implementation_dependent_.assignment_operator"></a><a href="index.html#boost.conversion.reference.core.ca_wrapper_hpp.function__mca_____.template_class__implementation_dependent_.assignment_operator" title="Assignment
+ operator">Assignment
+ operator</a>
+</h6></div></div></div>
+<pre class="programlisting">template <typename U> T& operator =(U const& u);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call to the <code class="computeroutput">assign_to<T,U></code> with the stored reference
+ and the passed parameter <code class="computeroutput">u</code>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Whatever <code class="computeroutput">assign_to</code>
+ throws.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.pack_hpp"></a><a href="index.html#boost.conversion.reference.core.pack_hpp" title=" Header
+ <boost/conversion/pack.hpp>"> Header
+ <code class="computeroutput"><boost/conversion/pack.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.conversion.reference.core.pack_hpp.function__pack_____">Function
+ <code class="computeroutput">pack<>()</code></a></dt></dl></div>
+
+ The result of the <code class="computeroutput">pack</code>
+ function is equivalent to a fusion sequence containing reference_warpper's
+ instead of C++ reference (&) as this are not allowed.
+ 
+<pre class="programlisting">namespace boost { namespace conversion {
+ namespace result_of
+ template <typename T1, typename T2, ...>
+ struct pack {
+ typedef fusion::sequence<
+ reference_wrapper<T1>, reference_wrapper<T2, ...>
+ > type;
+ };
+ }
+ template <typename T1, typename T2, ...>
+ typename result_of_pack<T1 const, T2 const>::type pack(
+ T1 const& t1, T2 const& t2);
+
+ template <typename T1, typename T2, ...>
+ typename result_of_pack<T1 const, T2, ...>::type pack(T1 const& t1, T2 & t2, ...);
+
+ ...
+
+} }
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.conversion.reference.core.pack_hpp.function__pack_____"></a><a href="index.html#boost.conversion.reference.core.pack_hpp.function__pack_____" title="Function
+ pack<>()">Function
+ <code class="computeroutput">pack<>()</code></a>
+</h5></div></div></div>
+<pre class="programlisting">template <typename T1, typename T2>
+typename result_of_pack<T1 const, T2 const>::type pack(
+ T1 const& t1, T2 const& t2);
+
+template <typename T1, typename T2>
+typename result_of_pack<T1 const, T2>::type pack(
+ T1 const& t1, T2 & t2);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns a packed type from the template parameters.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.reference.c___standard_classes_specializations"></a><a href="index.html#boost.conversion.reference.c___standard_classes_specializations" title="C++
+ Standard classes specializations">C++
+ Standard classes specializations</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.complex_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/complex.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.pair_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/pair.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.vector_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/vector.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.string_hpp">
+ Header <code class="computeroutput"><boost/conversion/std/string.hpp></code></a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.c___standard_classes_specializations.complex_hpp"></a><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.complex_hpp" title="
+ Header <boost/conversion/std/complex.hpp>">
+ Header <code class="computeroutput"><boost/conversion/std/complex.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between complex of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+ namespace conversion {
+ namespace partial_specialization_workaround {
+ template < class T, class U>
+ struct convert_to< std::complex<T>, std::complex<U> > {
+ static std::complex<T> apply(std::complex<U> const & from);
+ };
+ template < class T, class U>
+ struct convert_to< std::complex<T>, std::complex<U> > {
+ static std::complex<T>& apply(const std::complex<U>& from, std::complex<T>& to);
+ };
+
+ }}
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.c___standard_classes_specializations.pair_hpp"></a><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.pair_hpp" title="
+ Header <boost/conversion/std/pair.hpp>">
+ Header <code class="computeroutput"><boost/conversion/std/pair.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between pairs of convertible types.
+ 
+<pre class="programlisting">namespace boost {
+ namespace conversion {
+ namespace partial_specialization_workaround {
+ template < class T1, class T2, class U1, class U2>
+ struct convert_to< std::pair<T1,T2>, std::pair<U1,U2> > {
+ static std::pair<T1,T2> apply(std::pair<U1,U2> const & from);
+ };
+ template < class T1, class T2, class U1, class U2>
+ struct assign_to< std::pair<T1,T2>, std::pair<U1,U2> > {
+ static std::pair<T1,T2>& apply(std::pair<T1,T2>& to, const std::pair<U1,U2>&amp
; from);
+ };
+ }}
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.c___standard_classes_specializations.vector_hpp"></a><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.vector_hpp" title="
+ Header <boost/conversion/std/vector.hpp>">
+ Header <code class="computeroutput"><boost/conversion/std/vector.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between std::vector of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+ namespace conversion {
+ namespace partial_specialization_workaround {
+ template < class T1, class A1, class T2, class A2>
+ struct convert_to< std::vector<T1,A1>, std::vector<T2,A2> > {
+ inline static std::vector<T1,A1> apply(std::vector<T2,A2> const & from);
+ };
+ template < class T1, class A1, class T2, class A2>
+ struct assign_to< std::vector<T1,A1>, std::vector<T2,A2> > {
+ inline static std::vector<T1,A1>& apply(
+ std::vector<T1,A1>& to,
+ std::vector<T2,A2> const & from);
+ };
+
+ template < class T1, class A1, class T2, class A2>
+ struct convert_to< std::vector<T1,A1>,
+ typename result_of_pack<std::vector<T2,A2> const, A1 const>::type
+ > {
+ inline static std::vector<T1,A1> apply(
+ typename result_of_pack<std::vector<T2,A2> const, A1 const>::type const & pack);
+ };
+ }}
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.c___standard_classes_specializations.string_hpp"></a><a href="index.html#boost.conversion.reference.c___standard_classes_specializations.string_hpp" title="
+ Header <boost/conversion/std/string.hpp>">
+ Header <code class="computeroutput"><boost/conversion/std/string.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions to std::string.
+ 
+<pre class="programlisting">namespace boost {
+ namespace conversion {
+ namespace partial_specialization_workaround {
+ template<typename T, typename CharT, typename Traits, typename Alloc>
+ struct convert_to< std::basic_string<CharT,Traits,Alloc>, T > {
+ static std::basic_string<CharT,Traits,Alloc> apply(T const & from);
+ }
+ template<typename T, typename CharT, typename Traits, typename Alloc>
+ struct assign_to< std::basic_string<CharT,Traits,Alloc>, T > {
+ static std::basic_string<CharT,Traits,Alloc>& apply(
+ std::basic_string<CharT,Traits,Alloc>& to, const T& from);
+ };
+ template<typename T, typename CharT, typename Traits, typename Alloc>
+ struct convert_to< T, std::basic_string<CharT,Traits,Alloc>> {
+ static T apply(std::basic_string<CharT,Traits,Alloc> const & from);
+ };
+ template<typename T, typename CharT, typename Traits, typename Alloc>
+ struct assign_to< T, std::basic_string<CharT,Traits,Alloc>> {
+ static void apply(T& to
+ const std::basic_string<CharT,Traits,Alloc>& from);
+ };
+ }}
+}
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations"></a><a href="index.html#boost.conversion.reference.boost_classes_specializations" title="Boost
+ classes specializations">Boost
+ classes specializations</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.rational_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/rational.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.chrono_posix_time_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/chrono_posix_time.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.interval_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/interval.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.optional_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/optional.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.array_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/array.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.boost_classes_specializations.tuple_hpp">
+ Header <code class="computeroutput"><boost/conversion/boost/tuple.hpp></code></a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.rational_hpp"></a><a href="index.html#boost.conversion.reference.boost_classes_specializations.rational_hpp" title="
+ Header <boost/conversion/boost/rational.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/rational.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between rational of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+ template < class T, class U>
+ rational<T> convert_to(rational<U> const & from
+ , boost::dummy::type_tag<rational<T> > const&);
+
+ template < class T, class U>
+ rational<T>& assign_to(rational<T>& to, const rational<U>& from
+ , boost::dummy::type_tag<rational<T> > const&);
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.chrono_posix_time_hpp"></a><a href="index.html#boost.conversion.reference.boost_classes_specializations.chrono_posix_time_hpp" title="
+ Header <boost/conversion/boost/chrono_posix_time.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/chrono_posix_time.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between chrono and posix_time
+ time and duration types.
+ 
+<pre class="programlisting">namespace boost {
+namespace chrono {
+ template < class Clock, class Duration>
+ posix_time::ptime convert_to(const chrono::time_point<Clock, Duration>& from
+ , boost::dummy::type_tag<posix_time::ptime> const&);
+
+ template < class Clock, class Duration>
+ 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&);;
+
+}
+namespace posix_time {
+ template < class Clock, class Duration>
+ chrono::time_point<Clock, Duration> convert_to(const ptime& from
+ , boost::dummy::type_tag<chrono::time_point<Clock, Duration> > const&);
+
+ template < class Clock, class Duration>
+ ptime& assign_to(ptime& to, const chrono::time_point<Clock, Duration>& from
+ , boost::dummy::type_tag<posix_time::ptime> const&);
+}
+
+namespace chrono {
+ template < class Rep, class Period>
+ inline posix_time::time_duration convert_to(chrono::duration<Rep, Period> const & from
+ , boost::dummy::type_tag<posix_time::time_duration> const&);
+
+ template < class Rep, class Period>
+ inline chrono::duration<Rep, Period> & assign_to(chrono::duration<Rep, Period> & to, const posix_time::time_duration& fro
m
+ , boost::dummy::type_tag<chrono::duration<Rep, Period> > const&);
+}
+
+namespace posix_time {
+ template < class Rep, class Period>
+ inline chrono::duration<Rep, Period> convert_to(time_duration const & from
+ , boost::dummy::type_tag<chrono::duration<Rep, Period> > const&);
+
+ template < class Rep, class Period>
+ inline time_duration& assign_to(time_duration& to, const chrono::duration<Rep, Period>& from
+ , boost::dummy::type_tag<posix_time::time_duration> const&);
+}
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.interval_hpp"></a><a href="index.html#boost.conversion.reference.boost_classes_specializations.interval_hpp" title="
+ Header <boost/conversion/boost/interval.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/interval.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between intervals of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+namespace numeric {
+ template < class T, class PT, class U, class PU>
+ interval<T,PT> convert_to(interval<U,PU> const & from
+ , boost::dummy::type_tag<interval<T,PT> > const&);
+
+ template < class T, class PT, class U, class PU>
+ inline interval<T,PT>& assign_to(interval<T,PT>& to, const interval<U,PU>& from
+ , boost::dummy::type_tag<interval<T,PT> > const&);
+}
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.optional_hpp"></a><a href="index.html#boost.conversion.reference.boost_classes_specializations.optional_hpp" title="
+ Header <boost/conversion/boost/optional.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/optional.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between optional of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+ template < class Target, class Source>
+ optional<Target> convert_to(optional<Source> const & from
+ , boost::dummy::type_tag<optional<Target> > const&);
+
+ template < class Target, class Source>
+ optional<Target>& assign_to(optional<Target>& to, const optional<Source>& from
+ , boost::dummy::type_tag<optional<Target> > const&);
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.array_hpp"></a><a href="index.html#boost.conversion.reference.boost_classes_specializations.array_hpp" title="
+ Header <boost/conversion/boost/array.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/array.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between arrays of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+ template < typename T1, typename T2, std::size_t N>
+ array<T1,N> convert_to(array<T2,N> const & from
+ , boost::dummy::type_tag<array<T1,N> > const&);;
+
+ template < typename T1, typename T2, std::size_t N>
+ array<T1,N>& assign_to(array<T1,N>& to, array<T2,N> const & from
+ , boost::dummy::type_tag<array<T1,N> > const&);
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.boost_classes_specializations.tuple_hpp"></a><a href="index.html#boost.conversion.reference.boost_classes_specializations.tuple_hpp" title="
+ Header <boost/conversion/boost/tuple.hpp>">
+ Header <code class="computeroutput"><boost/conversion/boost/tuple.hpp></code></a>
+</h4></div></div></div>
+
+ Include this file when using conversions between fusion::tuple of convertible
+ types.
+ 
+<pre class="programlisting">namespace boost {
+namespace fusion {
+ template < class T1, class T2, class U1, class U2>
+ tuple<T1,T2> convert_to(tuple<U1,U2> const & from
+ , boost::dummy::type_tag<tuple<T1,T2> > const&);
+
+ template < class T1, class T2, class U1, class U2>
+ tuple<T1,T2>& assign_to(tuple<T1,T2>& to, tuple<U1,U2> const & from
+ , boost::dummy::type_tag<tuple<T1,T2> > const&);
+
+ template < class T1, class T2, class T3, class U1, class U2, class U3>
+ tuple<T1,T2,T3> convert_to(tuple<U1,U2,U3> const & from
+ , boost::dummy::type_tag<tuple<T1,T2,T3> > const&);;
+
+ template < class T1, class T2, class T3, class U1, class U2, class U3>
+ tuple<T1,T2,T3> 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>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost.conversion.examples"></a>Examples
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.conversion.examples.chrono__time_point_and_posix_time__ptime">chrono::time_point
+ and posix_time::ptime</a></dt>
+<dt>boost::optional</dt>
+<dt>std::pair</dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.examples.chrono__time_point_and_posix_time__ptime"></a><a href="index.html#boost.conversion.examples.chrono__time_point_and_posix_time__ptime" title="chrono::time_point
+ and posix_time::ptime">chrono::time_point
+ and posix_time::ptime</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#ifndef BOOST_CONVERT_TO_CHRONO_TIME_POINT_TO_POSIX_TIME_PTIME__HPP
+#define BOOST_CONVERT_TO_CHRONO_TIME_POINT_TO_POSIX_TIME_PTIME__HPP
+
+#include <boost/chrono/chrono.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/date_time/posix_time/conversion.hpp>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/config.hpp>
+
+namespace boost {
+ #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ namespace conversion { namespace partial_specialization_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)
+ {
+ typedef chrono::time_point<Clock, Duration> time_point_t;
+ typedef chrono::nanoseconds duration_t;
+ typedef duration_t::rep rep_t;
+ rep_t d = chrono::duration_cast<duration_t>(from.time_since_epoch()).count();
+ rep_t sec = d/1000000000;
+ rep_t nsec = d%1000000000;
+ return posix_time::from_time_t(0)+
+ posix_time::seconds(static_cast<long>(sec))+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+ posix_time::nanoseconds(nsec);
+#else
+ posix_time::microseconds((nsec+500)/1000);
+#endif
+ }
+ };
+ template < class Clock, class Duration>
+ 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);
+ return to;
+ }
+ };
+
+ template < class Clock, class Duration>
+ struct convert_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
+ inline static chrono::time_point<Clock, Duration> apply(const posix_time::ptime& from)
+ {
+ posix_time::time_duration const time_since_epoch=from-posix_time::from_time_t(0);
+ chrono::time_point<Clock, Duration> t=chrono::system_clock::from_time_t(time_since_epoch.total_seconds());
+ long nsec=time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second());
+ return t+chrono::nanoseconds(nsec);
+
+ }
+ };
+ template < class Clock, class Duration>
+ 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);
+ return to;
+ }
+ };
+ }}
+ #else
+ 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&)
+ {
+ typedef chrono::time_point<Clock, Duration> time_point_t;
+ typedef chrono::nanoseconds duration_t;
+ typedef duration_t::rep rep_t;
+ rep_t d = chrono::duration_cast<duration_t>(from.time_since_epoch()).count();
+ rep_t sec = d/1000000000;
+ rep_t nsec = d%1000000000;
+ return posix_time::from_time_t(0)+
+ posix_time::seconds(static_cast<long>(sec))+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+ posix_time::nanoseconds(nsec);
+#else
+ posix_time::microseconds((nsec+500)/1000);
+#endif
+ }
+
+
+ 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::convert_to<chrono::time_point<Clock, Duration> >(from);
+ return to;
+ }
+
+ }
+ namespace posix_time {
+ template < class Clock, class Duration>
+ inline chrono::time_point<Clock, Duration> convert_to(const ptime& from
+ , boost::dummy::type_tag<chrono::time_point<Clock, Duration> > const&)
+ {
+ time_duration const time_since_epoch=from-from_time_t(0);
+ chrono::time_point<Clock, Duration> t=chrono::system_clock::from_time_t(time_since_epoch.total_seconds());
+ long nsec=time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second());
+ return t+chrono::nanoseconds(nsec);
+ }
+
+ 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::convert_to<ptime>(from);
+ return to;
+ }
+
+ }
+ #endif
+}
+
+#endif
+</pre>
+
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.examples.boost__optional"></a>boost::optional
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#ifndef BOOST_CONVERT_TO_OPTIONAL__HPP
+#define BOOST_CONVERT_TO_OPTIONAL__HPP
+
+#include <boost/optional.hpp>
+#include <boost/none.hpp>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/config.hpp>
+
+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>());
+ }
+
+ 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 = from?boost::convert_to<Target>(from.get()):optional<Target>();
+ return to;
+ }
+ #endif
+}
+
+#endif
+
+</pre>
+
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.examples.std__pair"></a>std::pair
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#ifndef BOOST_CONVERT_TO_PAIR__HPP
+#define BOOST_CONVERT_TO_PAIR__HPP
+
+#include <utility>
+//#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+
+namespace boost { namespace conversion {
+
+ // std namespace can not be overloaded
+ namespace partial_specialization_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));
+ }
+ };
+ 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);
+ return to;
+ }
+ };
+ }
+}}
+
+#endif
+
+</pre>
+
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost.conversion.appendices"></a>Appendices
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt> Appendix A: History</dt>
+<dd><dl>
+<dt><a href="index.html#boost.conversion.appendices.history.__version_0_5_0__may_30__2010____adding_pack_expression_">Version 0.5.0, May 30, 2010 Adding pack
+ expression</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.history.__version_0_4_0__october_27__2009____applying_the_same_technique_that_boost__swap_applies_making_use_of_adl_">Version 0.4.0, October 27, 2009 Applying
+ the same technique that boost::swap applies making use of ADL</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.history.__version_0_3_0__october_22__2009____changing_the_order_of__to__and__from__parameters_on___assign_to___function___added__mca__function_">Version 0.3.0, October 22, 2009 Changing
+ the order of <code class="computeroutput">to</code> and <code class="computeroutput">from</code> parameters on <code class="computeroutput">assign_to</code>
+ function + Added <code class="computeroutput">mca</code> function</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.history.__version_0_2_0__mai_16__2009____adding_array___fusion__tuples___adaptation_to_boost_1_39_">Version 0.2.0, Mai 16, 2009 Adding array
+ + fusion::tuples + Adaptation to Boost 1.39</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.history.__version_0_1_0__april_16__2009____announcement_of_conversions_">Version 0.1.0, April 16, 2009 Announcement
+ of Conversions</a></dt>
+</dl></dd>
+<dt> Appendix B: Rationale</dt>
+<dt><a href="index.html#boost.conversion.appendices.implementation"> Appendix
+ C: Implementation Notes</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.acknowledgements"> Appendix
+ D: Acknowledgements</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.appendix_e__tests">Appendix
+ E: Tests</a></dt>
+<dd><dl>
+<dt>Builtins</dt>
+<dt><a href="index.html#boost.conversion.appendices.appendix_e__tests.intrinsic_conversions">Intrinsic
+ Conversions</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.appendix_e__tests.extrinsic_conversions">Extrinsic
+ Conversions</a></dt>
+<dt>Std</dt>
+<dt>Boost</dt>
+</dl></dd>
+<dt><a href="index.html#boost.conversion.appendices.appendix_f__tickets">Appendix
+ F: Tickets</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.todo"> Appendix F: Future
+ plans</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.appendices.history"></a> Appendix A: History
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.conversion.appendices.history.__version_0_5_0__may_30__2010____adding_pack_expression_">Version 0.5.0, May 30, 2010 Adding pack
+ expression</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.history.__version_0_4_0__october_27__2009____applying_the_same_technique_that_boost__swap_applies_making_use_of_adl_">Version 0.4.0, October 27, 2009 Applying
+ the same technique that boost::swap applies making use of ADL</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.history.__version_0_3_0__october_22__2009____changing_the_order_of__to__and__from__parameters_on___assign_to___function___added__mca__function_">Version 0.3.0, October 22, 2009 Changing
+ the order of <code class="computeroutput">to</code> and <code class="computeroutput">from</code> parameters on <code class="computeroutput">assign_to</code>
+ function + Added <code class="computeroutput">mca</code> function</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.history.__version_0_2_0__mai_16__2009____adding_array___fusion__tuples___adaptation_to_boost_1_39_">Version 0.2.0, Mai 16, 2009 Adding array
+ + fusion::tuples + Adaptation to Boost 1.39</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.history.__version_0_1_0__april_16__2009____announcement_of_conversions_">Version 0.1.0, April 16, 2009 Announcement
+ of Conversions</a></dt>
+</dl></div>
+<div class="itemizedlist"><ul type="disc"><li>
+ Add conversion between std::vector of explicitly convertible types.
+ </li></ul></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.history.__version_0_5_0__may_30__2010____adding_pack_expression_"></a><a href="index.html#boost.conversion.appendices.history.__version_0_5_0__may_30__2010____adding_pack_expression_" title="Version 0.5.0, May 30, 2010 Adding pack
+ expression">Version 0.5.0, May 30, 2010 Adding pack
+ expression</a>
+</h4></div></div></div>
+
+ New Features:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Added a pack funcrion able to pack the Source and the Target constructor
+ arguments in one parameter.
+ </li>
+<li>
+ Added conversion between std::vector of explicitly convertible types.
+ </li>
+<li>
+ Added is_convertible_to metafunction. Inherits: If an imaginary lvalue
+ of type From is convertible to type To using convert_to then inherits
+ from true_type, otherwise inherits from false_type.
+ </li>
+</ul></div>
+<pre class="programlisting">template <class From, class To>
+struct is_convertible : public true_type-or-false_type {};
+</pre>
+<div class="itemizedlist"><ul type="disc"><li>
+ Added is_asignable_to metafunction.
+ </li></ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.history.__version_0_4_0__october_27__2009____applying_the_same_technique_that_boost__swap_applies_making_use_of_adl_"></a><a href="index.html#boost.conversion.appendices.history.__version_0_4_0__october_27__2009____applying_the_same_technique_that_boost__swap_applies_making_use_of_adl_" title="Version 0.4.0, October 27, 2009 Applying
+ the same technique that boost::swap applies making use of ADL">Version 0.4.0, October 27, 2009 Applying
+ the same technique that boost::swap applies making use of ADL</a>
+</h4></div></div></div>
+
+ New Features:
+ 
+
+ A <code class="computeroutput">Source</code> class is convertible
+ to a <code class="computeroutput">Target</code> class if:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Either: A function with the signature <code class="computeroutput">convert_to<Target>(Source
+ const&,
+ boost::dummy::type_tag<To>
+ const&)</code>
+ is available via argument dependent lookup
+ </li>
+<li>
+ Or: A template specialization of <code class="computeroutput">boost::conversion::convert_to<Target, Source></code> exists for <code class="computeroutput">Target</code>
+ and <code class="computeroutput">Source</code>
+ </li>
+<li>
+ Or: <code class="computeroutput">Target</code> is copy
+ constructible from <code class="computeroutput">Source</code>
+ (default implementation)
+ </li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.history.__version_0_3_0__october_22__2009____changing_the_order_of__to__and__from__parameters_on___assign_to___function___added__mca__function_"></a><a href="index.html#boost.conversion.appendices.history.__version_0_3_0__october_22__2009____changing_the_order_of__to__and__from__parameters_on___assign_to___function___added__mca__function_" title="Version 0.3.0, October 22, 2009 Changing
+ the order of to and from parameters on assign_to
+ function + Added mca function">Version 0.3.0, October 22, 2009 Changing
+ the order of <code class="computeroutput">to</code> and <code class="computeroutput">from</code> parameters on <code class="computeroutput">assign_to</code>
+ function + Added <code class="computeroutput">mca</code> function</a>
+</h4></div></div></div>
+
+ Incompatibility:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Changing the order of <code class="computeroutput">to</code>
+ and <code class="computeroutput">from</code> parameters
+ on <code class="computeroutput">assign_to</code>.
+ </li>
+<li>
+ Now <code class="computeroutput">boost/conversion/convert_to.hpp</code> and <code class="computeroutput">boost/conversion/assign_to.hpp</code>
+ files are separated.
+ </li>
+</ul></div>
+
+ New Features:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Added <code class="computeroutput"><boost/conversion.hpp></code> global file.
+ </li>
+<li>
+ Added <code class="computeroutput">mca()</code>
+ function.
+ </li>
+<li>
+ Added <code class="computeroutput">convert_to_via</code>
+ function.
+ </li>
+</ul></div>
+
+ Test:
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ Added test for the new features
+ </li></ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.history.__version_0_2_0__mai_16__2009____adding_array___fusion__tuples___adaptation_to_boost_1_39_"></a><a href="index.html#boost.conversion.appendices.history.__version_0_2_0__mai_16__2009____adding_array___fusion__tuples___adaptation_to_boost_1_39_" title="Version 0.2.0, Mai 16, 2009 Adding array
+ + fusion::tuples + Adaptation to Boost 1.39">Version 0.2.0, Mai 16, 2009 Adding array
+ + fusion::tuples + Adaptation to Boost 1.39</a>
+</h4></div></div></div>
+
+ New Features:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ conversion between <code class="computeroutput">boost::array</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between Boost.Fusion sequences of explicitly convertible
+ types.
+ </li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.history.__version_0_1_0__april_16__2009____announcement_of_conversions_"></a><a href="index.html#boost.conversion.appendices.history.__version_0_1_0__april_16__2009____announcement_of_conversions_" title="Version 0.1.0, April 16, 2009 Announcement
+ of Conversions">Version 0.1.0, April 16, 2009 Announcement
+ of Conversions</a>
+</h4></div></div></div>
+
+ Features:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ a generic <code class="computeroutput">convert_to</code>
+ function which can be specialized by the user to make explicit conversion
+ between unrelated types.
+ </li>
+<li>
+ a generic <code class="computeroutput">assign_to</code>
+ function which can be specialized by the user to make explicit assignation
+ between unrelated types.
+ </li>
+<li>
+ conversion between C-arrays of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">std::complex</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">std::pair</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">std::string</code>
+ and Streamable types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::optional</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::rational</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::interval</code>
+ of explicitly convertible types.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::chrono::time_point</code>
+ and <code class="computeroutput">boost::ptime</code>.
+ </li>
+<li>
+ conversion between <code class="computeroutput">boost::chrono::duration</code>
+ and <code class="computeroutput">boost::time_duration</code>.
+ </li>
+</ul></div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.appendices.rationale"></a> Appendix B: Rationale
+</h3></div></div></div>
+<a name="boost.conversion.appendices.rationale.trick_to_avoid_recursion_on_the_convert_to_calls"></a><h4>
+<a name="id5022677"></a>
+ <a 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>
+ </h4>
+
+ The implementation of this utility contains various workarounds:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ <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.
+ </li>
+<li>
+ <code class="computeroutput">conversion_impl</code> has a
+ using-directive <code class="computeroutput">using namespace
+ boost::conversion;</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>
+ <code class="computeroutput">boost::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 a reference derived tag class <code class="computeroutput">dummy::type_tag<To> const&</code> for all others.
+ </li>
+</ul></div>
+<pre class="programlisting">namespace dummy {
+ template <typename T> struct base_tag {};
+ template <typename T> struct type_tag : public base_tag<T> {};
+}
+</pre>
+
+ 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>()) {
+</pre>
+
+ would be never chosen when called in this context
+ 
+<pre class="programlisting">using namespace boost::conversion;
+return convert_to(from, dummy::type_tag<Target>());
+</pre>
+
+ as the library defines
+ 
+<pre class="programlisting">namespace conversion {
+ template < typename To, typename From >
+ To boost::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><h4>
+<a name="id5023585"></a>
+ <a 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>
+ </h4>
+
+ The tag type is there to avoid infinite recursion, but it is quite cumbersome
+ at the user side.
+ 
+<pre class="programlisting">a = convert_to(b, dummy::type_tag<A>());
+</pre>
+
+ 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>()) {
+</pre>
+
+ This default value needs however to give the Target template parameter
+ 
+<pre class="programlisting">a= convert_to<A>(b);
+</pre>
+<a name="boost.conversion.appendices.rationale.mathematical_background"></a><h4>
+<a name="id5023933"></a>
+ <a href="index.html#boost.conversion.appendices.rationale.mathematical_background">Mathematical
+ background</a>
+ </h4>
+
+ Let be
+ 
+<pre class="programlisting">A a,a2;
+B b;
+C c;
+</pre>
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Reflexive: A is convertible to A if it is CopyConstructible or a specialization
+ of convert_to is provided.
+ </li>
+<li>
+ Anti-Symetric : A convertible to B don't implies B convertible to A
+ </li>
+<li>
+ Loss of precision: Conversions can loss precision but not at infinitum
+ </li>
+</ul></div>
+
+ Two convertible types don't loss precision if
+ 
+<pre class="programlisting">b = convert_to<B>(a);
+a2 = convert_to<A>(b);
+assert(a==a2);
+</pre>
+
+ If they can loss precision they satisfy
+ 
+<pre class="programlisting">b = convert_to<B>(a)
+a2 = convert_to<A>(b)
+assert(a==a2 || ct(a2)==b
+</pre>
+<div class="itemizedlist"><ul type="disc"><li>
+ Transitive: A convertible to B && B convertible to C implies
+ A convertible to C
+ </li></ul></div>
+
+ The implementation could use a intermediary B b to make the conversion or
+ make the conversion directly.
+ 
+<pre class="programlisting">template <>
+convert_to<C,A>(const C& c) {
+ return convert_to<A>(convert_to<B>(c));
+}
+</pre>
+
+ The library provides a convert_to_via function which helps to implement that.
+ 
+<a name="boost.conversion.appendices.rationale.ambiguity_of_multiple_overloadins"></a><h4>
+<a name="id5024467"></a>
+ <a href="index.html#boost.conversion.appendices.rationale.ambiguity_of_multiple_overloadins">Ambiguity
+ of multiple overloadins</a>
+ </h4>
+<div class="warning"><table border="0" summary="Warning">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../doc/src/images/warning.png"></td>
+<th align="left">Warning</th>
+</tr>
+<tr><td align="left" valign="top">
+ Ambiguity of multiple overloadins
+ </td></tr>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.appendices.implementation"></a><a href="index.html#boost.conversion.appendices.implementation" title=" Appendix
+ C: Implementation Notes"> Appendix
+ C: Implementation Notes</a>
+</h3></div></div></div>
+<a name="boost.conversion.appendices.implementation.why__code__phrase_role__identifier__convert_to__phrase___code__between_tuples_is_not_implemented_using__code__phrase_role__identifier__boost__phrase__phrase_role__special______phrase__phrase_role__identifier__fusion__phrase__phrase_role__special______phrase__phrase_role__identifier__transform__phrase___code__"></a><h4>
+<a name="id5024517"></a>
+ <a 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>
+ </h4>
+
+ <code class="computeroutput">convert_to<T></code> is
+ a kind of transformation, so the natural implementation of <code class="computeroutput">convert_to</code> for homogeneous containers could
+ be to use the transform function.
+ 
+
+ This can not be applied to heterogeneous containers as tuples because the
+ function change with the type.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.appendices.acknowledgements"></a><a href="index.html#boost.conversion.appendices.acknowledgements" title=" Appendix
+ D: Acknowledgements"> Appendix
+ D: Acknowledgements</a>
+</h3></div></div></div>
+
+ Thanks to Vladimir Batov proposing Boost.StringConversion which was the source
+ of inspiration of this generic library. Thanks to Edward Diener to showing
+ me indirectly that multiple assignments should be taken in account. Thanks
+ to Jeffrey Hellrung to showing me that Boost.Conversion should use also ADL.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.appendices.appendix_e__tests"></a><a href="index.html#boost.conversion.appendices.appendix_e__tests" title="Appendix
+ E: Tests">Appendix
+ E: Tests</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt>Builtins</dt>
+<dt><a href="index.html#boost.conversion.appendices.appendix_e__tests.intrinsic_conversions">Intrinsic
+ Conversions</a></dt>
+<dt><a href="index.html#boost.conversion.appendices.appendix_e__tests.extrinsic_conversions">Extrinsic
+ Conversions</a></dt>
+<dt>Std</dt>
+<dt>Boost</dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.appendix_e__tests.builtins"></a>Builtins
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ kind
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Result
+ 
+ </th>
+<th>
+ 
+ Ticket
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ convert_to_with_builtin_types
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ works for builting types
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ assign_to_with_builtin_types
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">assign_to</code>
+ works for builtin types
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ assign_to_transitive
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ Use of <code class="computeroutput">assign_to</code>
+ transitively
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ mca_assign_to_with_builtin_types
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">mca</code> <code class="computeroutput">works</code> for builtin types
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ mca_assign_to_transitive
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ use of <code class="computeroutput">mca</code> to
+ multiple assignments
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.appendix_e__tests.intrinsic_conversions"></a><a href="index.html#boost.conversion.appendices.appendix_e__tests.intrinsic_conversions" title="Intrinsic
+ Conversions">Intrinsic
+ Conversions</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ kind
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Result
+ 
+ </th>
+<th>
+ 
+ Ticket
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ convert_to_with_implicit_constructor
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ works when there is an implicit constructor
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_with_explicit_constructor
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ works when there is an explicit constructor
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_with_conversion_operator
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">assign_to</code>
+ works when there is an conversion operator
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ assign_to_with_assignment_operator
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">assign_to</code>
+ works when there is an assignment operator
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ assign_to_with_assignment_operator_and_implicit_constructor
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">assign_to</code>
+ works when there is an assignment operator and implicit constructor
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ assign_to_with_assignment_operator_and_conversion_operator
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ works when there is an assignment operator and a conversion operator
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ mca_with_assignment_operator
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">mca</code> works
+ when there is an assignment operator
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ mca_with_assignment_operator_and_implicit_constructor
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">mca</code> works
+ when there is an assignment operator and implicit constructor
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ mca_with_assignment_operator_and_conversion_operator
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">mca</code> works
+ when there is an assignment operator and a conversion operator
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.appendix_e__tests.extrinsic_conversions"></a><a href="index.html#boost.conversion.appendices.appendix_e__tests.extrinsic_conversions" title="Extrinsic
+ Conversions">Extrinsic
+ Conversions</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ kind
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Result
+ 
+ </th>
+<th>
+ 
+ Ticket
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ explicit_convert_to
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ works when <code class="computeroutput">convert_to</code>
+ is overloaded
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ explicit_assign_to
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">assign_to</code>
+ works when <code class="computeroutput">assign_to</code>
+ is overloaded
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ explicit_mca
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">mca</code> works
+ when <code class="computeroutput">assign_to</code>
+ is overloaded
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.appendix_e__tests.std"></a>Std
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ kind
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Result
+ 
+ </th>
+<th>
+ 
+ Ticket
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ convert_to_pair
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">std::pair</code> works when the parameters
+ are convertible
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_complex
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">std::complex</code> works when the parameters
+ are convertible
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_vector
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">std::vector</code> works when the parameters
+ are convertible
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_string
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">std::string</code> works when the parameter
+ defines the <code class="computeroutput">operator<<</code>
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_from_string
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ from <code class="computeroutput">std::string</code> works when the parameter
+ defines the <code class="computeroutput">operator>></code>
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.appendices.appendix_e__tests.boost"></a>Boost
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ kind
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Result
+ 
+ </th>
+<th>
+ 
+ Ticket
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ convert_to_rational
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::rational</code> works when the parameters
+ are convertible
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_interval
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::interval</code> works when the parameters
+ are convertible
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_optional
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::optional</code> works when the parameters
+ are convertible
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_time_point
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::chrono::system_clock::time_point</code> from boost::posix_time::ptime
+ works
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_ptime
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::posix_time::ptime</code> from boost::chrono::system_clock::time_point
+ works
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_duration
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::chrono::duration</code> from <code class="computeroutput">boost::posix_time::time_duration</code> works
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_time_duration
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::posix_time::time_duration</code> from <code class="computeroutput">boost::chrono::duration</code> works
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_array
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::array</code> works when the parameters
+ are convertible
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ convert_to_tuple
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::tuple</code> works when the parameters
+ are convertible
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.appendices.appendix_f__tickets"></a><a href="index.html#boost.conversion.appendices.appendix_f__tickets" title="Appendix
+ F: Tickets">Appendix
+ F: Tickets</a>
+</h3></div></div></div></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.appendices.todo"></a><a href="index.html#boost.conversion.appendices.todo" title=" Appendix F: Future
+ plans"> Appendix F: Future
+ plans</a>
+</h3></div></div></div>
+<a name="boost.conversion.appendices.todo.tasks_to_do_before_review"></a><h4>
+<a name="id5027145"></a>
+ <a href="index.html#boost.conversion.appendices.todo.tasks_to_do_before_review">Tasks
+ to do before review</a>
+ </h4>
+<a name="boost.conversion.appendices.todo.for_later_releases"></a><h4>
+<a name="id5027168"></a>
+ <a href="index.html#boost.conversion.appendices.todo.for_later_releases">For later
+ releases</a>
+ </h4>
+<div class="itemizedlist"><ul type="disc">
+<li>
+ conversion between types for which lexical_cast works.
+ </li>
+<li>
+ conversion between types for which numeric_cast works.
+ </li>
+</ul></div>
+<a name="boost.conversion.appendices.todo.make_a_proposal_to_the_c___standard"></a><h4>
+<a name="id5027209"></a>
+ <a href="index.html#boost.conversion.appendices.todo.make_a_proposal_to_the_c___standard">Make
+ a proposal to the C++ standard</a>
+ </h4>
+
+ C++1x has added explicit conversion operators, but they must always be defined
+ in the source class. The same applies to the assignment operator, it must
+ be defined on the Target class.
+ 
+
+ What it will interesting is to be able to add constructors and assignments
+ operators to the class std::pair, so we can say that two pairs are convertible
+ if the parameters are explicitly convertible using a convert_to function
+ 
+<pre class="programlisting">template<class U , class V>
+//requires HasConvertTo<T1, const U&> && HasConvertTo<T2, const V&>
+std::pair& operator=(const std::pair<U , V>& p) {
+ return std::make_pair(convert_to<T1>(p.first), convert_to<T2>(p.second));
+}
+</pre>
+
+ But this is not possible. We can not add operations to a class.
+ 
+
+ Another possibility could be to make an evolution to the standard, so the
+ convertible concept takes car of extrinsic conversions. We could be able
+ to implicitly or explicitly add extrinsic conversion operators between unrelated
+ types. Non-member assignment operators could also be specialized.
+ 
+<pre class="programlisting">template < typename To, typename From >
+operator To(const From& val);
+
+template < typename To, typename From >
+To& operator=(To& to, const From& from);
+</pre>
+
+ For example we could define the explicit conversion from as chrono::time_point<Clock,
+ Duration> to posix_time::ptime follows
+ 
+<pre class="programlisting">template < class Clock, class Duration>
+explicit operator boost::posix_time::ptime(const boost::chrono::time_point<Clock, Duration>& from) {
+ typedef boost::chrono::time_point<Clock, Duration> time_point_t;
+ typedef boost::chrono::nanoseconds duration_t;
+ typedef boost::duration_t::rep rep_t;
+ rep_t d = boost::chrono::duration_cast<duration_t>(from.time_since_epoch()).count();
+ rep_t sec = d/1000000000;
+ rep_t nsec = d%1000000000;
+ return boost::posix_time::from_time_t(0)+
+ boost::posix_time::seconds(static_cast<long>(sec))+
+ boost::posix_time::nanoseconds(nsec);
+}
+</pre>
+
+ With this explicit conversion and the equivalen for duration, the actual
+ definition of std::pair will allows to
+ 
+<pre class="programlisting">std::pair<chrono::time_point<Clock, Duration>, boost::chrono::duration<Rep, Period> > tp_dur_pair;
+std::pair<boost::posix_time::ptime, boost::posix_time::time_duration> ppt;
+ppt = tp_dur_pair;
+</pre>
+</div>
+</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: May 28, 2010 at 09:08:56 GMT</td>
+<td align="left">Last revised: September 23, 2010 at 19:30:01 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="boost/conversion/overview.html"><img src="../../../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"></div>
</body>
</html>

Modified: sandbox/conversion/libs/conversion/doc/html/standalone_HTML.manifest
==============================================================================
--- sandbox/conversion/libs/conversion/doc/html/standalone_HTML.manifest (original)
+++ sandbox/conversion/libs/conversion/doc/html/standalone_HTML.manifest 2010-09-23 15:35:35 EDT (Thu, 23 Sep 2010)
@@ -1,24 +1 @@
index.html
-boost/conversion/overview.html
-boost/conversion/overview/motivation.html
-boost/conversion/users_guide.html
-boost/conversion/users_guide/getting_started.html
-boost/conversion/users_guide/tutorial.html
-boost/conversion/users_guide/ext_references.html
-boost/conversion/reference.html
-boost/conversion/reference/conversion_hpp.html
-boost/conversion/reference/core.html
-boost/conversion/reference/c___standard_classes_specializations.html
-boost/conversion/reference/boost_classes_specializations.html
-boost/conversion/examples.html
-boost/conversion/examples/chrono__time_point_and_posix_time__ptime.html
-boost/conversion/examples/boost__optional.html
-boost/conversion/examples/std__pair.html
-boost/conversion/appendices.html
-boost/conversion/appendices/history.html
-boost/conversion/appendices/rationale.html
-boost/conversion/appendices/implementation.html
-boost/conversion/appendices/acknowledgements.html
-boost/conversion/appendices/appendix_e__tests.html
-boost/conversion/appendices/appendix_f__tickets.html
-boost/conversion/appendices/todo.html

Next message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r65558 - sandbox/conversion/libs/conversion/doc/html/boost"
Previous message: troyer_at_[hidden]: "[Boost-commit] svn:boost r65556 - trunk/boost/mpi"

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