Subject: [Boost-commit] svn:boost r72937 - in sandbox/conversion/boost/conversion: . boost fp std
From: vicente.botet_at_[hidden]
Date: 2011-07-06 18:18:25
Author: viboes
Date: 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
New Revision: 72937
URL: http://svn.boost.org/trac/boost/changeset/72937
Log:
conversion: update comments
Text files modified:
sandbox/conversion/boost/conversion/assign_to.hpp | 6 ++++
sandbox/conversion/boost/conversion/boost/array.hpp | 39 ++++++++++++++++++++++++------------
sandbox/conversion/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp | 11 +++------
sandbox/conversion/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp | 10 +++-----
sandbox/conversion/boost/conversion/boost/interval.hpp | 32 ++++++++++++++++++++----------
sandbox/conversion/boost/conversion/boost/optional.hpp | 42 ++++++++++++++++++++++++++++-----------
sandbox/conversion/boost/conversion/boost/rational.hpp | 31 ++++++++++++++++++++---------
sandbox/conversion/boost/conversion/boost/tuple.hpp | 37 +++++++++++++++++++++++-----------
sandbox/conversion/boost/conversion/convertible_from.hpp | 20 ++++++++++++------
sandbox/conversion/boost/conversion/convertible_to.hpp | 2
sandbox/conversion/boost/conversion/fp/convert_to.hpp | 8 ++++++
sandbox/conversion/boost/conversion/std/complex.hpp | 5 +++
sandbox/conversion/boost/conversion/std/pair.hpp | 15 +++++++++----
sandbox/conversion/boost/conversion/std/string.hpp | 6 ++++
sandbox/conversion/boost/conversion/std/vector.hpp | 17 ++++++++++++---
15 files changed, 189 insertions(+), 92 deletions(-)
Modified: sandbox/conversion/boost/conversion/assign_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/assign_to.hpp (original)
+++ sandbox/conversion/boost/conversion/assign_to.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -77,7 +77,11 @@
template < typename Target, typename Source>
struct assigner<Target, Source
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
- , requires(CopyAssignable<Target>&&ExtrinsicExplicitConvertible<Source,Target>)
+ , requires(
+ CopyAssignable<Target>
+ && ExtrinsicExplicitConvertible<Source,Target>
+ && ! Assignable<Target,Source>
+ )
#else
, typename enable_if_c<
is_copy_assignable<Target>::value
Modified: sandbox/conversion/boost/conversion/boost/array.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/array.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/array.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -30,6 +30,10 @@
namespace boost {
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_array{};
+#endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
template < class T, std::size_t N>
@@ -47,11 +51,6 @@
#endif
namespace conversion {
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED2)
- /** @brief Added here only to favor generation of specializations with doxygen */
- template < class Target, class Source, class Enable=void>
- struct converter_cp{};
-#endif
/**
* Partial specialization of @c converter for @c boost::array of the same size
@@ -81,10 +80,17 @@
*/
template < typename Target, typename Source, std::size_t N>
struct assigner_cp< array<Target,N>, array<Source,N>
- BOOST_CONVERSION_REQUIRES((
- is_extrinsic_assignable<Target,Source>::value
- && ! is_assignable<Target, Source>::value
- ))
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(
+ ExtrinsicAssignable<Target,Source>
+ && ! Assignable<Target, Source>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
+ is_extrinsic_assignable<Target,Source>::value
+ && ! is_assignable<Target, Source>::value
+ >::type
+#endif
> : true_type
{
//! @Effects assign to each one of the target array elements the conversion of the source array element.
@@ -103,10 +109,17 @@
#if defined(BOOST_CONVERSION_ENABLE_CND) || defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
template < typename Target, typename Source, std::size_t N>
struct assigner_cp< array<Target,N>, array<Source,N>
- BOOST_CONVERSION_REQUIRES((
- is_extrinsic_assignable<Target,Source>::value
- && is_assignable<Target, Source>::value
- ))
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requites()
+ ExtrinsicAssignable<Target,Source>
+ && Assignable<Target, Source>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
+ is_extrinsic_assignable<Target,Source>::value
+ && is_assignable<Target, Source>::value
+ >::type
+#endif
> : true_type
{
//! @Effects assign to each one of the target array elements the conversion of the source array element.
Modified: sandbox/conversion/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -25,7 +25,10 @@
#include <boost/config.hpp>
namespace boost {
-
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_chrono_duration{};
+#endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
template <> struct is_constructible< posix_time::time_duration > : true_type {};
#endif
@@ -55,12 +58,6 @@
namespace conversion {
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED2)
- /** @brief Added here only to favor generation of specializations with doxygen */
- template < class Target, class Source, class Enable=void>
- struct converter_cp{};
-#endif
-
//! @brief @c converter specialization for conversions from @c boost::chrono::duration<> to @c boost::posix_time::time_duration.
//!
template < class Rep, class Period>
Modified: sandbox/conversion/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -27,7 +27,10 @@
#include <boost/config.hpp>
namespace boost {
-
+ #if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_chrono_time_point{};
+ #endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
template <> struct is_constructible< boost::posix_time::ptime > : true_type {};
#endif
@@ -56,11 +59,6 @@
#endif
namespace conversion {
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED2)
- /** @brief Added here only to favor generation of specializations with doxygen */
- template < class Target, class Source, class Enable=void>
- struct converter_cp{};
-#endif
template < class Clock, class Duration>
struct converter_cp<posix_time::ptime, chrono::time_point<Clock, Duration>
Modified: sandbox/conversion/boost/conversion/boost/interval.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/interval.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/interval.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -22,6 +22,10 @@
#include <boost/conversion/assign_to.hpp>
namespace boost {
+ #if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_numeric_interval{};
+ #endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
template < class T, class P>
@@ -40,20 +44,20 @@
namespace conversion {
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED2)
- /** @brief Added here only to favor generation of specializations with doxygen */
- template < class Target, class Source, class Enable=void>
- struct implicit_converter_cp{};
-#endif
-
//! @brief @c converter specialization for source and target been @c boost::numeric::interval.
//!
template < class Target, class PTarget, class Source, class PSource>
struct converter_cp< numeric::interval<Target,PTarget>, numeric::interval<Source,PSource>
- BOOST_CONVERSION_REQUIRES((
- is_extrinsic_convertible<Source,Target>::value
- ))
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(
+ ExtrinsicConvertible<Source,Target>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
+ is_extrinsic_convertible<Source,Target>::value
+ >::type
+#endif
> : true_type
{
//! @Returns the target interval having as extremes the conversion from the source interval extremes.
@@ -64,9 +68,15 @@
};
template < class Target, class PTarget, class Source, class PSource>
struct assigner_cp< numeric::interval<Target,PTarget>, numeric::interval<Source,PSource>
- BOOST_CONVERSION_REQUIRES((
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(
+ ExtrinsicConvertible<Source,Target>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
is_extrinsic_convertible<Source,Target>::value
- ))
+ >::type
+#endif
> : true_type
{
numeric::interval<Target,PTarget>& operator()(numeric::interval<Target,PTarget>& to, const numeric::interval<Source,PSource>& from)
Modified: sandbox/conversion/boost/conversion/boost/optional.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/optional.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/optional.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -29,7 +29,10 @@
namespace boost {
-
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_optional{};
+#endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
template < class T >
struct is_constructible< optional<T> > : true_type {};
@@ -47,20 +50,21 @@
namespace conversion {
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED2)
- /** @brief Added here only to favor generation of specializations with doxygen */
- template < class Target, class Source, class Enable>
- struct converter_cp{};
-#endif
/**
* Partial specialization of @c converter for boost::optional
*/
template < class Target, class Source>
struct converter_cp
< optional<Target>, optional<Source>
- BOOST_CONVERSION_REQUIRES((
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(
+ ExtrinsicConvertible<Source,Target>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
is_extrinsic_convertible<Source,Target>::value
- ))
+ >::type
+#endif
> : true_type
{
//! @Returns If the optional source is initialized @c boost::optional<Target> initialized to the conversion of the optional value.
@@ -77,10 +81,17 @@
//! We can see this specialization as a try_convert_to function.
template < class Target, class Source>
struct converter_cp< optional<Target>, Source
- BOOST_CONVERSION_REQUIRES((
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(
+ ExtrinsicConvertible<Source,Target>
+ && ! Optional<Source>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
is_extrinsic_convertible<Source,Target>::value
&& ! detail::is_optional<Source>::value
- ))
+ >::type
+#endif
> : true_type
{
@@ -105,10 +116,17 @@
//! We can see this specialization as a try_convert_to function.
template < class Target, class Source>
struct explicit_converter_cp< optional<Target>, Source
- BOOST_CONVERSION_REQUIRES((
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(
+ ExtrinsicExplicit_convertible<Source,Target>
+ && ! Optional<Source>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
is_extrinsic_explicit_convertible<Source,Target>::value
&& ! detail::is_optional<Source>::value
- ))
+ >::type
+#endif
> : true_type
{
Modified: sandbox/conversion/boost/conversion/boost/rational.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/rational.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/rational.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -27,7 +27,11 @@
namespace boost {
-
+
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_rational{};
+#endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
template < class T>
struct is_constructible< rational<T> > : true_type {};
@@ -44,19 +48,20 @@
#endif
namespace conversion {
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED2)
- /** @brief Added here only to favor generation of specializations with doxygen */
- template < class Target, class Source, class Enable=void>
- struct converter_cp{};
-#endif
//! @brief @c converter specialization for source and target been @c boost::rational.
//!
template < class Target, class Source>
struct converter_cp< rational<Target>, rational<Source>
- BOOST_CONVERSION_REQUIRES((
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(
+ ExtrinsicConvertible<Source,Target>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
is_extrinsic_convertible<Source,Target>::value
- ))
+ >::type
+#endif
> : true_type
{
//! @Returns the target rational having as numerator and denominator the conversion from the numerator and denominator of the source rational.
@@ -67,9 +72,15 @@
};
template < class Target, class Source>
struct assigner_cp< rational<Target>, rational<Source>
- BOOST_CONVERSION_REQUIRES((
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(
+ ExtrinsicConvertible<Source,Target>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
is_extrinsic_convertible<Source,Target>::value
- ))
+ >::type
+#endif
> : true_type
{
rational<Target>& operator()(rational<Target>& to, const rational<Source>& from)
Modified: sandbox/conversion/boost/conversion/boost/tuple.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/tuple.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/tuple.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -22,7 +22,10 @@
#include <boost/config.hpp>
namespace boost {
-
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_fusion_tuple{};
+#endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
template < class T1, class T2, class T3 >
struct is_constructible< fusion::tuple<T1,T2,T3> > : true_type {};
@@ -33,18 +36,20 @@
#endif
namespace conversion {
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED2)
- /** @brief Added here only to favor generation of specializations with doxygen */
- template < class Target, class Source, class Enable=void>
- struct explicit_converter_cp{};
-#endif
template < class T1, class T2, class S1, class S2>
struct explicit_converter_cp< fusion::tuple<T1,T2>, fusion::tuple<S1,S2>
- BOOST_CONVERSION_REQUIRES((
- is_extrinsic_convertible<S1,T1>::value
- && is_extrinsic_convertible<S2,T2>::value
- ))
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(
+ ExtrinsicConvertible<S1,T1>
+ && ExtrinsicConvertible<S2,T2>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
+ is_extrinsic_convertible<S1,T1>::value
+ && is_extrinsic_convertible<S2,T2>::value
+ >::type
+#endif
> : true_type
{
fusion::tuple<T1,T2> operator()(fusion::tuple<S1,S2> const & from)
@@ -57,11 +62,19 @@
};
template < class T1, class T2, class T3, class S1, class S2, class S3>
struct explicit_converter_cp< fusion::tuple<T1,T2,T3>, fusion::tuple<S1,S2,S3>
- BOOST_CONVERSION_REQUIRES((
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(
+ ExtrinsicConvertible<S1,T1>
+ && ExtrinsicConvertible<S2,T2>
+ && ExtrinsicConvertible<S3,T3>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
is_extrinsic_convertible<S1,T1>::value
&& is_extrinsic_convertible<S2,T2>::value
&& is_extrinsic_convertible<S3,T3>::value
- ))
+ >::type
+#endif
> : true_type
{
fusion::tuple<T1,T2,T3> operator()(fusion::tuple<S1,S2,S3> const & from)
Modified: sandbox/conversion/boost/conversion/convertible_from.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/convertible_from.hpp (original)
+++ sandbox/conversion/boost/conversion/convertible_from.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -18,7 +18,7 @@
#define BOOST_CONVERSION_CONVERTIBLE_FROM_HPP
#include <boost/conversion/config.hpp>
-#if defined(BOOST_CONVERSION_MCF_ENABLED)
+#if defined(BOOST_CONVERSION_MCF_ENABLED) || defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
#include <boost/conversion/implicit_convert_to.hpp>
#include <boost/conversion/assign_to.hpp>
@@ -28,23 +28,28 @@
namespace boost {
namespace conversion {
- //! wrapper providing implicit conversion operation to @c Target.
+ //! wrapper providing implicit conversion operation to any type extrinsicaly implicit convertible from @c Source.
+
+ //! This wrapper is used indirectly through the @mcf function to pass a @c Source parameter to a function waiting a parameter @c Target
+ //! extrinsicaly convertible from it.
+ //!
+ //! Requires @c Source must be CopyConstructible
template <typename Source>
class convertible_from {
Source val_;
public:
- //! @brief constructor from a @c Source
+ //! @brief constructor from a @c Source.
//! @Throws Whatever the @c Source copy constructor could throw.
convertible_from(Source source) : val_(source) {}
- //! @brief Implicit conversion to @c Target.
+ //! @brief Implicit conversion to a @c Target extrinsicaly convertible from @c Source.
//! @Effects Forwards the conversion from the reference using @c conver_to.
//! @Returns the conversion using @c conver_to
//! @Throws Whatever extrinsic conversion from @c Source to @c Target could throw.
//! @Remark On compilers that supports C++0x default arguments for function template parameters,
- //! this constructor doesn't participates on overload resolution if @c Source is not extrinsic convertible to @c Target.
+ //! this conversion operator doesn't participates on overload resolution if @c Source is not extrinsic convertible to @c Target.
template <typename Target
, typename boost::enable_if< boost::is_extrinsic_convertible<Source,Target>, int >::type = 0
>
@@ -54,8 +59,9 @@
}
};
- //! @brief makes a wrapper implicitly convertible from @c Source.
- //! The result provides implicitly conversion to any type which is extrinsic convertible from @c Source.
+ //! @brief makes a wrapper implicitly convertible to types extrinsicly implicit convertibles from @c Source.
+
+ //! The result provides implicitly conversion to any type which is extrinsic implicit convertible from @c Source.
//! @Returns convertible_from<Source>(s).
//! @NoThrow.
template <typename Source>
Modified: sandbox/conversion/boost/conversion/convertible_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/convertible_to.hpp (original)
+++ sandbox/conversion/boost/conversion/convertible_to.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -32,7 +32,7 @@
Target val_;
public:
- //! constructor from a extrinsic implicitly convertible to @c Target.
+ //! Constructor from a extrinsic implicitly convertible to @c Target.
//! @Effects Store the extrinsic conversion from @c source to @ Target.
//! @Throws Whatever extrinsic implicit conversion from @c source to @c Target could throw.
//! @Remark This constructor doesn't participates on overload resolution if @c Source is not extrinsic convertible to @c Target.
Modified: sandbox/conversion/boost/conversion/fp/convert_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/fp/convert_to.hpp (original)
+++ sandbox/conversion/boost/conversion/fp/convert_to.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -45,7 +45,13 @@
//! The nested type @ type is @c true_type.
template <typename T>
- struct enable_functor<T, typename enable_if<phoenix::is_actor<T> >::type> : true_type {};
+ struct enable_functor<T
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires(PhoenixActor<T>)
+#else
+ , typename enable_if<phoenix::is_actor<T> >::type
+#endif
+ > : true_type {};
namespace detail {
struct convert_to_eval
Modified: sandbox/conversion/boost/conversion/std/complex.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/complex.hpp (original)
+++ sandbox/conversion/boost/conversion/std/complex.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -26,7 +26,10 @@
namespace boost {
-
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_complex{};
+#endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
template < class T >
struct is_constructible< std::complex<T> > : true_type {};
Modified: sandbox/conversion/boost/conversion/std/pair.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/pair.hpp (original)
+++ sandbox/conversion/boost/conversion/std/pair.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -24,7 +24,12 @@
#include <utility>
+
namespace boost {
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_pair{};
+#endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
//! Specialization for std::pair<T,U> default constructor
template < class T, class U>
@@ -55,10 +60,10 @@
template < class T1, class T2, class S1, class S2>
struct converter_cp< std::pair<T1,T2>, std::pair<S1,S2>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
- , typename enable_if_c<
- is_extrinsic_convertible<S1,T1>::value
- && is_extrinsic_convertible<S2,T2>::value
- >::type
+ , requires(
+ ExtrinsicConvertible<S1,T1>
+ && ExtrinsicConvertible<S2,T2>
+ )
#elif defined(BOOST_CONVERSION_ENABLE_CND)
, typename enable_if_c<
is_extrinsic_convertible<S1,T1>::value
@@ -73,7 +78,7 @@
}
};
-#if !defined(BOOST_CONVERSION_ENABLE_CND)
+#if !defined(BOOST_CONVERSION_ENABLE_CND) && !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
/**
* Partial specialization of @c assigner_cp for @c std::pair of extrinsic convertibles.
*/
Modified: sandbox/conversion/boost/conversion/std/string.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/string.hpp (original)
+++ sandbox/conversion/boost/conversion/std/string.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -29,6 +29,10 @@
namespace boost {
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_string{};
+#endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
template<typename CharT, typename Traits, typename Alloc>
struct is_constructible< std::basic_string<CharT,Traits,Alloc> > : true_type {};
@@ -83,7 +87,7 @@
}
};
-#if !defined(BOOST_CONVERSION_ENABLE_CND)
+#if !defined(BOOST_CONVERSION_ENABLE_CND) && !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
/**
* Partial specialization of @c assigner_cp for convertibles to std::string.
*/
Modified: sandbox/conversion/boost/conversion/std/vector.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/vector.hpp (original)
+++ sandbox/conversion/boost/conversion/std/vector.hpp 2011-07-06 18:18:23 EDT (Wed, 06 Jul 2011)
@@ -28,7 +28,10 @@
namespace boost {
-
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ //! trick to generate the doc. Don't take care of it
+ struct trick_vector{};
+#endif
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
template < class T, class A>
struct is_constructible< std::vector<T,A> > : true_type {};
@@ -53,9 +56,15 @@
*/
template < class T1, class A1, class T2, class A2>
struct converter_cp< std::vector<T1,A1>, std::vector<T2,A2>
- BOOST_CONVERSION_REQUIRES((
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ , requires
+ ExtrinsicAssignable<T1,T2>
+ )
+#elif defined(BOOST_CONVERSION_ENABLE_CND)
+ , typename enable_if_c<
is_extrinsic_assignable<T1,T2>::value
- ))
+ >::type
+#endif
> : true_type
{
std::vector<T1,A1> operator()(std::vector<T2,A2> const & from)
@@ -70,7 +79,7 @@
}
};
-#if !defined(BOOST_CONVERSION_ENABLE_CND)
+#if !defined(BOOST_CONVERSION_ENABLE_CND) && !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
/**
* Partial specialization of @c assigner_cp for @c std::vector of extrinsic convertibles.
*/