Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r68412 - in sandbox/conversion/libs/conversion_ext: doc doc/html test
From: vicente.botet_at_[hidden]
Date: 2011-01-24 07:14:13

Next message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r68413 - trunk/tools/release"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r68411 - in sandbox/conversion/boost/conversion: . boost std"

Author: viboes
Date: 2011-01-24 07:14:12 EST (Mon, 24 Jan 2011)
New Revision: 68412
URL: http://svn.boost.org/trac/boost/changeset/68412

Log:
Boost.Conversion: Cleanup + updated doc

Binary files modified:
   sandbox/conversion/libs/conversion_ext/doc/conversion.pdf
Text files modified:
   sandbox/conversion/libs/conversion_ext/doc/Jamfile.v2 | 24
   sandbox/conversion/libs/conversion_ext/doc/conversion.qbk | 125 +
   sandbox/conversion/libs/conversion_ext/doc/html/index.html | 2240 +++++++++++++++++++++------------------
   sandbox/conversion/libs/conversion_ext/test/helper.hpp | 4
   sandbox/conversion/libs/conversion_ext/test/vector.cpp | 17
   5 files changed, 1300 insertions(+), 1110 deletions(-)

Modified: sandbox/conversion/libs/conversion_ext/doc/Jamfile.v2
==============================================================================
--- sandbox/conversion/libs/conversion_ext/doc/Jamfile.v2 (original)
+++ sandbox/conversion/libs/conversion_ext/doc/Jamfile.v2 2011-01-24 07:14:12 EST (Mon, 24 Jan 2011)
@@ -7,21 +7,8 @@
#
# See http://www.boost.org for updates, documentation, and revision history.

-#import doxygen ;
import quickbook ;

-#doxygen autodoc
-# :
-# [ glob ../../../boost/interprocess/*.hpp ]
-# [ glob ../../../boost/interprocess/allocators/*.hpp ]
-# :
-# <doxygen:param>EXTRACT_ALL=NO
-# <doxygen:param>HIDE_UNDOC_MEMBERS=YES
-# <doxygen:param>EXTRACT_PRIVATE=NO
-# <doxygen:param>EXPAND_ONLY_PREDEF=YES
-# <doxygen:param>PREDEFINED=BOOST_INTERPROCESS_DOXYGEN_INVOKED
-# <xsl:param>"boost.doxygen.reftitle=Boost.Interprocess Reference"
-# ;

xml conversion : conversion.qbk ;

@@ -47,15 +34,15 @@
 # Path for libraries index:
 <xsl:param>boost.libraries=../../../../libs/libraries.htm
 # Use the main Boost stylesheet:
- <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
+ <xsl:param>html.stylesheet=../../../../doc/src/boostbook.css

 # PDF Options:
 # TOC Generation: this is needed for FOP-0.9 and later:
- #<xsl:param>fop1.extensions=1
+ <format>pdf:<xsl:param>fop1.extensions=0
 # Or enable this if you're using XEP:
- <xsl:param>xep.extensions=1
+ <format>pdf:<xsl:param>xep.extensions=1
 # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
- <xsl:param>fop.extensions=0
+ <format>pdf:<xsl:param>fop.extensions=0
 # No indent on body text:
 <xsl:param>body.start.indent=0pt
 # Margin size:
@@ -69,4 +56,7 @@
 # better use SVG's instead:
 <format>pdf:<xsl:param>admon.graphics.extension=".svg"
 <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
+ <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/conversion_ext/doc/html
 ;
+
+install pdf-install : standalone : <location>. <install-type>PDF ;

Modified: sandbox/conversion/libs/conversion_ext/doc/conversion.pdf
==============================================================================
Binary files. No diff available.

Modified: sandbox/conversion/libs/conversion_ext/doc/conversion.qbk
==============================================================================
--- sandbox/conversion/libs/conversion_ext/doc/conversion.qbk (original)
+++ sandbox/conversion/libs/conversion_ext/doc/conversion.qbk 2011-01-24 07:14:12 EST (Mon, 24 Jan 2011)
@@ -7,8 +7,8 @@
 /]

[article Toward Boost.Conversion
- [quickbook 1.4]
- [version 0.5.0]
+ [quickbook 1.5]
+ [version 0.6.0]
 [authors [Botet Escriba, Vicente J.]]
 [copyright 2009-2010 Vicente J. Botet Escriba]
 [id boost.conversion]
@@ -47,36 +47,6 @@
[section Overview]
[/========================]

-[/==================]
-[heading Description]
-[/==================]
-
-Generic explicit conversion between unrelated types.
-
-The template function __convert_to__ allows to convert a source type to a target type, using argument dependent lookup to select a specialized `convert_to` function if available. If no specialized `convert_to` function is available, `boost::conversion::convert_to` is used.
-
-The generic __convert_to__ 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 `convert_to` 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 __convert_to__.
-
-[*Boost.Conversion] provides:
-
-* a generic __convert_to__ function which can be specialized by the user to make explicit conversion between unrelated types.
-* a generic __assign_to__ function which can be specialized by the user to make explicit assignation between unrelated types.
-* a generic `mca` function returning a wrapper which replace assignments by a call to __assign_to__ and conversion operators by a call __convert_to__.
-* a generic `convert_to_via` function which convert a type `From` to another `To` using a temporary one `Via`.
-* a generic `pack` function used to pack Source and target constructor arguments.
-* conversion between `std::complex` of explicitly convertible types.
-* conversion between `std::pair` of explicitly convertible types.
-* conversion between `boost::optional` of explicitly convertible types.
-* conversion between `boost::rational` of explicitly convertible types.
-* conversion between `boost::interval` of explicitly convertible types.
-* conversion between `boost::chrono::time_point` and `boost::ptime`.
-* conversion between `boost::chrono::duration` and `boost::time_duration`.
-* conversion between `boost::array` of explicitly convertible types.
-* conversion between Boost.Fusion sequences of explicitly convertible types.
-* conversion between `std::vector` of explicitly convertible types.
-
[/====================================]
[heading How to Use This Documentation]
[/====================================]
@@ -254,6 +224,39 @@

[endsect]
+
+[/==================]
+[section Description]
+[/==================]
+
+Generic explicit conversion between unrelated types.
+
+The template function __convert_to__ allows to convert a source type to a target type, using argument dependent lookup to select a specialized `convert_to` function if available. If no specialized `convert_to` function is available, `boost::conversion::convert_to` is used.
+
+The generic __convert_to__ 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 `convert_to` 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 __convert_to__.
+
+[*Boost.Conversion] provides:
+
+* a generic __convert_to__ function which can be specialized by the user to make explicit conversion between unrelated types.
+* a generic __assign_to__ function which can be specialized by the user to make explicit assignation between unrelated types.
+* a generic `mca` function returning a wrapper which replace assignments by a call to __assign_to__ and conversion operators by a call __convert_to__.
+* a generic `convert_to_via` function which convert a type `From` to another `To` using a temporary one `Via`.
+* a generic `pack` function used to pack Source and target constructor arguments.
+* conversion between `std::complex` of explicitly convertible types.
+* conversion between `std::pair` of explicitly convertible types.
+* conversion between `boost::optional` of explicitly convertible types.
+* conversion between `boost::rational` of explicitly convertible types.
+* conversion between `boost::interval` of explicitly convertible types.
+* conversion between `boost::chrono::time_point` and `boost::ptime`.
+* conversion between `boost::chrono::duration` and `boost::time_duration`.
+* conversion between `boost::array` of explicitly convertible types.
+* conversion between Boost.Fusion sequences of explicitly convertible types.
+* conversion between `std::vector` of explicitly convertible types.
+
+[endsect]
+
[endsect]

[/==============================]
@@ -291,7 +294,6 @@

The genric part of [*Boost.Conversion] depends only on Boost.Config. Of course it depends on the specific libraries when specific conversion are used.

-
[/========================]
[heading Exceptions safety]
[/========================]
@@ -308,12 +310,30 @@
[/=======================]
[heading Tested compilers]
[/=======================]
+
Currently, [*Boost.Conversion] has been tested in the following compilers/platforms:

-* GCC 3.4.4 Cygwin
-* GCC 3.4.6 Linux
-[/* GCC 4.3.2 Cygwin]
-* GCC 4.1.2 Linux
+Windows with
+
+* MSVC 10.0
+
+Cygwin 1.5 with
+
+* GCC 3.4.4
+
+Cygwin 1.7 with
+
+* GCC 4.3.4
+
+MinGW with
+
+* GCC 4.4.0
+* GCC 4.5.0
+* GCC 4.5.0 -std=c++0x
+* GCC 4.6.0
+* GCC 4.6.0 -std=c++0x
+
+[note Please let us know how this works on other platforms/compilers.]

[note Please send any questions, comments and bug reports to boost <at> lists <dot> boost <dot> org.]

@@ -417,7 +437,6 @@
 return partial_specialization_workaround::assign_to<Target,Source>::apply(to, from);
 }

-
[endsect]

[section How to convert to types needing some constructors arguments?]
@@ -428,7 +447,6 @@

[endsect]

-
[section:ext_references External Resources]
[variablelist
[
@@ -480,12 +498,23 @@

[section Reference]

+[section Core]
+
[/==========================================================================================]
[section:conversion_hpp Header `<boost/conversion.hpp>`]
[/==========================================================================================]

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.

+ #include <boost/conversion/include.hpp>
+
+[endsect]
+[/==========================================================================================]
+[section:conversion_include_hpp Header `<boost/conversion/include.hpp>`]
+[/==========================================================================================]
+
+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.
+
 #include <boost/conversion/convert_to.hpp>
 #include <boost/conversion/assign_to.hpp>
 #include <boost/conversion/convert_to_via.hpp>
@@ -494,8 +523,6 @@

[endsect]

-[section Core]
-

[/==========================================================================================]
[section:convert_to_hpp Header `<boost/conversion/convert_to.hpp>`]
@@ -639,7 +666,7 @@

[variablelist

-[[Effects:] [Returns a implementation dependent class able to transform conversion by convert_to call and assignments by assign_to calls.]]
+[[Effects:] [Returns a implementation dependent class able to transform conversion by __convert_to__ calls and assignments by __assign_to__ calls.]]

[[Throws:] [Nothing.]]

@@ -900,7 +927,7 @@

 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&);;
+ , boost::dummy::type_tag<chrono::time_point<Clock, Duration> > const&);

 }
 namespace posix_time {
@@ -981,7 +1008,7 @@
 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&);;
+ , 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
@@ -1009,11 +1036,11 @@

 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&);;
+ , 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&);;
+ , boost::dummy::type_tag<tuple<T1,T2,T3> > const&);
 }
 }

@@ -1024,15 +1051,15 @@
[section Examples]
[section chrono::time_point and posix_time::ptime]

-[CHRONO_TIME_POINT_TO_POSIX_TIME_PTIME__HPP]
+[CHRONO_TIME_POINT_TO_POSIX_TIME_PTIME_HPP]

[endsect]
[section boost::optional]
-[OPTIONAL__HPP]
+[OPTIONAL_HPP]

[endsect]
[section std::pair]
-[PAIR__HPP]
+[PAIR_HPP]
[endsect]
[endsect]

Modified: sandbox/conversion/libs/conversion_ext/doc/html/index.html
==============================================================================
--- sandbox/conversion/libs/conversion_ext/doc/html/index.html (original)
+++ sandbox/conversion/libs/conversion_ext/doc/html/index.html 2011-01-24 07:14:12 EST (Mon, 24 Jan 2011)
@@ -1,10 +1,10 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Toward Boost.Conversion 0.5.0</title>
-<link rel="stylesheet" href="../../../../doc/html/boostbook.css" type="text/css">
+<title>Toward Boost.Conversion 0.6.0</title>
+<link rel="stylesheet" href="../../../../doc/src/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 0.5.0">
+<link rel="start" href="index.html" title="Toward Boost.Conversion 0.6.0">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -21,13 +21,13 @@
<div class="titlepage">
<div>
<div><h2 class="title">
-<a name="boost.conversion"></a>Toward Boost.Conversion 0.5.0</h2></div>
+<a name="boost.conversion"></a>Toward Boost.Conversion 0.6.0</h2></div>
<div><div class="authorgroup"><div class="author"><h3 class="author">
Vicente J. Botet Escriba
</h3></div></div></div>
<div>Copyright © 2009 -2010 Vicente J. Botet Escriba</div>
<div><div class="legalnotice">
-<a name="id4987067"></a>
+<a name="id4987096"></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,7 +39,10 @@
Table of Contents
<dl>
<dt>Overview</dt>
-<dd><dl><dt>Motivation</dt></dl></dd>
+<dd><dl>
+<dt>Motivation</dt>
+<dt>Description</dt>
+</dl></dd>
<dt> Users' Guide</dt>
<dd><dl>
<dt><a href="index.html#boost.conversion.users_guide.getting_started"> Getting
@@ -50,7 +53,6 @@
</dl></dd>
<dt>Reference</dt>
<dd><dl>
-<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>
@@ -94,105 +96,12 @@
<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>
+<div class="toc"><dl>
+<dt>Motivation</dt>
+<dt>Description</dt>
+</dl></div>
<a name="boost.conversion.overview.how_to_use_this_documentation"></a><h3>
-<a name="id4949128"></a>
+<a name="id4987010"></a>
 <a href="index.html#boost.conversion.overview.how_to_use_this_documentation">How
 to Use This Documentation</a>
 </h3>
@@ -201,32 +110,35 @@
 
<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>
+ 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>
@@ -241,7 +153,8 @@

 Finally, you can mentally add the following to any code fragments in this document:
 
-<pre class="programlisting">// Include all of the core Conversion files
+<pre class="programlisting">
+// Include all of the core Conversion files
#include <boost/conversion.hpp>

using namespace boost;
@@ -265,12 +178,14 @@
 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 class="programlisting">
+Target ConvertToTarget(Source& v);
</pre>

 In my case I started by defining
 
-<pre class="programlisting">template <typename Rep, typename Period>
+<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);

@@ -281,7 +196,8 @@
 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>
+<pre class="programlisting">
+template <typename T1, typename T2>
struct pair {
 ...
 template<class U, class V>
@@ -302,7 +218,8 @@

 Well we can again define a specific function
 
-<pre class="programlisting">std::pair<Target,Target> ConvertToPairOfTarget(std::pair<Source,Source>& v) {
+<pre class="programlisting">
+std::pair<Target,Target> ConvertToPairOfTarget(std::pair<Source,Source>& v) {
 return std::make_pair(ConvertToTarget(v.fisrt), ConvertToTarget(v.second));
}
</pre>
@@ -311,21 +228,24 @@
 could be specific, the <code class="computeroutput">ConvertToPairOfTarget</code>
 should be generic
 
-<pre class="programlisting">template <typename Target1, typename Target2, typename Source1, typename Source2)
+<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)
+<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)
+<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));
}
@@ -336,12 +256,14 @@
 and <code class="computeroutput">Target</code>. We can do it
 as follows
 
-<pre class="programlisting">Target convert_to(Source& v) {return ConvertToTarget(v);}
+<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>
+<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);
@@ -356,12 +278,14 @@

 So now I can convert
 
-<pre class="programlisting">std::pair<chrono::time_point<Clock, Duration>, boost::chrono::duration<Rep, Period> >
+<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 class="programlisting">
+std::pair<boost::posix_time::ptime, boost::posix_time::time_duration>
</pre>

 using the <code class="computeroutput">ConvertToPair</code> function.
@@ -373,7 +297,8 @@
 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)
+<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));
@@ -386,7 +311,8 @@
 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>
+<pre class="programlisting">
+template < typename Target, typename Source>
Target convert_to(const Source& from)
{
 return Target(from);
@@ -397,29 +323,34 @@
 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 class="programlisting">
+Target(from)
</pre>

 requires
 
-<pre class="programlisting">convert_to<Target>(from)
+<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 class="programlisting">
+to = from
</pre>

 requires
 
-<pre class="programlisting">assign_to(to, from);
+<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 >
+<pre class="programlisting">
+template < typename Target, typename Source >
To& assign_to(Target& to, const Source& from)
{
 to = from;
@@ -431,7 +362,8 @@
 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 class="programlisting">
+to = convert_to<Target>(from);
</pre>

 The rationale is that if there was not a copy constructor from a Source seems
@@ -443,17 +375,20 @@

 When doing multiple assignments we use to do
 
-<pre class="programlisting">a = b = c;
+<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 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 class="programlisting">
+mca(a) = mca(b) = c;
</pre>

 The behavior of mca recall the tie function of Boost.Tuple, but instead of
@@ -471,6 +406,103 @@
 type, as we can do with explicit casts.
 
</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.conversion.overview.description"></a>Description
+</h3></div></div></div>
+
+ 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>
+</div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -520,7 +552,7 @@
 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 name="id4998196"></a>
 <a href="index.html#boost.conversion.users_guide.getting_started.install.getting_boost_conversion">Getting
 Boost.Conversion</a>
 </h5>
@@ -534,7 +566,7 @@
 Sandbox</a>.
 
<a name="boost.conversion.users_guide.getting_started.install.building_boost_conversion"></a><h5>
-<a name="id4998265"></a>
+<a name="id4998247"></a>
 <a href="index.html#boost.conversion.users_guide.getting_started.install.building_boost_conversion">Building
 Boost.Conversion</a>
 </h5>
@@ -544,7 +576,7 @@
 in your compiler include path.
 
<a name="boost.conversion.users_guide.getting_started.install.requirements"></a><h5>
-<a name="id4998297"></a>
+<a name="id4998280"></a>
 <a href="index.html#boost.conversion.users_guide.getting_started.install.requirements">Requirements</a>
 </h5>

@@ -553,7 +585,7 @@
 specific conversion are used.
 
<a name="boost.conversion.users_guide.getting_started.install.exceptions_safety"></a><h5>
-<a name="id4998329"></a>
+<a name="id4998312"></a>
 <a href="index.html#boost.conversion.users_guide.getting_started.install.exceptions_safety">Exceptions
 safety</a>
 </h5>
@@ -562,7 +594,7 @@
 of exception safety as long as the underlying parameters provide it.
 
<a name="boost.conversion.users_guide.getting_started.install.thread_safety"></a><h5>
-<a name="id4998355"></a>
+<a name="id4998338"></a>
 <a href="index.html#boost.conversion.users_guide.getting_started.install.thread_safety">Thread
 safety</a>
 </h5>
@@ -570,7 +602,7 @@
 All functions in the library are thread-unsafe except when noted explicitly.
 
<a name="boost.conversion.users_guide.getting_started.install.tested_compilers"></a><h5>
-<a name="id4998380"></a>
+<a name="id4998363"></a>
 <a href="index.html#boost.conversion.users_guide.getting_started.install.tested_compilers">Tested
 compilers</a>
 </h5>
@@ -578,16 +610,43 @@
 Currently, Boost.Conversion has been tested
 in the following compilers/platforms:
 
+
+ Windows with
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ MSVC 10.0
+ </li></ul></div>
+
+ Cygwin 1.5 with
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ GCC 3.4.4
+ </li></ul></div>
+
+ Cygwin 1.7 with
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ GCC 4.3.4
+ </li></ul></div>
+
+ MinGW with
+ 
<div class="itemizedlist"><ul type="disc">
<li>
- GCC 3.4.4 Cygwin
- </li>
+ GCC 4.4.0
+ </li>
+<li>
+ GCC 4.5.0
+ </li>
<li>
- GCC 3.4.6 Linux
- </li>
+ GCC 4.5.0 -std=c++0x
+ </li>
<li>
- GCC 4.1.2 Linux
- </li>
+ GCC 4.6.0
+ </li>
+<li>
+ GCC 4.6.0 -std=c++0x
+ </li>
</ul></div>
<div class="note"><table border="0" summary="Note">
<tr>
@@ -595,6 +654,15 @@
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top">
+ Please let us know how this works on other platforms/compilers.
+ </td></tr>
+</table></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>
@@ -634,7 +702,8 @@
 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>
+<pre class="programlisting">
+#include <boost/conversion/convert_to.hpp>

// ...

@@ -651,7 +720,8 @@
 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>
+<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);
@@ -682,7 +752,8 @@
 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 {
+<pre class="programlisting">
+namespace my_own_namespace {
 B convert_to(const A& from, boost::dummy::type_tag<B> const&);
}
</pre>
@@ -698,7 +769,8 @@
 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 >
+<pre class="programlisting">
+template < typename Target, typename Source >
Target convert_to(const Source& val, boost::dummy::type_tag<Target> const&)
</pre>

@@ -707,7 +779,8 @@
 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 {
+<pre class="programlisting">
+namespace boost { namespace conversion {
 namespace partial_specialization_workaround {
 template < typename Target, typename Source >
 struct convert_to {
@@ -725,7 +798,8 @@
 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 {
+<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) {
@@ -740,7 +814,8 @@
 The same applies to the generic <code class="computeroutput">assign_to</code>
 function.
 
-<pre class="programlisting">namespace partial_specialization_workaround {
+<pre class="programlisting">
+namespace partial_specialization_workaround {
 template < typename Target, typename Source >
 struct assign_to {
 inline static To& apply(Target& to, const Source& from)
@@ -784,38 +859,38 @@
<dl>
<dt>Boost.Convert</dt>
<dd>
- Vladimir Batov. Not yet scheduled
- </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>
+ 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>
+ 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>
+ 2)</a></dt>
<dd>
- Lois Goldthwaite, Michael Wong, Jens Mauer, Alisdair Meredith.
- </dd>
+ Lois Goldthwaite, Michael Wong, Jens Mauer, Alisdair Meredith.
+ </dd>
<dt>N2200 - Operator Overloading</dt>
<dd>
- Gary Powell, Doug Gregor, Jaakko Jarvi.
- </dd>
+ Gary Powell, Doug Gregor, Jaakko Jarvi.
+ </dd>
<dt>N1671 - Overloading operator.() & operator.*()</dt>
<dd>
- Gary Powell, Doug Gregor, Jaakko Jarvi.
- </dd>
+ Gary Powell, Doug Gregor, Jaakko Jarvi.
+ </dd>
<dt>N1676 - Non-member overloaded copy assignment operator</dt>
<dd>
- Bronek Kozicki.
- </dd>
+ Bronek Kozicki.
+ </dd>
<dt>N1694 - A Proposal to Extend the Function Call Operator</dt>
<dd>
- Bronek Kozicki.
- </dd>
+ Bronek Kozicki.
+ </dd>
</dl>
</div>
</div>
@@ -825,9 +900,12 @@
<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.conversion_hpp"> Header
+ <code class="computeroutput"><boost/conversion.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.core.conversion_include_hpp">
+ Header <code class="computeroutput"><boost/conversion/include.hpp></code></a></dt>
<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
@@ -870,25 +948,13 @@
</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.conversion_hpp"> Header
+ <code class="computeroutput"><boost/conversion.hpp></code></a></dt>
+<dt><a href="index.html#boost.conversion.reference.core.conversion_include_hpp">
+ Header <code class="computeroutput"><boost/conversion/include.hpp></code></a></dt>
<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
@@ -912,13 +978,48 @@
</dl></div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.conversion_hpp"></a><a href="index.html#boost.conversion.reference.core.conversion_hpp" title=" Header
+ <boost/conversion.hpp>"> Header
+ <code class="computeroutput"><boost/conversion.hpp></code></a>
+</h4></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/include.hpp>
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.conversion.reference.core.conversion_include_hpp"></a><a href="index.html#boost.conversion.reference.core.conversion_include_hpp" title="
+ Header <boost/conversion/include.hpp>">
+ Header <code class="computeroutput"><boost/conversion/include.hpp></code></a>
+</h4></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><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 {
+<pre class="programlisting">
+namespace boost {
 namespace dummy {
 template <typename T> struct base_tag {};
 template <typename T> struct type_tag : public base_tag<T> {};
@@ -973,7 +1074,8 @@
 convert_to()">Function
 <code class="computeroutput">convert_to()</code></a>
</h5></div></div></div>
-<pre class="programlisting">template < typename To, typename From >
+<pre class="programlisting">
+template < typename To, typename From >
To convert_to(const From& from, dummy::type_tag<To> const&);
</pre>
<div class="variablelist">
@@ -981,16 +1083,16 @@
<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>
+ 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>
+ 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>
@@ -1003,7 +1105,8 @@
</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 {
+<pre class="programlisting">
+namespace boost {
 namespace conversion {
 namespace partial_specialization_workaround {
 template < typename To, typename From >
@@ -1057,7 +1160,8 @@
 assign_to()">Function
 <code class="computeroutput">assign_to()</code></a>
</h5></div></div></div>
-<pre class="programlisting">template < typename To, typename From >
+<pre class="programlisting">
+template < typename To, typename From >
void assign_to(To& to, const From& from);
</pre>
<div class="variablelist">
@@ -1065,14 +1169,14 @@
<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>
+ 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>
+ Whatever the underlying the assignment operator of the <code class="computeroutput">To</code> class throws.
+ </dd>
</dl>
</div>
</div>
@@ -1085,7 +1189,8 @@
</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 {
+<pre class="programlisting">
+namespace boost {

 template < typename To, typename Via, typename From >
 To convert_to_via(const From& val) {
@@ -1104,13 +1209,13 @@
<dl>
<dt>Effects:</dt>
<dd>
- Converts the from parameter to an instance of the To type using
- a intermediary Via type.
- </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>
+ Whatever the underlying conversions functions throw.
+ </dd>
</dl>
</div>
</div>
@@ -1123,7 +1228,8 @@
</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 {
+<pre class="programlisting">
+namespace boost {
 template <typename T> 'implementation_dependent<T>' mca(T& r);
}
</pre>
@@ -1135,20 +1241,23 @@
</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 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>
+ Returns a implementation dependent class able to transform conversion
+ by <code class="computeroutput">convert_to</code> calls
+ and assignments by <code class="computeroutput">assign_to</code>
+ calls.
+ </dd>
<dt>Throws:</dt>
<dd>
- Nothing.
- </dd>
+ Nothing.
+ </dd>
</dl>
</div>
<div class="section" lang="en">
@@ -1164,7 +1273,8 @@
<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>
+<pre class="programlisting">
+template <typename T>
class implementation_dependent {
public:
 implementation_dependent(T& r);
@@ -1176,19 +1286,20 @@
<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 class="programlisting">
+implementation_dependent(T& r);
</pre>
<div class="variablelist">

<dl>
<dt>Effects:</dt>
<dd>
- Stores the reference to type.
- </dd>
+ Stores the reference to type.
+ </dd>
<dt>Throws:</dt>
<dd>
- Nothing
- </dd>
+ Nothing
+ </dd>
</dl>
</div>
</div>
@@ -1198,20 +1309,21 @@
 operator">Conversion
 operator</a>
</h6></div></div></div>
-<pre class="programlisting">template <typename U> operator U();
+<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>
+ 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>
+ Whatever <code class="computeroutput">convert_to</code>
+ throws.
+ </dd>
</dl>
</div>
</div>
@@ -1221,21 +1333,22 @@
 operator">Assignment
 operator</a>
</h6></div></div></div>
-<pre class="programlisting">template <typename U> T& operator =(U const& u);
+<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>
+ 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>
+ Whatever <code class="computeroutput">assign_to</code>
+ throws.
+ </dd>
</dl>
</div>
</div>
@@ -1255,7 +1368,8 @@
 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 {
+<pre class="programlisting">
+namespace boost { namespace conversion {
 namespace result_of
 template <typename T1, typename T2, ...>
 struct pack {
@@ -1281,7 +1395,8 @@
 pack<>()">Function
 <code class="computeroutput">pack<>()</code></a>
</h5></div></div></div>
-<pre class="programlisting">template <typename T1, typename T2>
+<pre class="programlisting">
+template <typename T1, typename T2>
typename result_of_pack<T1 const, T2 const>::type pack(
 T1 const& t1, T2 const& t2);

@@ -1294,12 +1409,12 @@
<dl>
<dt>Effects:</dt>
<dd>
- Returns a packed type from the template parameters.
- </dd>
+ Returns a packed type from the template parameters.
+ </dd>
<dt>Throws:</dt>
<dd>
- Nothing.
- </dd>
+ Nothing.
+ </dd>
</dl>
</div>
</div>
@@ -1331,7 +1446,8 @@
 Include this file when using conversions between complex of convertible
 types.
 
-<pre class="programlisting">namespace boost {
+<pre class="programlisting">
+namespace boost {
 namespace conversion {
 namespace partial_specialization_workaround {
 template < class T, class U>
@@ -1356,7 +1472,8 @@

 Include this file when using conversions between pairs of convertible types.
 
-<pre class="programlisting">namespace boost {
+<pre class="programlisting">
+namespace boost {
 namespace conversion {
 namespace partial_specialization_workaround {
 template < class T1, class T2, class U1, class U2>
@@ -1381,7 +1498,8 @@
 Include this file when using conversions between std::vector of convertible
 types.
 
-<pre class="programlisting">namespace boost {
+<pre class="programlisting">
+namespace boost {
 namespace conversion {
 namespace partial_specialization_workaround {
 template < class T1, class A1, class T2, class A2>
@@ -1415,7 +1533,8 @@

 Include this file when using conversions to std::string.
 
-<pre class="programlisting">namespace boost {
+<pre class="programlisting">
+namespace boost {
 namespace conversion {
 namespace partial_specialization_workaround {
 template<typename T, typename CharT, typename Traits, typename Alloc>
@@ -1471,7 +1590,8 @@
 Include this file when using conversions between rational of convertible
 types.
 
-<pre class="programlisting">namespace boost {
+<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&);
@@ -1492,7 +1612,8 @@
 Include this file when using conversions between chrono and posix_time
 time and duration types.
 
-<pre class="programlisting">namespace boost {
+<pre class="programlisting">
+namespace boost {
namespace chrono {
 template < class Clock, class Duration>
 posix_time::ptime convert_to(const chrono::time_point<Clock, Duration>& from
@@ -1500,7 +1621,7 @@

 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&);;
+ , boost::dummy::type_tag<chrono::time_point<Clock, Duration> > const&);

}
namespace posix_time {
@@ -1545,7 +1666,8 @@
 Include this file when using conversions between intervals of convertible
 types.
 
-<pre class="programlisting">namespace boost {
+<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
@@ -1568,7 +1690,8 @@
 Include this file when using conversions between optional of convertible
 types.
 
-<pre class="programlisting">namespace boost {
+<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&);
@@ -1589,10 +1712,11 @@
 Include this file when using conversions between arrays of convertible
 types.
 
-<pre class="programlisting">namespace boost {
+<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&);;
+ , 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
@@ -1610,7 +1734,8 @@
 Include this file when using conversions between fusion::tuple of convertible
 types.
 
-<pre class="programlisting">namespace boost {
+<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
@@ -1622,11 +1747,11 @@

 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&);;
+ , 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&);;
+ , boost::dummy::type_tag<tuple<T1,T2,T3> > const&);
}
}
</pre>
@@ -1650,10 +1775,13 @@
 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
+<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>
@@ -1699,9 +1827,8 @@
 {
 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);
-
+ long long nsec=time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second());
+ return t+chrono::duration_cast<Duration>(chrono::nanoseconds(nsec));
 }
 };
 template < class Clock, class Duration>
@@ -1734,7 +1861,6 @@
#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&
@@ -1745,15 +1871,16 @@
 }

 }
+
 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&)
+ template < class TP>
+ inline TP convert_to(const ptime& from
+ , boost::dummy::type_tag<TP > 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);
+ TP t=chrono::system_clock::from_time_t(time_since_epoch.total_seconds());
+ long long nsec=time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second());
+ return t+chrono::duration_cast<typename TP::duration>(chrono::nanoseconds(nsec));
 }

 template < class Clock, class Duration>
@@ -1772,6 +1899,8 @@
#endif
</pre>

+ 
+
 
</div>
<div class="section" lang="en">
@@ -1779,10 +1908,13 @@
<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
+<pre class="programlisting">
+#ifndef BOOST_CONVERT_TO_OPTIONAL_HPP
+#define BOOST_CONVERT_TO_OPTIONAL_HPP

#include <boost/optional.hpp>
#include <boost/none.hpp>
@@ -1834,6 +1966,8 @@

</pre>

+ 
+
 
</div>
<div class="section" lang="en">
@@ -1841,10 +1975,13 @@
<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
+<pre class="programlisting">
+#ifndef BOOST_CONVERT_TO_PAIR_HPP
+#define BOOST_CONVERT_TO_PAIR_HPP

#include <utility>
//#include <boost/conversion/convert_to.hpp>
@@ -1877,6 +2014,8 @@

</pre>

+ 
+
 
</div>
</div>
@@ -1938,8 +2077,8 @@
 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>
+ 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
@@ -1951,24 +2090,25 @@
 
<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>
+ 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>
+<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>
+ Added is_asignable_to metafunction.
+ </li></ul></div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
@@ -1985,21 +2125,20 @@
 
<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>
+ 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">
@@ -2015,37 +2154,37 @@
 
<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>
+ 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>
+ 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">mca()</code>
- function.
- </li>
-<li>
- Added <code class="computeroutput">convert_to_via</code>
- function.
- </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>
+ Added test for the new features
+ </li></ul></div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
@@ -2058,13 +2197,12 @@
 
<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>
+ 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">
@@ -2078,50 +2216,50 @@
 
<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>
+ 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>
@@ -2130,7 +2268,7 @@
<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 name="id5022743"></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>
@@ -2139,28 +2277,33 @@
 
<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>
+<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 {
+<pre class="programlisting">
+namespace dummy {
 template <typename T> struct base_tag {};
 template <typename T> struct type_tag : public base_tag<T> {};
}
@@ -2168,25 +2311,28 @@

 In this way
 
-<pre class="programlisting">template <typename Target, typename Source>
+<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;
+<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 {
+<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 name="id5023646"></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>
@@ -2194,66 +2340,73 @@
 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 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>
+<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 class="programlisting">
+a= convert_to<A>(b);
</pre>
<a name="boost.conversion.appendices.rationale.mathematical_background"></a><h4>
-<a name="id5023933"></a>
+<a name="id5023997"></a>
 <a href="index.html#boost.conversion.appendices.rationale.mathematical_background">Mathematical
 background</a>
 </h4>

 Let be
 
-<pre class="programlisting">A a,a2;
+<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>
+ 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>
+ 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>
+ 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);
+<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)
+<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>
+ 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 <>
+<pre class="programlisting">
+template <>
convert_to<C,A>(const C& c) {
 return convert_to<A>(convert_to<B>(c));
}
@@ -2262,7 +2415,7 @@
 The library provides a convert_to_via function which helps to implement that.
 
<a name="boost.conversion.appendices.rationale.ambiguity_of_multiple_overloadins"></a><h4>
-<a name="id5024467"></a>
+<a name="id5024522"></a>
 <a href="index.html#boost.conversion.appendices.rationale.ambiguity_of_multiple_overloadins">Ambiguity
 of multiple overloadins</a>
 </h4>
@@ -2283,7 +2436,7 @@
 C: Implementation Notes</a>
</h3></div></div></div>
<a name="boost.conversion.appendices.implementation.why__code__phrase_role__identifier__convert_to__phrase___code__between_tuples_is_not_implemented_using__code__phrase_role__identifier__boost__phrase__phrase_role__special______phrase__phrase_role__identifier__fusion__phrase__phrase_role__special______phrase__phrase_role__identifier__transform__phrase___code__"></a><h4>
-<a name="id5024517"></a>
+<a name="id5024572"></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>
@@ -2340,169 +2493,169 @@
</colgroup>
<thead><tr>
<th>
- 
- Name
- 
+ 
+ Name
+ 
 </th>
<th>
- 
- kind
- 
+ 
+ kind
+ 
 </th>
<th>
- 
- Description
- 
+ 
+ Description
+ 
 </th>
<th>
- 
- Result
- 
+ 
+ Result
+ 
 </th>
<th>
- 
- Ticket
- 
+ 
+ Ticket
+ 
 </th>
</tr></thead>
<tbody>
<tr>
<td>
- 
- convert_to_with_builtin_types
- 
+ 
+ convert_to_with_builtin_types
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- works for builting types
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ works for builting types
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- assign_to_with_builtin_types
- 
+ 
+ assign_to_with_builtin_types
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">assign_to</code>
- works for builtin types
- 
+ 
+ check <code class="computeroutput">assign_to</code>
+ works for builtin types
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- assign_to_transitive
- 
+ 
+ assign_to_transitive
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- Use of <code class="computeroutput">assign_to</code>
- transitively
- 
+ 
+ Use of <code class="computeroutput">assign_to</code>
+ transitively
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- mca_assign_to_with_builtin_types
- 
+ 
+ mca_assign_to_with_builtin_types
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">mca</code> <code class="computeroutput">works</code> for builtin types
- 
+ 
+ check <code class="computeroutput">mca</code> <code class="computeroutput">works</code> for builtin types
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- mca_assign_to_transitive
- 
+ 
+ mca_assign_to_transitive
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- use of <code class="computeroutput">mca</code> to
- multiple assignments
- 
+ 
+ use of <code class="computeroutput">mca</code> to multiple
+ assignments
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
</tbody>
@@ -2524,282 +2677,282 @@
</colgroup>
<thead><tr>
<th>
- 
- Name
- 
+ 
+ Name
+ 
 </th>
<th>
- 
- kind
- 
+ 
+ kind
+ 
 </th>
<th>
- 
- Description
- 
+ 
+ Description
+ 
 </th>
<th>
- 
- Result
- 
+ 
+ Result
+ 
 </th>
<th>
- 
- Ticket
- 
+ 
+ Ticket
+ 
 </th>
</tr></thead>
<tbody>
<tr>
<td>
- 
- convert_to_with_implicit_constructor
- 
+ 
+ convert_to_with_implicit_constructor
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- works when there is an implicit constructor
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ works when there is an implicit constructor
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_with_explicit_constructor
- 
+ 
+ convert_to_with_explicit_constructor
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- works when there is an explicit constructor
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ works when there is an explicit constructor
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_with_conversion_operator
- 
+ 
+ convert_to_with_conversion_operator
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">assign_to</code>
- works when there is an conversion operator
- 
+ 
+ check <code class="computeroutput">assign_to</code>
+ works when there is an conversion operator
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- assign_to_with_assignment_operator
- 
+ 
+ assign_to_with_assignment_operator
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">assign_to</code>
- works when there is an assignment operator
- 
+ 
+ check <code class="computeroutput">assign_to</code>
+ works when there is an assignment operator
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- assign_to_with_assignment_operator_and_implicit_constructor
- 
+ 
+ assign_to_with_assignment_operator_and_implicit_constructor
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">assign_to</code>
- works when there is an assignment operator and implicit constructor
- 
+ 
+ check <code class="computeroutput">assign_to</code>
+ works when there is an assignment operator and implicit constructor
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- assign_to_with_assignment_operator_and_conversion_operator
- 
+ 
+ assign_to_with_assignment_operator_and_conversion_operator
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- works when there is an assignment operator and a conversion operator
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ works when there is an assignment operator and a conversion operator
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- mca_with_assignment_operator
- 
+ 
+ mca_with_assignment_operator
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">mca</code> works
- when there is an assignment operator
- 
+ 
+ check <code class="computeroutput">mca</code> works
+ when there is an assignment operator
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- mca_with_assignment_operator_and_implicit_constructor
- 
+ 
+ mca_with_assignment_operator_and_implicit_constructor
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">mca</code> works
- when there is an assignment operator and implicit constructor
- 
+ 
+ check <code class="computeroutput">mca</code> works
+ when there is an assignment operator and implicit constructor
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- mca_with_assignment_operator_and_conversion_operator
- 
+ 
+ mca_with_assignment_operator_and_conversion_operator
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">mca</code> works
- when there is an assignment operator and a conversion operator
- 
+ 
+ check <code class="computeroutput">mca</code> works
+ when there is an assignment operator and a conversion operator
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
</tbody>
@@ -2821,117 +2974,117 @@
</colgroup>
<thead><tr>
<th>
- 
- Name
- 
+ 
+ Name
+ 
 </th>
<th>
- 
- kind
- 
+ 
+ kind
+ 
 </th>
<th>
- 
- Description
- 
+ 
+ Description
+ 
 </th>
<th>
- 
- Result
- 
+ 
+ Result
+ 
 </th>
<th>
- 
- Ticket
- 
+ 
+ Ticket
+ 
 </th>
</tr></thead>
<tbody>
<tr>
<td>
- 
- explicit_convert_to
- 
+ 
+ explicit_convert_to
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- works when <code class="computeroutput">convert_to</code>
- is overloaded
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ works when <code class="computeroutput">convert_to</code>
+ is overloaded
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- explicit_assign_to
- 
+ 
+ explicit_assign_to
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">assign_to</code>
- works when <code class="computeroutput">assign_to</code>
- is overloaded
- 
+ 
+ check <code class="computeroutput">assign_to</code>
+ works when <code class="computeroutput">assign_to</code>
+ is overloaded
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- explicit_mca
- 
+ 
+ explicit_mca
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">mca</code> works
- when <code class="computeroutput">assign_to</code>
- is overloaded
- 
+ 
+ check <code class="computeroutput">mca</code> works
+ when <code class="computeroutput">assign_to</code>
+ is overloaded
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
</tbody>
@@ -2951,175 +3104,175 @@
</colgroup>
<thead><tr>
<th>
- 
- Name
- 
+ 
+ Name
+ 
 </th>
<th>
- 
- kind
- 
+ 
+ kind
+ 
 </th>
<th>
- 
- Description
- 
+ 
+ Description
+ 
 </th>
<th>
- 
- Result
- 
+ 
+ Result
+ 
 </th>
<th>
- 
- Ticket
- 
+ 
+ Ticket
+ 
 </th>
</tr></thead>
<tbody>
<tr>
<td>
- 
- convert_to_pair
- 
+ 
+ convert_to_pair
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- <code class="computeroutput">std::pair</code> works when the parameters
- are convertible
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">std::pair</code> works when the parameters
+ are convertible
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_complex
- 
+ 
+ convert_to_complex
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- <code class="computeroutput">std::complex</code> works when the parameters
- are convertible
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">std::complex</code> works when the parameters
+ are convertible
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_vector
- 
+ 
+ convert_to_vector
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- <code class="computeroutput">std::vector</code> works when the parameters
- are convertible
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">std::vector</code> works when the parameters
+ are convertible
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_string
- 
+ 
+ convert_to_string
+ 
 </td>
<td>
- 
- run
- 
+ 
+ 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>
- 
+ 
+ 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
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_from_string
- 
+ 
+ convert_from_string
+ 
 </td>
<td>
- 
- run
- 
+ 
+ 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>
- 
+ 
+ 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
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
</tbody>
@@ -3139,289 +3292,290 @@
</colgroup>
<thead><tr>
<th>
- 
- Name
- 
+ 
+ Name
+ 
 </th>
<th>
- 
- kind
- 
+ 
+ kind
+ 
 </th>
<th>
- 
- Description
- 
+ 
+ Description
+ 
 </th>
<th>
- 
- Result
- 
+ 
+ Result
+ 
 </th>
<th>
- 
- Ticket
- 
+ 
+ Ticket
+ 
 </th>
</tr></thead>
<tbody>
<tr>
<td>
- 
- convert_to_rational
- 
+ 
+ convert_to_rational
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- <code class="computeroutput">boost::rational</code> works when the parameters
- are convertible
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::rational</code> works when the parameters
+ are convertible
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_interval
- 
+ 
+ convert_to_interval
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- <code class="computeroutput">boost::interval</code> works when the parameters
- are convertible
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::interval</code> works when the parameters
+ are convertible
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_optional
- 
+ 
+ convert_to_optional
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- <code class="computeroutput">boost::optional</code> works when the parameters
- are convertible
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::optional</code> works when the parameters
+ are convertible
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_time_point
- 
+ 
+ convert_to_time_point
+ 
 </td>
<td>
- 
- run
- 
+ 
+ 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
- 
+ 
+ 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
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_ptime
- 
+ 
+ convert_to_ptime
+ 
 </td>
<td>
- 
- run
- 
+ 
+ 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
- 
+ 
+ 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
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_duration
- 
+ 
+ convert_to_duration
+ 
 </td>
<td>
- 
- run
- 
+ 
+ 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
- 
+ 
+ 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
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_time_duration
- 
+ 
+ convert_to_time_duration
+ 
 </td>
<td>
- 
- run
- 
+ 
+ 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
- 
+ 
+ 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
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_array
- 
+ 
+ convert_to_array
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- <code class="computeroutput">boost::array</code> works when the parameters
- are convertible
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::array</code> works when the parameters
+ are convertible
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
<tr>
<td>
- 
- convert_to_tuple
- 
+ 
+ convert_to_tuple
+ 
 </td>
<td>
- 
- run
- 
+ 
+ run
+ 
 </td>
<td>
- 
- check <code class="computeroutput">convert_to</code>
- <code class="computeroutput">boost::tuple</code> works when the parameters
- are convertible
- 
+ 
+ check <code class="computeroutput">convert_to</code>
+ <code class="computeroutput">boost::tuple</code> works when the parameters
+ are convertible
+ 
 </td>
<td>
- 
- Pass
- 
+ 
+ Pass
+ 
 </td>
<td>
- 
- #
- 
+ 
+ #
+ 
 </td>
</tr>
</tbody>
@@ -3440,25 +3594,25 @@
 plans</a>
</h3></div></div></div>
<a name="boost.conversion.appendices.todo.tasks_to_do_before_review"></a><h4>
-<a name="id5027145"></a>
+<a name="id5027037"></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 name="id5027060"></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>
+ conversion between types for which lexical_cast works.
+ </li>
<li>
- conversion between types for which numeric_cast works.
- </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 name="id5027095"></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>
@@ -3472,7 +3626,8 @@
 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>
+<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));
@@ -3487,7 +3642,8 @@
 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 >
+<pre class="programlisting">
+template < typename To, typename From >
operator To(const From& val);

template < typename To, typename From >
@@ -3497,7 +3653,8 @@
 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>
+<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;
@@ -3514,7 +3671,8 @@
 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;
+<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>
@@ -3522,7 +3680,7 @@
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: September 23, 2010 at 19:30:01 GMT</td>
+<td align="left">Last revised: January 23, 2011 at 22:54:20 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Modified: sandbox/conversion/libs/conversion_ext/test/helper.hpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/helper.hpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/helper.hpp 2011-01-24 07:14:12 EST (Mon, 24 Jan 2011)
@@ -8,8 +8,8 @@
//
//////////////////////////////////////////////////////////////////////////////

-#ifndef BOOST_CONVERSION_TEST_HELPER__HPP
-#define BOOST_CONVERSION_TEST_HELPER__HPP
+#ifndef BOOST_CONVERSION_TEST_HELPER_HPP
+#define BOOST_CONVERSION_TEST_HELPER_HPP

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

Modified: sandbox/conversion/libs/conversion_ext/test/vector.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/vector.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/vector.cpp 2011-01-24 07:14:12 EST (Mon, 24 Jan 2011)
@@ -34,14 +34,24 @@
void explicit_convert_to() {
 std::vector<B1> vb1;
 std::vector<A1> va1(boost::convert_to<std::vector<A1> >(vb1));
-
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;
 B1 b10, b11, b12, b13;
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;
 std::vector<B1> vb2;
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;
+ vb2.reserve(5);
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;
 vb2[0]=b10;
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;
 vb2[1]=b11;
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;
 vb2[2]=b12;
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;
 vb2[3]=b13;
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;
 std::vector<A1> va2(boost::convert_to<std::vector<A1> >(vb2));
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;

 std::allocator<A1> all;
 std::vector<A1,std::allocator<A1> > va3(
@@ -50,13 +60,16 @@
 boost::reference_wrapper<std::vector<B1> const>,
 boost::reference_wrapper<std::allocator<A1> const>
>(boost::cref(vb2), boost::cref(all))));
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;

 std::vector<A1,std::allocator<A1> > va32(
 boost::convert_to<std::vector<A1,std::allocator<A1> > >(
 std::make_pair(boost::cref(vb2), boost::cref(all))));
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;

 boost::conversion::result_of::pack2<std::vector<B1> const, std::allocator<A1> const>::type v =
 boost::conversion::pack(vb2, all);
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;

 //~ std::vector<A1,std::allocator<A1> > va4(
 //~ boost::convert_to<std::vector<A1,std::allocator<A1> > >(v));
@@ -68,6 +81,7 @@
 std::vector<A1,std::allocator<A1> > va6(
 boost::convert_to<std::vector<A1,std::allocator<A1> > >(
 boost::conversion::pack(vb2, std::allocator<A1>())));
+ std::cout << __FILE__ << '['<<__LINE__<<"]" << std::endl;

}
@@ -78,6 +92,7 @@

 B1 b10, b11, b12, b13;
 std::vector<B1> vb2;
+ vb2.reserve(5);
 vb2[0]=b10;
 vb2[1]=b11;
 vb2[2]=b12;

Next message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r68413 - trunk/tools/release"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r68411 - in sandbox/conversion/boost/conversion: . boost std"

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