Subject: [Boost-commit] svn:boost r57168 - in sandbox/conversion: boost/conversion boost/conversion/boost boost/conversion/std libs/conversion/test
From: vicente.botet_at_[hidden]
Date: 2009-10-27 04:46:51
Author: viboes
Date: 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
New Revision: 57168
URL: http://svn.boost.org/trac/boost/changeset/57168
Log:
TBoost.conversion: v0.4 Changing the namespaces to get ADL
Added:
sandbox/conversion/boost/conversion/assign_to.hpp (contents, props changed)
Text files modified:
sandbox/conversion/boost/conversion/boost/array.hpp | 20 +-
sandbox/conversion/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp | 21 ++-
sandbox/conversion/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp | 37 +++---
sandbox/conversion/boost/conversion/boost/interval.hpp | 10
sandbox/conversion/boost/conversion/boost/optional.hpp | 14 +-
sandbox/conversion/boost/conversion/boost/rational.hpp | 12 +-
sandbox/conversion/boost/conversion/boost/tuple.hpp | 37 +++--
sandbox/conversion/boost/conversion/ca_wrapper.hpp | 8
sandbox/conversion/boost/conversion/convert_to.hpp | 68 +++++------
sandbox/conversion/boost/conversion/convert_to_via.hpp | 9
sandbox/conversion/boost/conversion/std/complex.hpp | 6
sandbox/conversion/boost/conversion/std/pair.hpp | 6
sandbox/conversion/libs/conversion/test/array.cpp | 4
sandbox/conversion/libs/conversion/test/builtins.cpp | 228 ++++++++++++++++++++--------------------
sandbox/conversion/libs/conversion/test/chrono_posix_time_duration.cpp | 16 +-
sandbox/conversion/libs/conversion/test/chrono_posix_time_time.cpp | 8
sandbox/conversion/libs/conversion/test/complex.cpp | 8
sandbox/conversion/libs/conversion/test/extrinsec.cpp | 8
sandbox/conversion/libs/conversion/test/helper.hpp | 8
sandbox/conversion/libs/conversion/test/interval.cpp | 15 +-
sandbox/conversion/libs/conversion/test/intrinsec.cpp | 18 +-
sandbox/conversion/libs/conversion/test/optional.cpp | 24 ++-
sandbox/conversion/libs/conversion/test/pair.cpp | 12 +-
sandbox/conversion/libs/conversion/test/rational.cpp | 16 +-
sandbox/conversion/libs/conversion/test/tuple.cpp | 12 +-
25 files changed, 319 insertions(+), 306 deletions(-)
Added: sandbox/conversion/boost/conversion/assign_to.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/assign_to.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -0,0 +1,70 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009. 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)
+//
+// See http://www.boost.org/libs/synchro for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONVERSION_ASSIGN_TO__HPP
+#define BOOST_CONVERSION_ASSIGN_TO__HPP
+
+#include <cstddef> //for std::size_t
+#include <boost/conversion/convert_to.hpp>
+#include <boost/swap.hpp>
+
+namespace boost {
+ namespace conversion {
+ namespace partial_specialization_workaround {
+ template < typename To, typename From >
+ struct assign_to {
+ inline static To& apply(To& to, const From& from)
+ {
+ to = from;
+ return to;
+ }
+ };
+ template < typename To, typename From, std::size_t N >
+ struct assign_to<To[N],From[N]> {
+ inline static To*& apply(To(&to)[N], const From(& from)[N])
+ {
+ for (std::size_t i = 0; i < N; ++i)
+ {
+ to[i] = boost::conversion::convert_to(from[i], boost::dummy::type_tag<To>());
+ }
+ return to;
+ }
+ };
+ }
+ }
+
+ namespace conversion_default {
+ template < typename To, typename From >
+ To& assign_to(To& to, const From& from) {
+ return conversion::partial_specialization_workaround::assign_to<To,From>::apply(to, from);
+ }
+ }
+
+ namespace conversion_impl {
+ template <typename Target, typename Source>
+ Target& assign_to_impl(Target& to, const Source& from) {
+ using namespace boost::conversion_default;
+ //use boost::conversion::assign_to if ADL fails
+ return assign_to(to, from);
+ }
+ }
+
+ namespace conversion {
+ template <typename Target, typename Source>
+ Target& assign_to(Target& to, const Source& from) {
+ return conversion_impl::assign_to_impl<Target, Source>(to, from);
+ }
+ }
+}
+
+
+
+#endif
+
Modified: sandbox/conversion/boost/conversion/boost/array.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/array.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/array.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -17,7 +17,7 @@
#include <algorithm>
#include <boost/config.hpp>
-#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
+//#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
namespace boost {
@@ -28,7 +28,7 @@
inline static array<T1,N> apply(array<T2,N> const & from)
{
array<T1,N> to;
- boost::assign_to(to, from);
+ conversion::assign_to(to, from);
return to;
}
};
@@ -37,7 +37,7 @@
inline static array<T1,N>& apply(array<T1,N>& to, array<T2,N> const & from)
{
for (unsigned int i =0; i<N; ++i) {
- to[i]=boost::convert_to<T1>(from[i]);
+ to[i]=conversion::convert_to<T1>(from[i]);
}
return to;
}
@@ -45,20 +45,20 @@
}}
#else
template < typename T1, typename T2, std::size_t N>
- inline static array<T1,N> convert_to(array<T2,N> const & from)
+ inline array<T1,N> convert_to(array<T2,N> const & from
+ , boost::dummy::type_tag<array<T1,N> >)
{
array<T1,N> to;
- boost::assign_to(to, from);
+ conversion::assign_to(to, from);
return to;
}
template < typename T1, typename T2, std::size_t N>
- inline static array<T1,N>& assign_to(array<T1,N>& to, array<T2,N> const & from)
+ inline array<T1,N>& assign_to(array<T1,N>& to, array<T2,N> const & from)
{
- std::transform(from.begin(), from.end(), to.begin(), boost::convert_to<T1,T2>);
- //for (unsigned int i =0; i<N; ++i) {
- // to[i]=boost::convert_to<T1>(from[i]);
- //}
+ for (unsigned int i =0; i<N; ++i) {
+ to[i]=conversion::convert_to<T1>(from[i]);
+ }
return to;
}
#endif
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 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -16,7 +16,8 @@
#include <boost/conversion/convert_to.hpp>
#include <boost/conversion/assign_to.hpp>
#include <boost/config.hpp>
-#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
+
+//#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
namespace boost {
#ifdef BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING
@@ -43,7 +44,7 @@
struct assign_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
inline static posix_time::time_duration& apply(posix_time::time_duration& to, const chrono::duration<Rep, Period>& from)
{
- to = boost::convert_to<posix_time::time_duration>(from);
+ to = conversion::convert_to<posix_time::time_duration>(from);
return to;
}
};
@@ -59,7 +60,7 @@
struct assign_to<chrono::duration<Rep, Period>, posix_time::time_duration> {
inline static chrono::duration<Rep, Period> & apply(chrono::duration<Rep, Period> & to, const posix_time::time_duration& from)
{
- to = boost::convert_to<chrono::duration<Rep, Period> >(from);
+ to = conversion::convert_to<chrono::duration<Rep, Period> >(from);
return to;
}
};
@@ -67,7 +68,8 @@
#else
namespace chrono {
template < class Rep, class Period>
- inline static posix_time::time_duration convert_to(chrono::duration<Rep, Period> const & from)
+ inline posix_time::time_duration convert_to(chrono::duration<Rep, Period> const & from
+ , boost::dummy::type_tag<posix_time::time_duration>)
{
typedef duration<Rep, Period> src_duration_t;
typedef nanoseconds duration_t;
@@ -84,24 +86,25 @@
}
template < class Rep, class Period>
- inline static chrono::duration<Rep, Period> & assign_to(chrono::duration<Rep, Period> & to, const posix_time::time_duration& from)
+ inline chrono::duration<Rep, Period> & assign_to(chrono::duration<Rep, Period> & to, const posix_time::time_duration& from)
{
- to = boost::convert_to<duration<Rep, Period> >(from);
+ to = conversion::convert_to<duration<Rep, Period> >(from);
return to;
}
}
namespace posix_time {
template < class Rep, class Period>
- inline static chrono::duration<Rep, Period> convert_to(time_duration const & from)
+ inline chrono::duration<Rep, Period> convert_to(time_duration const & from
+ , boost::dummy::type_tag<chrono::duration<Rep, Period> >)
{
return chrono::duration_cast<chrono::duration<Rep, Period> >(chrono::nanoseconds(from.total_nanoseconds()));
}
template < class Rep, class Period>
- inline static time_duration& assign_to(time_duration& to, const chrono::duration<Rep, Period>& from)
+ inline time_duration& assign_to(time_duration& to, const chrono::duration<Rep, Period>& from)
{
- to = boost::convert_to<time_duration>(from);
+ to = conversion::convert_to<time_duration>(from);
return to;
}
}
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 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -18,7 +18,8 @@
#include <boost/conversion/convert_to.hpp>
#include <boost/conversion/assign_to.hpp>
#include <boost/config.hpp>
-#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
+
+//#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
namespace boost {
#ifdef BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING
@@ -46,7 +47,7 @@
struct assign_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
inline static posix_time::ptime& apply(posix_time::ptime& to, const chrono::time_point<Clock, Duration>& from)
{
- to = boost::convert_to<posix_time::ptime>(from);
+ to = conversion::convert_to<posix_time::ptime>(from);
return to;
}
};
@@ -66,7 +67,7 @@
struct assign_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
inline static chrono::time_point<Clock, Duration>& apply(chrono::time_point<Clock, Duration>& to, const posix_time::ptime& from)
{
- to = boost::convert_to<chrono::time_point<Clock, Duration> >(from);
+ to = conversion::convert_to<chrono::time_point<Clock, Duration> >(from);
return to;
}
};
@@ -74,9 +75,9 @@
#else
namespace chrono {
template < class Clock, class Duration>
- struct convert_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
- inline static posix_time::ptime apply(const chrono::time_point<Clock, Duration>& from)
- {
+ inline posix_time::ptime convert_to(const chrono::time_point<Clock, Duration>& from
+ , boost::dummy::type_tag<posix_time::ptime>)
+ {
typedef chrono::time_point<Clock, Duration> time_point_t;
typedef chrono::nanoseconds duration_t;
typedef duration_t::rep rep_t;
@@ -90,21 +91,21 @@
#else
boost::posix_time::microseconds((nsec+500)/1000);
#endif
- }
- };
+ }
+
template < class Clock, class Duration>
- struct assign_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
- inline static chrono::time_point<Clock, Duration>& apply(chrono::time_point<Clock, Duration>& to, const posix_time::ptime& from)
- {
- to = boost::convert_to<chrono::time_point<Clock, Duration> >(from);
- return to;
- }
- };
+ inline chrono::time_point<Clock, Duration>& assign_to(chrono::time_point<Clock, Duration>& to, const posix_time::ptime& from)
+ {
+ to = conversion::convert_to<chrono::time_point<Clock, Duration> >(from);
+ return to;
+ }
+
}
namespace posix_time {
template < class Clock, class Duration>
- inline static chrono::time_point<Clock, Duration> convert_to(const ptime& from)
+ inline chrono::time_point<Clock, Duration> convert_to(const ptime& from
+ , boost::dummy::type_tag<chrono::time_point<Clock, Duration> >)
{
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());
@@ -113,9 +114,9 @@
}
template < class Clock, class Duration>
- inline static ptime& assign_to(ptime& to, const chrono::time_point<Clock, Duration>& from)
+ inline ptime& assign_to(ptime& to, const chrono::time_point<Clock, Duration>& from)
{
- to = boost::convert_to<ptime>(from);
+ to = conversion::convert_to<ptime>(from);
return to;
}
Modified: sandbox/conversion/boost/conversion/boost/interval.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/interval.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/interval.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -23,14 +23,14 @@
struct convert_to< numeric::interval<T,PT>, numeric::interval<U,PU> > {
inline static numeric::interval<T,PT> apply(numeric::interval<U,PU> const & from)
{
- return numeric::interval<T,PT>(boost::convert_to<T>(from.lower()), boost::convert_to<U>(from.upper()));
+ return numeric::interval<T,PT>(conversion::convert_to<T>(from.lower()), conversion::convert_to<U>(from.upper()));
}
};
template < class T, class PT, class U, class PU>
struct assign_to< numeric::interval<T,PT>, numeric::interval<U,PU> > {
inline static numeric::interval<T,PT>& apply(numeric::interval<T,PT>& to, const numeric::interval<U,PU>& from)
{
- to.assign(boost::convert_to<T>(from.lower()), boost::convert_to<U>(from.upper()));
+ to.assign(conversion::convert_to<T>(from.lower()), conversion::convert_to<U>(from.upper()));
return to;
}
};
@@ -39,14 +39,14 @@
#else
namespace numeric {
template < class T, class PT, class U, class PU>
- inline static interval<T,PT> convert_to(interval<U,PU> const & from, type_tag<interval<T,PT> >)
+ inline static interval<T,PT> convert_to(interval<U,PU> const & from, boost::dummy::type_tag<interval<T,PT> >)
{
- return interval<T,PT>(boost::convert_to<T>(from.lower()), boost::convert_to<U>(from.upper()));
+ return interval<T,PT>(conversion::convert_to<T>(from.lower()), conversion::convert_to<U>(from.upper()));
}
template < class T, class PT, class U, class PU>
inline static interval<T,PT>& assign_to(interval<T,PT>& to, const interval<U,PU>& from)
{
- to.assign(boost::convert_to<T>(from.lower()), boost::convert_to<U>(from.upper()));
+ to.assign(conversion::convert_to<T>(from.lower()),conversion::convert_to<U>(from.upper()));
return to;
}
}
Modified: sandbox/conversion/boost/conversion/boost/optional.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/optional.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/optional.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -18,7 +18,7 @@
#include <boost/conversion/assign_to.hpp>
#include <boost/config.hpp>
-#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
+//#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
namespace boost {
@@ -28,14 +28,14 @@
struct convert_to< optional<Target>, optional<Source> > {
inline static optional<Target> apply(optional<Source> const & from)
{
- return (from?optional<Target>(boost::convert_to<Target>(from.get())):optional<Target>());
+ return (from?optional<Target>(conversion::convert_to<Target>(from.get())):optional<Target>());
}
};
template < class Target, class Source>
struct assign_to< optional<Target>, optional<Source> > {
inline static optional<Target>& apply(optional<Target>& to, const optional<Source>& from)
{
- to = from?boost::convert_to<Target>(from.get()):optional<Target>();
+ to = from?conversion::convert_to<Target>(from.get()):optional<Target>();
return to;
}
};
@@ -43,15 +43,15 @@
}}
#else
template < class Target, class Source>
- inline static optional<Target> convert_to(optional<Source> const & from)
+ inline optional<Target> convert_to(optional<Source> const & from, boost::dummy::type_tag<optional<Target> >)
{
- return (from?optional<Target>(boost::convert_to<Target>(from.get())):optional<Target>());
+ return (from?optional<Target>(conversion::convert_to<Target>(from.get())):optional<Target>());
}
template < class Target, class Source>
- inline static optional<Target>& assign_to(optional<Target>& to, const optional<Source>& from)
+ inline optional<Target>& assign_to(optional<Target>& to, const optional<Source>& from)
{
- to = from?boost::convert_to<Target>(from.get()):optional<Target>();
+ to = from?conversion::convert_to<Target>(from.get()):optional<Target>();
return to;
}
#endif
Modified: sandbox/conversion/boost/conversion/boost/rational.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/rational.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/rational.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -16,7 +16,7 @@
#include <boost/conversion/assign_to.hpp>
#include <boost/config.hpp>
-#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
+//#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
namespace boost {
@@ -26,14 +26,14 @@
struct convert_to< rational<T>, rational<U> > {
inline static rational<T> apply(rational<U> const & from)
{
- return rational<T>(boost::convert_to<T>(from.numerator()), boost::convert_to<T>(from.denominator()));
+ return rational<T>(conversion::convert_to<T>(from.numerator()), conversion::convert_to<T>(from.denominator()));
}
};
template < class T, class U>
struct assign_to< rational<T>, rational<U> > {
inline static rational<T>& apply(rational<T>& to, const rational<U>& from)
{
- to.assign(boost::convert_to<T>(from.numerator()), boost::convert_to<T>(from.denominator()));
+ to.assign(conversion::convert_to<T>(from.numerator()), conversion::convert_to<T>(from.denominator()));
return to;
}
};
@@ -41,15 +41,15 @@
}}
#else
template < class T, class U>
- inline static rational<T> convert_to(rational<U> const & from)
+ inline static rational<T> convert_to(rational<U> const & from, boost::dummy::type_tag<rational<T> >)
{
- return rational<T>(boost::convert_to<T>(from.numerator()), boost::convert_to<T>(from.denominator()));
+ return rational<T>(conversion::convert_to<T>(from.numerator()), conversion::convert_to<T>(from.denominator()));
}
template < class T, class U>
inline static rational<T>& assign_to(rational<T>& to, const rational<U>& from)
{
- to.assign(boost::convert_to<T>(from.numerator()), boost::convert_to<T>(from.denominator()));
+ to.assign(conversion::convert_to<T>(from.numerator()), conversion::convert_to<T>(from.denominator()));
return to;
}
#endif
Modified: sandbox/conversion/boost/conversion/boost/tuple.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/tuple.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/tuple.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -14,7 +14,8 @@
#include <boost/fusion/tuple.hpp>
#include <boost/conversion/convert_to.hpp>
#include <boost/conversion/assign_to.hpp>
-#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
+
+//#define BOOST_CONVERSION_NO_FUNCTION_TEMPLATE_ORDERING 1
namespace boost {
@@ -25,8 +26,8 @@
inline static boost::fusion::tuple<T1,T2> apply(boost::fusion::tuple<U1,U2> const & from)
{
return boost::fusion::tuple<T1,T2>(
- boost::convert_to<T1>(boost::fusion::get<0>(from))
- , boost::convert_to<T2>(boost::fusion::get<1>(from))
+ conversion::convert_to<T1>(boost::fusion::get<0>(from))
+ , conversion::convert_to<T2>(boost::fusion::get<1>(from))
);
}
};
@@ -34,7 +35,7 @@
struct assign_to< boost::fusion::tuple<T1,T2>, boost::fusion::tuple<U1,U2> > {
inline static boost::fusion::tuple<T1,T2>& apply(boost::fusion::tuple<T1,T2>& to, boost::fusion::tuple<U1,U2> const & from)
{
- to = boost::convert_to<boost::fusion::tuple<T1,T2> >(from);
+ to = conversion::convert_to<boost::fusion::tuple<T1,T2> >(from);
return to;
}
};
@@ -43,9 +44,9 @@
inline static boost::fusion::tuple<T1,T2,T3> apply(boost::fusion::tuple<U1,U2,U3> const & from)
{
return boost::fusion::tuple<T1,T2, T3>(
- boost::convert_to<T1>(boost::fusion::get<0>(from))
- , boost::convert_to<T2>(boost::fusion::get<1>(from))
- , boost::convert_to<T3>(boost::fusion::get<2>(from))
+ conversion::convert_to<T1>(boost::fusion::get<0>(from))
+ , conversion::convert_to<T2>(boost::fusion::get<1>(from))
+ , conversion::convert_to<T3>(boost::fusion::get<2>(from))
);
}
};
@@ -53,7 +54,7 @@
struct assign_to< boost::fusion::tuple<T1,T2,T3>, boost::fusion::tuple<U1,U2,U3> > {
inline static boost::fusion::tuple<T1,T2,T3> apply(boost::fusion::tuple<T1,T2,T3>& to, boost::fusion::tuple<U1,U2,U3> const & from)
{
- to = boost::convert_to<boost::fusion::tuple<T1,T2> >(from);
+ to = conversion::convert_to<boost::fusion::tuple<T1,T2> >(from);
return to;
}
};
@@ -62,35 +63,37 @@
#else
namespace fusion {
template < class T1, class T2, class U1, class U2>
- inline static tuple<T1,T2> convert_to(tuple<U1,U2> const & from)
+ inline static tuple<T1,T2> convert_to(tuple<U1,U2> const & from
+ , boost::dummy::type_tag<tuple<T1,T2> >)
{
return tuple<T1,T2>(
- boost::convert_to<T1>(boost::fusion::get<0>(from))
- , boost::convert_to<T2>(boost::fusion::get<1>(from))
+ conversion::convert_to<T1>(boost::fusion::get<0>(from))
+ , conversion::convert_to<T2>(boost::fusion::get<1>(from))
);
}
template < class T1, class T2, class U1, class U2>
inline static tuple<T1,T2>& assign_to(tuple<T1,T2>& to, tuple<U1,U2> const & from)
{
- to = boost::convert_to<boost::fusion::tuple<T1,T2> >(from);
+ to = conversion::convert_to<boost::fusion::tuple<T1,T2> >(from);
return to;
}
template < class T1, class T2, class T3, class U1, class U2, class U3>
- inline static tuple<T1,T2,T3> convert_to(tuple<U1,U2,U3> const & from)
+ inline static tuple<T1,T2,T3> convert_to(tuple<U1,U2,U3> const & from
+ , boost::dummy::type_tag<tuple<T1,T2,T3> >)
{
return boost::fusion::tuple<T1,T2, T3>(
- boost::convert_to<T1>(boost::fusion::get<0>(from))
- , boost::convert_to<T2>(boost::fusion::get<1>(from))
- , boost::convert_to<T3>(boost::fusion::get<2>(from))
+ conversion::convert_to<T1>(boost::fusion::get<0>(from))
+ , conversion::convert_to<T2>(boost::fusion::get<1>(from))
+ , conversion::convert_to<T3>(boost::fusion::get<2>(from))
);
}
template < class T1, class T2, class T3, class U1, class U2, class U3>
inline static tuple<T1,T2,T3> assign_to(tuple<T1,T2,T3>& to, boost::fusion::tuple<U1,U2,U3> const & from)
{
- to = boost::convert_to<boost::fusion::tuple<T1,T2> >(from);
+ to = conversion::convert_to<boost::fusion::tuple<T1,T2> >(from);
return to;
}
}
Modified: sandbox/conversion/boost/conversion/ca_wrapper.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/ca_wrapper.hpp (original)
+++ sandbox/conversion/boost/conversion/ca_wrapper.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -14,7 +14,7 @@
#include <boost/conversion/convert_to.hpp>
#include <boost/conversion/assign_to.hpp>
-namespace boost {
+namespace boost { namespace conversion {
template <typename T>
class ca_wrapper {
@@ -23,11 +23,11 @@
ca_wrapper(T& r) : ref_(r) {}
template <typename U>
operator U() {
- return boost::convert_to<U>(ref_);
+ return boost::conversion::convert_to<U>(ref_);
}
template <typename U>
T& operator =(U const& u) {
- return boost::assign_to(ref_, u);
+ return boost::conversion::assign_to(ref_, u);
}
};
@@ -36,7 +36,7 @@
return ca_wrapper<T>(r);
}
-}
+}}
#endif
Modified: sandbox/conversion/boost/conversion/convert_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/convert_to.hpp (original)
+++ sandbox/conversion/boost/conversion/convert_to.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -14,47 +14,43 @@
#include <cstddef> //for std::size_t
namespace boost {
- template <typename T>
- struct type_tag {};
-
+ namespace dummy {
+ template <typename T>
+ struct type_tag {};
+ }
namespace conversion {
-
- //template < typename To, typename From >
- //To convert_to(const From& val, type_tag<To> p=type_tag<To>());
-
- namespace partial_specialization_workaround {
- template < typename To, typename From >
- struct convert_to {
- inline static To apply(const From& val)
- {
- return To(val);
+ namespace partial_specialization_workaround {
+ template < typename To, typename From >
+ struct convert_to {
+ inline static To apply(const From& val)
+ {
+ return To(val);
+ }
+ };
}
- };
- }
-
- template < typename To, typename From >
- To convert_to(const From& val, type_tag<To>) {
- return partial_specialization_workaround::convert_to<To,From>::apply(val);
- }
-
-}}
-
-namespace boost_conversion_impl {
- template <typename Target, typename Source>
- Target convert_to_impl(Source const& from) {
- using namespace boost::conversion;
- //use boost::conversion::convert_to if ADL fails
- return convert_to<Target, Source>(from, boost::type_tag<Target>());
}
-}
-
-namespace boost {
- template <typename Target, typename Source>
- Target convert_to(Source const& from, type_tag<Target> p=type_tag<Target>()) {
- return ::boost_conversion_impl::convert_to_impl<Target>(from);
+ namespace conversion_default {
+ template < typename To, typename From >
+ To convert_to(const From& val, dummy::type_tag<To>) {
+ return conversion::partial_specialization_workaround::convert_to<To,From>::apply(val);
+ }
+ }
+ namespace conversion_impl {
+ template <typename Target, typename Source>
+ Target convert_to_impl(Source const& from) {
+ using namespace boost::conversion_default;
+ //use boost::conversion::convert_to if ADL fails
+ return convert_to(from, boost::dummy::type_tag<Target>());
+ }
}
+ namespace conversion {
+ template <typename Target, typename Source>
+ Target convert_to(Source const& from, boost::dummy::type_tag<Target> p=boost::dummy::type_tag<Target>()) {
+ return conversion_impl::convert_to_impl<Target>(from);
+ }
+
+ }
}
-
#endif
Modified: sandbox/conversion/boost/conversion/convert_to_via.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/convert_to_via.hpp (original)
+++ sandbox/conversion/boost/conversion/convert_to_via.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -13,14 +13,13 @@
#include <boost/conversion/convert_to.hpp>
-namespace boost {
+namespace boost { namespace conversion {
template < typename To, typename Via, typename From >
- To convert_to_via(const From& val, type_tag<To>) {
- boost::convert_to(boost::convert_to(val, type_tag<Via>()), type_tag<To>());
+ To convert_to_via(const From& val) {
+ boost::convert_to<To>(boost::convert_to<Via>(val));
}
-
-}
+}}
#endif
Modified: sandbox/conversion/boost/conversion/std/complex.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/complex.hpp (original)
+++ sandbox/conversion/boost/conversion/std/complex.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -23,15 +23,15 @@
struct convert_to< std::complex<T>, std::complex<U> > {
inline static std::complex<T> apply(std::complex<U> const & from)
{
- return std::complex<T>(boost::convert_to<T>(from.real()), boost::convert_to<T>(from.imag()));
+ return std::complex<T>(conversion::convert_to<T>(from.real()), conversion::convert_to<T>(from.imag()));
}
};
template < class T, class U>
struct assign_to< std::complex<T>, std::complex<U> > {
inline static std::complex<T>& apply(std::complex<T>& to, const std::complex<U>& from)
{
- to.real() = boost::convert_to<T>(from.real());
- to.imag() = boost::convert_to<T>(from.imag());
+ to.real() = conversion::convert_to<T>(from.real());
+ to.imag() = conversion::convert_to<T>(from.imag());
return to;
}
};
Modified: sandbox/conversion/boost/conversion/std/pair.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/pair.hpp (original)
+++ sandbox/conversion/boost/conversion/std/pair.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -23,15 +23,15 @@
struct convert_to< std::pair<T1,T2>, std::pair<U1,U2> > {
inline static std::pair<T1,T2> apply(std::pair<U1,U2> const & from)
{
- return std::pair<T1,T2>(boost::convert_to<T1>(from.first), boost::convert_to<T2>(from.second));
+ return std::pair<T1,T2>(conversion::convert_to<T1>(from.first), conversion::convert_to<T2>(from.second));
}
};
template < class T1, class T2, class U1, class U2>
struct assign_to< std::pair<T1,T2>, std::pair<U1,U2> > {
inline static std::pair<T1,T2>& apply(std::pair<T1,T2>& to, const std::pair<U1,U2>& from)
{
- to.first = boost::convert_to<T1>(from.first);
- to.second = boost::convert_to<T2>(from.second);
+ to.first = conversion::convert_to<T1>(from.first);
+ to.second = conversion::convert_to<T2>(from.second);
return to;
}
};
Modified: sandbox/conversion/libs/conversion/test/array.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/array.cpp (original)
+++ sandbox/conversion/libs/conversion/test/array.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -20,13 +20,13 @@
void explicit_convert_to() {
boost::array<B1,3> bs;
boost::array<A1,3> as;
- as = convert_to<boost::array<A1,3> >(bs);
+ as = conversion::convert_to<boost::array<A1,3> >(bs);
}
void explicit_assign_to() {
boost::array<int,3> bs;
boost::array<short,3> as;
- assign_to(as,bs);
+ conversion::assign_to(as,bs);
}
Modified: sandbox/conversion/libs/conversion/test/builtins.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/builtins.cpp (original)
+++ sandbox/conversion/libs/conversion/test/builtins.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -13,7 +13,7 @@
#include <boost/conversion/ca_wrapper.hpp>
#include <boost/conversion/convert_to.hpp>
-using namespace boost;
+//using namespace boost;
using namespace boost::unit_test;
@@ -28,42 +28,42 @@
unsigned int ui(i);
unsigned long ul(l);
- c=convert_to<char>(c);
- s=boost::convert_to<short>(c);
- i=boost::convert_to<int>(c);
- l=boost::convert_to<long>(c);
- uc=boost::convert_to<unsigned char>(c);
- us=boost::convert_to<unsigned short>(c);
- ui=boost::convert_to<unsigned int>(c);
- ul=boost::convert_to<unsigned long>(c);
-
-
- c=boost::convert_to<char>(s);
- s=boost::convert_to<short>(s);
- i=boost::convert_to<int>(s);
- l=boost::convert_to<long>(s);
- uc=boost::convert_to<unsigned char>(s);
- us=boost::convert_to<unsigned short>(s);
- ui=boost::convert_to<unsigned int>(s);
- ul=boost::convert_to<unsigned long>(s);
-
- c=boost::convert_to<char>(i);
- s=boost::convert_to<short>(i);
- i=boost::convert_to<int>(i);
- l=boost::convert_to<long>(i);
- uc=boost::convert_to<unsigned char>(i);
- us=boost::convert_to<unsigned short>(i);
- ui=boost::convert_to<unsigned int>(i);
- ul=boost::convert_to<unsigned long>(i);
-
- c=boost::convert_to<char>(l);
- s=boost::convert_to<short>(l);
- i=boost::convert_to<int>(l);
- l=boost::convert_to<long>(l);
- uc=boost::convert_to<unsigned char>(l);
- us=boost::convert_to<unsigned short>(l);
- ui=boost::convert_to<unsigned int>(l);
- ul=boost::convert_to<unsigned long>(l);
+ c=boost::conversion::convert_to<char>(c);
+ s=boost::conversion::convert_to<short>(c);
+ i=boost::conversion::convert_to<int>(c);
+ l=boost::conversion::convert_to<long>(c);
+ uc=boost::conversion::convert_to<unsigned char>(c);
+ us=boost::conversion::convert_to<unsigned short>(c);
+ ui=boost::conversion::convert_to<unsigned int>(c);
+ ul=boost::conversion::convert_to<unsigned long>(c);
+
+
+ c=boost::conversion::convert_to<char>(s);
+ s=boost::conversion::convert_to<short>(s);
+ i=boost::conversion::convert_to<int>(s);
+ l=boost::conversion::convert_to<long>(s);
+ uc=boost::conversion::convert_to<unsigned char>(s);
+ us=boost::conversion::convert_to<unsigned short>(s);
+ ui=boost::conversion::convert_to<unsigned int>(s);
+ ul=boost::conversion::convert_to<unsigned long>(s);
+
+ c=boost::conversion::convert_to<char>(i);
+ s=boost::conversion::convert_to<short>(i);
+ i=boost::conversion::convert_to<int>(i);
+ l=boost::conversion::convert_to<long>(i);
+ uc=boost::conversion::convert_to<unsigned char>(i);
+ us=boost::conversion::convert_to<unsigned short>(i);
+ ui=boost::conversion::convert_to<unsigned int>(i);
+ ul=boost::conversion::convert_to<unsigned long>(i);
+
+ c=boost::conversion::convert_to<char>(l);
+ s=boost::conversion::convert_to<short>(l);
+ i=boost::conversion::convert_to<int>(l);
+ l=boost::conversion::convert_to<long>(l);
+ uc=boost::conversion::convert_to<unsigned char>(l);
+ us=boost::conversion::convert_to<unsigned short>(l);
+ ui=boost::conversion::convert_to<unsigned int>(l);
+ ul=boost::conversion::convert_to<unsigned long>(l);
}
@@ -77,45 +77,45 @@
unsigned int ui(i);
unsigned long ul(l);
- boost::assign_to(c, 0);
- boost::assign_to(c, c);
- boost::assign_to(c, s);
- boost::assign_to(c, i);
- boost::assign_to(c, l);
- boost::assign_to(c, uc);
- boost::assign_to(c, us);
- boost::assign_to(c, ui);
- boost::assign_to(c, ul);
-
- boost::assign_to(s, 1);
- boost::assign_to(s, c);
- boost::assign_to(s, s);
- boost::assign_to(s, i);
- boost::assign_to(s, l);
- boost::assign_to(s, uc);
- boost::assign_to(s, us);
- boost::assign_to(s, ui);
- boost::assign_to(s, ul);
-
- boost::assign_to(i, 2);
- boost::assign_to(i, c);
- boost::assign_to(i, s);
- boost::assign_to(i, i);
- boost::assign_to(i, l);
- boost::assign_to(i, uc);
- boost::assign_to(i, us);
- boost::assign_to(i, ui);
- boost::assign_to(i, ul);
-
- boost::assign_to(l, 3);
- boost::assign_to(l, c);
- boost::assign_to(l, s);
- boost::assign_to(l, i);
- boost::assign_to(l, l);
- boost::assign_to(l, uc);
- boost::assign_to(l, us);
- boost::assign_to(l, ui);
- boost::assign_to(l, ul);
+ boost::conversion::assign_to(c, 0);
+ boost::conversion::assign_to(c, c);
+ boost::conversion::assign_to(c, s);
+ boost::conversion::assign_to(c, i);
+ boost::conversion::assign_to(c, l);
+ boost::conversion::assign_to(c, uc);
+ boost::conversion::assign_to(c, us);
+ boost::conversion::assign_to(c, ui);
+ boost::conversion::assign_to(c, ul);
+
+ boost::conversion::assign_to(s, 1);
+ boost::conversion::assign_to(s, c);
+ boost::conversion::assign_to(s, s);
+ boost::conversion::assign_to(s, i);
+ boost::conversion::assign_to(s, l);
+ boost::conversion::assign_to(s, uc);
+ boost::conversion::assign_to(s, us);
+ boost::conversion::assign_to(s, ui);
+ boost::conversion::assign_to(s, ul);
+
+ boost::conversion::assign_to(i, 2);
+ boost::conversion::assign_to(i, c);
+ boost::conversion::assign_to(i, s);
+ boost::conversion::assign_to(i, i);
+ boost::conversion::assign_to(i, l);
+ boost::conversion::assign_to(i, uc);
+ boost::conversion::assign_to(i, us);
+ boost::conversion::assign_to(i, ui);
+ boost::conversion::assign_to(i, ul);
+
+ boost::conversion::assign_to(l, 3);
+ boost::conversion::assign_to(l, c);
+ boost::conversion::assign_to(l, s);
+ boost::conversion::assign_to(l, i);
+ boost::conversion::assign_to(l, l);
+ boost::conversion::assign_to(l, uc);
+ boost::conversion::assign_to(l, us);
+ boost::conversion::assign_to(l, ui);
+ boost::conversion::assign_to(l, ul);
}
void mca_assign_to_with_builtin_types() {
@@ -128,49 +128,49 @@
unsigned int ui(i);
unsigned long ul(l);
- boost::mca(c) = c;
- boost::mca(c) = s;
- boost::mca(c) = i;
- boost::mca(c) = l;
- boost::mca(c) = uc;
- boost::mca(c) = us;
- boost::mca(c) = ui;
- boost::mca(c) = ul;
-
- boost::mca(s) = c;
- boost::mca(s) = s;
- boost::mca(s) = i;
- boost::mca(s) = l;
- boost::mca(s) = uc;
- boost::mca(s) = us;
- boost::mca(s) = ui;
- boost::mca(s) = ul;
-
- boost::mca(i) = c;
- boost::mca(i) = s;
- boost::mca(i) = i;
- boost::mca(i) = l;
- boost::mca(i) = uc;
- boost::mca(i) = us;
- boost::mca(i) = ui;
- boost::mca(i) = ul;
-
- boost::mca(l) = c;
- boost::mca(l) = s;
- boost::mca(l) = i;
- boost::mca(l) = l;
- boost::mca(l) = uc;
- boost::mca(l) = us;
- boost::mca(l) = ui;
- boost::mca(l) = ul;
+ boost::conversion::mca(c) = c;
+ boost::conversion::mca(c) = s;
+ boost::conversion::mca(c) = i;
+ boost::conversion::mca(c) = l;
+ boost::conversion::mca(c) = uc;
+ boost::conversion::mca(c) = us;
+ boost::conversion::mca(c) = ui;
+ boost::conversion::mca(c) = ul;
+
+ boost::conversion::mca(s) = c;
+ boost::conversion::mca(s) = s;
+ boost::conversion::mca(s) = i;
+ boost::conversion::mca(s) = l;
+ boost::conversion::mca(s) = uc;
+ boost::conversion::mca(s) = us;
+ boost::conversion::mca(s) = ui;
+ boost::conversion::mca(s) = ul;
+
+ boost::conversion::mca(i) = c;
+ boost::conversion::mca(i) = s;
+ boost::conversion::mca(i) = i;
+ boost::conversion::mca(i) = l;
+ boost::conversion::mca(i) = uc;
+ boost::conversion::mca(i) = us;
+ boost::conversion::mca(i) = ui;
+ boost::conversion::mca(i) = ul;
+
+ boost::conversion::mca(l) = c;
+ boost::conversion::mca(l) = s;
+ boost::conversion::mca(l) = i;
+ boost::conversion::mca(l) = l;
+ boost::conversion::mca(l) = uc;
+ boost::conversion::mca(l) = us;
+ boost::conversion::mca(l) = ui;
+ boost::conversion::mca(l) = ul;
}
void assign_to_transitive() {
- int a=0; int b=0; int c=0;
+ int a=0; int b=0; //int c=0;
//assign_to(a, assign_to(b, assign_to(c,1)));
- boost::assign_to(a, boost::assign_to(b, c));
+ boost::conversion::assign_to(a, boost::conversion::assign_to(b, 1));
}
@@ -178,7 +178,7 @@
{
int a=0; int b=0; int c=0;
- boost::mca(a) = boost::mca(b) = boost::mca(b) = 1;
+ boost::conversion::mca(a) = boost::conversion::mca(b) = boost::conversion::mca(c) = 1;
}
}
Modified: sandbox/conversion/libs/conversion/test/chrono_posix_time_duration.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/chrono_posix_time_duration.cpp (original)
+++ sandbox/conversion/libs/conversion/test/chrono_posix_time_duration.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -20,17 +20,17 @@
typedef short B1;
void explicit_convert_to() {
- chrono::seconds a(3);
- posix_time::time_duration b(convert_to<posix_time::time_duration >(a));
- chrono::seconds c(convert_to<chrono::seconds>(b));
+ boost::chrono::seconds a(3);
+ boost::posix_time::time_duration b(conversion::convert_to<boost::posix_time::time_duration >(a));
+ boost::chrono::seconds c(conversion::convert_to<boost::chrono::seconds>(b));
}
void explicit_assign_to() {
- chrono::seconds a(3);
- posix_time::time_duration b;
- assign_to(b, a);
- chrono::seconds c;
- assign_to(c, b);
+ boost::chrono::seconds a(3);
+ boost::posix_time::time_duration b;
+ conversion::assign_to(b, a);
+ boost::chrono::seconds c;
+ conversion::assign_to(c, b);
}
test_suite* init_unit_test_suite(int, char*[])
Modified: sandbox/conversion/libs/conversion/test/chrono_posix_time_time.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/chrono_posix_time_time.cpp (original)
+++ sandbox/conversion/libs/conversion/test/chrono_posix_time_time.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -21,16 +21,16 @@
void explicit_convert_to() {
chrono::system_clock::time_point a=chrono::system_clock::now();
- posix_time::ptime b(convert_to<posix_time::ptime >(a));
- chrono::system_clock::time_point c(convert_to<chrono::system_clock::time_point>(b));
+ posix_time::ptime b(conversion::convert_to<posix_time::ptime >(a));
+ chrono::system_clock::time_point c(conversion::convert_to<chrono::system_clock::time_point>(b));
}
void explicit_assign_to() {
chrono::system_clock::time_point a=chrono::system_clock::now();
posix_time::ptime b;
- assign_to(b, a);
+ conversion::assign_to(b, a);
chrono::system_clock::time_point c;
- assign_to(c, b);
+ conversion::assign_to(c, b);
}
test_suite* init_unit_test_suite(int, char*[])
Modified: sandbox/conversion/libs/conversion/test/complex.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/complex.cpp (original)
+++ sandbox/conversion/libs/conversion/test/complex.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -21,8 +21,8 @@
B1 b1;
B1 b2;
std::complex<B1> b;
- std::complex<A1> a1(convert_to<std::complex<A1> >(b));
- std::complex<A1> a2(convert_to<std::complex<A1> >(std::complex<B1>(b1,b2)));
+ std::complex<A1> a1(conversion::convert_to<std::complex<A1> >(b));
+ std::complex<A1> a2(conversion::convert_to<std::complex<A1> >(std::complex<B1>(b1,b2)));
}
void explicit_assign_to() {
@@ -30,8 +30,8 @@
B1 b2;
std::complex<A1> a;
std::complex<B1> b;
- assign_to(a,b);
- assign_to(a,std::complex<B1>(b1,b2));
+ conversion::assign_to(a,b);
+ conversion::assign_to(a,std::complex<B1>(b1,b2));
}
test_suite* init_unit_test_suite(int, char*[])
Modified: sandbox/conversion/libs/conversion/test/extrinsec.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/extrinsec.cpp (original)
+++ sandbox/conversion/libs/conversion/test/extrinsec.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -21,7 +21,7 @@
namespace boost { namespace conversion {
template <>
- A convert_to<A,B>(const B& val, type_tag<A>) {
+ A convert_to<A,B>(const B& val, boost::dummy::type_tag<A>) {
return A();
}
@@ -34,14 +34,14 @@
void explicit_convert_to() {
B b;
- A a(convert_to<A>(b));
+ A a(conversion::convert_to<A>(b));
}
void explicit_assign_to() {
B b;
A a;
- assign_to(a, b);
- mca(a)= b;
+ conversion::assign_to(a, b);
+ conversion::mca(a)= b;
}
test_suite* init_unit_test_suite(int, char*[])
Modified: sandbox/conversion/libs/conversion/test/helper.hpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/helper.hpp (original)
+++ sandbox/conversion/libs/conversion/test/helper.hpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -20,8 +20,9 @@
struct B2{};
namespace boost {
+ namespace conversion {
template <>
- A1 convert_to<A1,B1>(const B1& val, type_tag<A1>) {
+ A1 convert_to<A1,B1>(const B1& val, boost::dummy::type_tag<A1>) {
return A1();
}
@@ -30,7 +31,7 @@
return to;
}
- namespace conversion { namespace partial_specialization_workaround {
+ namespace partial_specialization_workaround {
template <>
struct convert_to< A2,B2 > {
inline static A2 apply(B2 const & from)
@@ -45,7 +46,8 @@
return to;
}
};
- }}
+ }
+ }
}
#endif //BOOST_CONVERSION_TEST_HELPER__HPP
Modified: sandbox/conversion/libs/conversion/test/interval.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/interval.cpp (original)
+++ sandbox/conversion/libs/conversion/test/interval.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -22,18 +22,19 @@
void explicit_convert_to() {
B1 b1;
B1 b2;
- numeric::interval<B1> b;
- numeric::interval<A1> a1(convert_to<numeric::interval<A1> >(b));
- numeric::interval<A1> a2(convert_to<numeric::interval<A1> >(numeric::interval<B1>(b1,b2)));
+ boost::numeric::interval<B1> b;
+ boost::numeric::interval<A1> a1(conversion::convert_to<boost::numeric::interval<A1> >(b));
+ boost::numeric::interval<A1> a2(conversion::convert_to<boost::numeric::interval<A1> >(
+ boost::numeric::interval<B1>(b1,b2)));
}
void explicit_assign_to() {
B1 b1;
B1 b2;
- numeric::interval<A1> a;
- numeric::interval<B1> b;
- assign_to(a,b);
- assign_to(a,numeric::interval<B1>(b1,b2));
+ boost::numeric::interval<A1> a;
+ boost::numeric::interval<B1> b;
+ conversion::assign_to(a,b);
+ conversion::assign_to(a,boost::numeric::interval<B1>(b1,b2));
}
test_suite* init_unit_test_suite(int, char*[])
Modified: sandbox/conversion/libs/conversion/test/intrinsec.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/intrinsec.cpp (original)
+++ sandbox/conversion/libs/conversion/test/intrinsec.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -44,7 +44,7 @@
}
{
B b;
- A a(convert_to<A>(b));
+ A a(conversion::convert_to<A>(b));
}
}
@@ -55,7 +55,7 @@
}
{
B b;
- AE ae(convert_to<AE>(b));
+ AE ae(conversion::convert_to<AE>(b));
}
}
@@ -67,7 +67,7 @@
}
{
C c;
- A a(convert_to<A>(c));
+ A a(conversion::convert_to<A>(c));
}
}
@@ -80,13 +80,13 @@
{
A a(0);
AA aa(0);
- assign_to(aa,a);
+ conversion::assign_to(aa,a);
}
}
void mca_with_assignemet_operator() {
A a(0);
AA aa(0);
- mca(aa) =a;
+ conversion::mca(aa) =a;
}
void assign_to_with_assignemet_operator_and_implicit_constructor() {
@@ -98,13 +98,13 @@
{
B b;
AA aa(1);
- assign_to(aa,b);
+ conversion::assign_to(aa,b);
}
}
void mca_with_assignemet_operator_and_implicit_constructor() {
B b;
AA aa(1);
- mca(aa)=b;
+ conversion::mca(aa)=b;
}
void assign_to_with_assignemet_operator_and_conversion_operator() {
@@ -116,14 +116,14 @@
{
C c;
CC cc(1);
- assign_to(cc,c);
+ conversion::assign_to(cc,c);
}
}
void mca_with_assignemet_operator_and_conversion_operator() {
C c;
CC cc(1);
- mca(cc)=c;
+ conversion::mca(cc)=c;
}
Modified: sandbox/conversion/libs/conversion/test/optional.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/optional.cpp (original)
+++ sandbox/conversion/libs/conversion/test/optional.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -16,24 +16,32 @@
using namespace boost;
using namespace boost::unit_test;
-typedef int A1;
-typedef short B1;
+ struct A1{};
+ struct B1{};
+ A1 convert_to(const B1& val, boost::dummy::type_tag<A1>) {
+ return A1();
+ }
+
+ A1& assign_to(A1& to, const B1& from) {
+ return to;
+ }
+
void explicit_convert_to() {
B1 b1;
- optional<B1> b;
- optional<A1> a1(convert_to<optional<A1> >(b));
+ boost::optional<B1> b;
+ boost::optional<A1> a1(conversion::convert_to<boost::optional<A1> >(b));
//optional<A1> a1;
//a1=convert_to<optional<A1> >(b);
- optional<A1> a2(convert_to<optional<A1> >(optional<B1>(b1)));
+ boost::optional<A1> a2(conversion::convert_to<boost::optional<A1> >(boost::optional<B1>(b1)));
}
void explicit_assign_to() {
B1 b1;
- optional<A1> a;
- optional<B1> b;
+ boost::optional<A1> a;
+ boost::optional<B1> b;
//assign_to(b,a);
- assign_to(a, optional<B1>(b1));
+ conversion::assign_to(a, boost::optional<B1>(b1));
}
test_suite* init_unit_test_suite(int, char*[])
Modified: sandbox/conversion/libs/conversion/test/pair.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/pair.cpp (original)
+++ sandbox/conversion/libs/conversion/test/pair.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -22,9 +22,9 @@
B1 b1;
B2 b2;
std::pair<B1,B2> b;
- std::pair<A1,A2> a1(convert_to<std::pair<A1,A2> >(b));
- std::pair<A1,A2> a2(convert_to<std::pair<A1,A2> >(std::pair<B1,B2>(b1,b2)));
- std::pair<A1,A2> a3(convert_to<std::pair<A1,A2> >(std::make_pair(b1,b2)));
+ std::pair<A1,A2> a1(conversion::convert_to<std::pair<A1,A2> >(b));
+ std::pair<A1,A2> a2(conversion::convert_to<std::pair<A1,A2> >(std::pair<B1,B2>(b1,b2)));
+ std::pair<A1,A2> a3(conversion::convert_to<std::pair<A1,A2> >(std::make_pair(b1,b2)));
}
void explicit_assign_to() {
@@ -32,9 +32,9 @@
B2 b2;
std::pair<A1,A2> a;
std::pair<B1,B2> b;
- assign_to(a,b);
- assign_to(a, std::pair<B1,B2>(b1,b2));
- assign_to(a, std::make_pair(b1,b2));
+ conversion::assign_to(a,b);
+ conversion::assign_to(a, std::pair<B1,B2>(b1,b2));
+ conversion::assign_to(a, std::make_pair(b1,b2));
}
Modified: sandbox/conversion/libs/conversion/test/rational.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/rational.cpp (original)
+++ sandbox/conversion/libs/conversion/test/rational.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -18,22 +18,22 @@
typedef int A1;
typedef short B1;
-
+
void explicit_convert_to() {
B1 b1;
B1 b2(2);
- rational<B1> b(1,2);
- rational<A1> a1(convert_to<rational<A1> >(b));
- rational<A1> a2(convert_to<rational<A1> >(rational<B1>(b1,b2)));
+ boost::rational<B1> b(1,2);
+ boost::rational<A1> a1(conversion::convert_to<boost::rational<A1> >(b));
+ boost::rational<A1> a2(conversion::convert_to<boost::rational<A1> >(boost::rational<B1>(b1,b2)));
}
void explicit_assign_to() {
B1 b1;
B1 b2(2);
- rational<A1> a;
- rational<B1> b(1,2);
- assign_to(a, b);
- assign_to(a, rational<B1>(b1,b2));
+ boost::rational<A1> a;
+ boost::rational<B1> b(1,2);
+ conversion::assign_to(a, b);
+ conversion::assign_to(a, boost::rational<B1>(b1,b2));
}
test_suite* init_unit_test_suite(int, char*[])
Modified: sandbox/conversion/libs/conversion/test/tuple.cpp
==============================================================================
--- sandbox/conversion/libs/conversion/test/tuple.cpp (original)
+++ sandbox/conversion/libs/conversion/test/tuple.cpp 2009-10-27 04:46:48 EDT (Tue, 27 Oct 2009)
@@ -21,9 +21,9 @@
B1 b1;
B2 b2;
fusion::tuple<B1,B2> b;
- fusion::tuple<A1,A2> a1(convert_to<fusion::tuple<A1,A2> >(b));
- fusion::tuple<A1,A2> a2(convert_to<fusion::tuple<A1,A2> >(fusion::tuple<B1,B2>(b1,b2)));
- fusion::tuple<A1,A2> a3(convert_to<fusion::tuple<A1,A2> >(fusion::make_tuple(b1,b2)));
+ fusion::tuple<A1,A2> a1(conversion::convert_to<fusion::tuple<A1,A2> >(b));
+ fusion::tuple<A1,A2> a2(conversion::convert_to<fusion::tuple<A1,A2> >(fusion::tuple<B1,B2>(b1,b2)));
+ fusion::tuple<A1,A2> a3(conversion::convert_to<fusion::tuple<A1,A2> >(fusion::make_tuple(b1,b2)));
}
void explicit_assign_to() {
@@ -31,9 +31,9 @@
B2 b2;
fusion::tuple<A1,A2> a;
fusion::tuple<B1,B2> b;
- assign_to(a, b);
- assign_to(a, fusion::tuple<B1,B2>(b1,b2));
- assign_to(a, fusion::make_tuple(b1,b2));
+ conversion::assign_to(a, b);
+ conversion::assign_to(a, fusion::tuple<B1,B2>(b1,b2));
+ conversion::assign_to(a, fusion::make_tuple(b1,b2));
}