[Boost-commit] svn:boost r72324 - in sandbox/conversion/boost/conversion: . boost std

Subject: [Boost-commit] svn:boost r72324 - in sandbox/conversion/boost/conversion: . boost std
From: vicente.botet_at_[hidden]
Date: 2011-06-01 09:01:11

Author: viboes
Date: 2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
New Revision: 72324
URL: http://svn.boost.org/trac/boost/changeset/72324

Log:
Conversion: remove overload_workaround+make CP functors
Text files modified: 
   sandbox/conversion/boost/conversion/assign_to.hpp                                    |    60 +++++++++++++--------------             
   sandbox/conversion/boost/conversion/boost/array.hpp                                  |    12 ++---                                   
   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  |    12 ++--                                    
   sandbox/conversion/boost/conversion/boost/interval.hpp                               |    12 ++---                                   
   sandbox/conversion/boost/conversion/boost/optional.hpp                               |    11 ++--                                    
   sandbox/conversion/boost/conversion/boost/rational.hpp                               |    13 ++---                                   
   sandbox/conversion/boost/conversion/boost/tuple.hpp                                  |    10 +--                                     
   sandbox/conversion/boost/conversion/convert_to.hpp                                   |    24 +++++------                             
   sandbox/conversion/boost/conversion/convert_to_or_fallback.hpp                       |    39 ++++++++----------                      
   sandbox/conversion/boost/conversion/std/complex.hpp                                  |    10 +--                                     
   sandbox/conversion/boost/conversion/std/pair.hpp                                     |    15 +++---                                  
   sandbox/conversion/boost/conversion/std/string.hpp                                   |    23 ++++------                              
   sandbox/conversion/boost/conversion/std/vector.hpp                                   |    42 ++++++++++----------                    
   sandbox/conversion/boost/conversion/try_assign_to.hpp                                |    84 +++++++++++++++++++-------------------- 
   sandbox/conversion/boost/conversion/try_convert_to.hpp                               |    72 ++++++++++++++++-----------------       
   16 files changed, 213 insertions(+), 237 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-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -31,40 +31,38 @@
 
 namespace boost {
   namespace conversion {
-    namespace overload_workaround {
-      //! struct used when overloading can not be applied.
-      //! @tparam To target type of the conversion.
-      //! @tparam From source type of the conversion.
-      //! @tparam Enable A dummy parameter that can be used for SFINAE.
-      template < typename To, typename From, class Enable = void>
-      struct assign_to
+    //! struct used when overloading can not be applied.
+    //! @tparam To target type of the conversion.
+    //! @tparam From source type of the conversion.
+    //! @tparam Enable A dummy parameter that can be used for SFINAE.
+    template < typename To, typename From, class Enable = void>
+    struct assigner
+    {
+      //! @Effects  Converts the @c from parameter to  the @c to parameter, using by default the assignment operator.
+      //! @Throws  Whatever the underlying assignment operator of the @c To class throws.
+      To& operator()(To& to, const From& from)
       {
-        //! @Effects  Converts the @c from parameter to  the @c to parameter, using by default the assignment operator.
-        //! @Throws  Whatever the underlying assignment operator of the @c To class throws.
-        inline static To& apply(To& to, const From& from)
-        {
-          to = ::boost::conversion::convert_to<To>(from);
-          return to;
-        }
-      };
-
-      //! partial specialization for c-array types.
-      template < typename To, typename From, std::size_t N  >
-      struct assign_to<To[N],From[N],void>
+        to = ::boost::conversion::convert_to<To>(from);
+        return to;
+      }
+    };
+
+    //! partial specialization for c-array types.
+    template < typename To, typename From, std::size_t N  >
+    struct assigner<To[N],From[N],void>
+    {
+      //! @Effects  Converts the @c from parameter to the @c to parameter, using by default the assignment operator on each one of the array elements.
+      //! @Throws  Whatever the underlying assignment operator of the @c To class throws.
+      //! @Basic
+      To*& operator()(To(&to)[N], const From(& from)[N])
       {
-        //! @Effects  Converts the @c from parameter to the @c to parameter, using by default the assignment operator on each one of the array elements.
-        //! @Throws  Whatever the underlying assignment operator of the @c To class throws.
-        //! @Basic
-        inline static To*& apply(To(&to)[N], const From(& from)[N])
+        for (std::size_t i = 0; i < N; ++i)
         {
-          for (std::size_t i = 0; i < N; ++i)
-          {
-            to[i] = ::boost::conversion::convert_to<To>(from[i]);
-          }
-          return to;
+          to[i] = ::boost::conversion::convert_to<To>(from[i]);
         }
-      };
-    }
+        return to;
+      }
+    };
   }
 
 #if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
@@ -78,7 +76,7 @@
     template < typename To, typename From >
     To& assign_to(To& to, const From& from)
     {
-      return conversion::overload_workaround::assign_to<To,From>::apply(to, from);
+      return conversion::assigner<To,From>()(to, from);
     }
   }
 

Modified: sandbox/conversion/boost/conversion/boost/array.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/array.hpp	(original)
+++ sandbox/conversion/boost/conversion/boost/array.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -26,16 +26,15 @@
 namespace boost {
 
   namespace conversion {
-    namespace overload_workaround {
 
       /**
        * Partial specialization of @c convert_to for @c boost::array of the same size
        */
       template < typename T1, typename T2, std::size_t N>
-      struct convert_to< array<T1,N>, array<T2,N> >
+      struct converter< array<T1,N>, array<T2,N> >
       {
         //! @Returns the array having as elements the result of the conversion of each one of the source array elements.
-        inline static array<T1,N> apply(array<T2,N> const & from)
+        inline array<T1,N> operator()(array<T2,N> const & from)
         {
           array<T1,N> to;
           boost::conversion::assign_to(to, from);
@@ -46,10 +45,10 @@
        * Partial specialization of @c assign_to for @c boost::array of the same size
        */
       template < typename T1, typename T2, std::size_t N>
-      struct assign_to< array<T1,N>, array<T2,N> >
+      struct assigner< array<T1,N>, array<T2,N> >
       {
         //! @Effects assign to each one of the target array elements the conversion of the source array element.
-        inline static array<T1,N>& apply(array<T1,N>& to, array<T2,N> const & from)
+        array<T1,N>& operator()(array<T1,N>& to, array<T2,N> const & from)
         {
           for (unsigned int i =0; i<N; ++i)
           {
@@ -58,7 +57,6 @@
           return to;
         }
       };
-    }
   }
 
   #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -70,7 +68,7 @@
   inline array<T1,N>& assign_to(array<T1,N>& to, array<T2,N> const & from
   )
   {
-    return conversion::overload_workaround::assign_to<array<T1,N>, array<T2,N> >::apply(to, from);
+    return conversion::assigner<array<T1,N>, array<T2,N> >()(to, from);
   }
   #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	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -25,13 +25,12 @@
 
 namespace boost {
   namespace conversion {
-    namespace overload_workaround {
       //! @brief @c convert_to specialization for conversions from @c boost::chrono::duration<> to @c boost::posix_time::time_duration.
       //!
         template < class Rep, class Period>
-        struct convert_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
+        struct converter<posix_time::time_duration, chrono::duration<Rep, Period> > {
           //! @Returns the duration converted to seconds+nanoseconds following the boost::posix_time::time_duration formatting.
-            inline static posix_time::time_duration apply(chrono::duration<Rep, Period> const & from)
+            posix_time::time_duration operator()(chrono::duration<Rep, Period> const & from)
             {
                 typedef chrono::duration<Rep, Period> src_duration_t;
                 typedef chrono::nanoseconds duration_t;
@@ -51,14 +50,14 @@
         //!
 
         template < class Rep, class Period>
-        struct convert_to<chrono::duration<Rep, Period>, posix_time::time_duration> {
+        struct converter<chrono::duration<Rep, Period>, posix_time::time_duration> {
           //! @Returns the duration cast from a nanoseconds duration initialized to the total number of nanosecond of the @c from parameter.
-            inline static chrono::duration<Rep, Period> apply(posix_time::time_duration const & from)
+            chrono::duration<Rep, Period> operator()(posix_time::time_duration const & from)
             {
                 return  chrono::duration_cast<chrono::duration<Rep, Period> >(chrono::nanoseconds(from.total_nanoseconds()));
             }
         };
-    }
+
   }
 
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

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-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -26,10 +26,10 @@
 #include <boost/config.hpp>
 
 namespace boost {
-    namespace conversion { namespace overload_workaround {
+    namespace conversion {
         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)
+        struct converter<posix_time::ptime, chrono::time_point<Clock, Duration> > {
+            posix_time::ptime operator()(const chrono::time_point<Clock, Duration>& from)
             {
                 typedef chrono::time_point<Clock, Duration> time_point_t;
                 typedef chrono::nanoseconds duration_t;
@@ -48,8 +48,8 @@
         };
 
         template < class Clock, class Duration>
-        struct convert_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
-            inline static chrono::time_point<Clock, Duration> apply(const posix_time::ptime& from)
+        struct converter<chrono::time_point<Clock, Duration>, posix_time::ptime> {
+            chrono::time_point<Clock, Duration> operator()(const posix_time::ptime& from)
             {
                 posix_time::time_duration const time_since_epoch=from-posix_time::from_time_t(0);
                 chrono::time_point<Clock, Duration> t=chrono::system_clock::from_time_t(time_since_epoch.total_seconds());
@@ -57,7 +57,7 @@
                 return  t+chrono::duration_cast<Duration>(chrono::nanoseconds(nsec));
             }
         };
-    }}
+    }
 
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
     namespace chrono {

Modified: sandbox/conversion/boost/conversion/boost/interval.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/interval.hpp	(original)
+++ sandbox/conversion/boost/conversion/boost/interval.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -24,26 +24,24 @@
 namespace boost {
 
     namespace conversion {
-      namespace overload_workaround {
         //! @brief @c convert_to specialization for source and target been @c boost::numeric::interval.
         //!
         template < class T, class PT, class U, class PU>
-        struct convert_to< numeric::interval<T,PT>, numeric::interval<U,PU> > {
+        struct converter< numeric::interval<T,PT>, numeric::interval<U,PU> > {
           //! @Returns the target interval having as extremes the conversion from the source interval extremes.
-            inline static numeric::interval<T,PT> apply(numeric::interval<U,PU> const & from)
+            numeric::interval<T,PT> operator()(numeric::interval<U,PU> const & from)
             {
                 return numeric::interval<T,PT>(boost::conversion::convert_to<T>(from.lower()), boost::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)
+        struct assigner< numeric::interval<T,PT>, numeric::interval<U,PU> > {
+            numeric::interval<T,PT>& operator()(numeric::interval<T,PT>& to, const numeric::interval<U,PU>& from)
             {
                 to.assign(boost::conversion::convert_to<T>(from.lower()), boost::conversion::convert_to<U>(from.upper()));
                 return to;
             }
         };
-      }
     }
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
     namespace numeric {
@@ -51,7 +49,7 @@
         inline interval<T,PT>& assign_to(interval<T,PT>& to, const interval<U,PU>& from
         )
         {
-          return conversion::overload_workaround::assign_to<interval<T,PT>, interval<U,PU> >::apply(to, from);
+          return conversion::assigner<interval<T,PT>, interval<U,PU> >()(to, from);
         }
     }
 #endif

Modified: sandbox/conversion/boost/conversion/boost/optional.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/optional.hpp	(original)
+++ sandbox/conversion/boost/conversion/boost/optional.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -41,16 +41,15 @@
 #endif
 
   namespace conversion { 
-    namespace overload_workaround {
       /**
        * Partial specialization of @c convert_to for boost::optional
        */
       template < class Target, class Source>
-      struct convert_to< optional<Target>, optional<Source> >
+      struct converter< optional<Target>, optional<Source> >
       {
         //! @Returns If the optional source is initialized @c boost::optional<Target> initialized to the conversion of the optional value.
         //! Uninitialized  @c boost::optional<Target otherwise.
-        inline static optional<Target> apply(optional<Source> const & from)
+        optional<Target> operator()(optional<Source> const & from)
         {
           return (from?optional<Target>(boost::conversion::convert_to<Target>(from.get())):optional<Target>());
         }
@@ -60,12 +59,12 @@
       //!
       //! We can see this specialization as a try_convert_to function.
       template < class Target, class Source>
-      struct convert_to< optional<Target>, Source>
+      struct converter< optional<Target>, Source>
       {
         //! @Returns If the source is convertible to the target @c value_type
         //! @c Target initialized to the result of the conversion.
         //! Uninitialized  @c Target otherwise.
-        inline static optional<Target> apply(Source const & from)
+        optional<Target> operator()(Source const & from)
         {
           try
           {
@@ -78,7 +77,7 @@
         }
       };
 
-    }
+
   }
 
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

Modified: sandbox/conversion/boost/conversion/boost/rational.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/rational.hpp	(original)
+++ sandbox/conversion/boost/conversion/boost/rational.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -27,34 +27,33 @@
 namespace boost {
 
   namespace conversion {
-    namespace overload_workaround {
       //! @brief @c convert_to specialization for source and target been @c boost::rational.
       //!
       template < class T, class U>
-      struct convert_to< rational<T>, rational<U> > {
+      struct converter< rational<T>, rational<U> > {
         //! @Returns the target rational having as numerator and denominator the conversion from the numerator and denominator of the source rational.
-        inline static rational<T> apply(rational<U> const & from)
+        rational<T> operator()(rational<U> const & from)
         {
           return rational<T>(boost::conversion::convert_to<T>(from.numerator()), boost::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)
+      struct assigner< rational<T>, rational<U> >
+      {
+        rational<T>& operator()(rational<T>& to, const rational<U>& from)
         {
           to.assign(boost::conversion::convert_to<T>(from.numerator()), boost::conversion::convert_to<T>(from.denominator()));
           return to;
         }
       };
 
-    }
   }
 
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
     template < class T, class U>
     inline rational<T>& assign_to(rational<T>& to, const rational<U>& from)
     {
-      return conversion::overload_workaround::assign_to<rational<T>, rational<U> >::apply(to, from);
+      return conversion::assigner<rational<T>, rational<U> >()(to, from);
     }
 #endif
 

Modified: sandbox/conversion/boost/conversion/boost/tuple.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/tuple.hpp	(original)
+++ sandbox/conversion/boost/conversion/boost/tuple.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -24,10 +24,9 @@
 namespace boost {
 
   namespace conversion {
-    namespace overload_workaround {
         template < class T1, class T2, class U1, class U2>
-        struct convert_to< fusion::tuple<T1,T2>, fusion::tuple<U1,U2> > {
-            inline static fusion::tuple<T1,T2> apply(fusion::tuple<U1,U2> const & from)
+        struct converter< fusion::tuple<T1,T2>, fusion::tuple<U1,U2> > {
+            fusion::tuple<T1,T2> operator()(fusion::tuple<U1,U2> const & from)
             {
                 return fusion::tuple<T1,T2>(
                     boost::conversion::convert_to<T1>(fusion::get<0>(from))
@@ -36,8 +35,8 @@
             }
         };
         template < class T1, class T2, class T3, class U1, class U2, class U3>
-        struct convert_to< fusion::tuple<T1,T2,T3>, fusion::tuple<U1,U2,U3> > {
-            inline static fusion::tuple<T1,T2,T3> apply(fusion::tuple<U1,U2,U3> const & from)
+        struct converter< fusion::tuple<T1,T2,T3>, fusion::tuple<U1,U2,U3> > {
+            fusion::tuple<T1,T2,T3> operator()(fusion::tuple<U1,U2,U3> const & from)
             {
                 return fusion::tuple<T1,T2, T3>(
                       boost::conversion::convert_to<T1>(fusion::get<0>(from))
@@ -47,7 +46,6 @@
             }
         };
 
-    }
   }
 
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

Modified: sandbox/conversion/boost/conversion/convert_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/convert_to.hpp	(original)
+++ sandbox/conversion/boost/conversion/convert_to.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -58,23 +58,21 @@
     template <typename T, typename Enabled=void>
     struct enable_functor : mpl::false_ {};
 
-    namespace overload_workaround {
-      //! struct used when overloading of @c convert_to function can not be applied.
+      //! customization point for @convert_to.
 
       //! @tparam To target type of the conversion.
       //! @tparam From source type of the conversion.
       //! @tparam Enable A dummy parameter that can be used for SFINAE.
 
-      template < typename To, typename From, class Enable = void >
-      struct convert_to {
-        //! @Effects Converts the @c from parameter to an instance of the @c To type, using by default the conversion operator or copy constructor.
-        //! @Throws  Whatever the underlying conversion @c To operator of the @c From class or the copy constructor of the @c To class throws.
-        inline static To apply(const From& val)
-        {
-          return To((val));
-        }
-      };
-    }
+    template < typename To, typename From, class Enable = void >
+    struct converter {
+      //! @Effects Converts the @c from parameter to an instance of the @c To type, using by default the conversion operator or copy constructor.
+      //! @Throws  Whatever the underlying conversion @c To operator of the @c From class or the copy constructor of the @c To class throws.
+      To operator()(const From& val)
+      {
+        return To((val));
+      }
+    };
 #if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
     namespace impl_2 {
 
@@ -85,7 +83,7 @@
       //! Forwards the call to the overload workaround, which can yet be specialized by the user for standard C++ types.
       template < typename To, typename From >
       To convert_to(const From& from, dummy::type_tag<To> const&) {
-        return conversion::overload_workaround::convert_to<To,From>::apply(from);
+        return conversion::converter<To,From>()(from);
       }
     }
 

Modified: sandbox/conversion/boost/conversion/convert_to_or_fallback.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/convert_to_or_fallback.hpp	(original)
+++ sandbox/conversion/boost/conversion/convert_to_or_fallback.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -37,28 +37,25 @@
 
 namespace boost {
   namespace conversion {
-    namespace overload_workaround {
-      //! <c>struct convert_to_or_fallback</c> used when overloading can not be applied.
-      //! This struct can be specialized by the user.
-      template < typename To, typename From, typename Fallback>
-      struct convert_to_or_fallback {
-        //!
-        //! @Effects  Converts the @c from parameter to an instance of the @c To type, using by default the conversion operator or copy constructor.
-        //! @Returns the converted value if the conversion succeeds or the fallback.
-        //! @NoThrow
-        inline static To apply(const From& val, Fallback const& fallback)
+    //! This struct can be specialized by the user.
+    template < typename To, typename From, typename Fallback>
+    struct converter_or_fallbacker {
+      //!
+      //! @Effects  Converts the @c from parameter to an instance of the @c To type, using by default the conversion operator or copy constructor.
+      //! @Returns the converted value if the conversion succeeds or the fallback.
+      //! @NoThrow
+      To operator()(const From& val, Fallback const& fallback)
+      {
+        try
         {
-          try
-          {
-            return boost::conversion::convert_to<To>(val);
-          } 
-          catch (...) 
-          {
-            return To((fallback));
-          }
+          return boost::conversion::convert_to<To>(val);
         }
-      };
-    }
+        catch (...)
+        {
+          return To((fallback));
+        }
+      }
+    };
 
     #if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
     namespace impl_2 {
@@ -71,7 +68,7 @@
       //! Forwards the call to the overload workaround, which can yet be specialized by the user for standard C++ types.
       template < typename To, typename From, typename Fallback >
       To convert_to_or_fallback(const From& val, Fallback const& fallback, dummy::type_tag<To> const&) {
-        return conversion::overload_workaround::convert_to_or_fallback<To,From,Fallback>::apply(val, fallback);
+        return conversion::converter_or_fallbacker<To,From,Fallback>()(val, fallback);
       }
     }
 

Modified: sandbox/conversion/boost/conversion/std/complex.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/complex.hpp	(original)
+++ sandbox/conversion/boost/conversion/std/complex.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -25,13 +25,12 @@
   namespace conversion {
 
     // std namespace can not be overloaded
-    namespace overload_workaround {
       /**
        * Partial specialization of @c convert_to for @c std::complex of the same size
        */
       template < class T, class U>
-      struct convert_to< std::complex<T>, std::complex<U> > {
-        inline static std::complex<T> apply(std::complex<U> const & from)
+      struct converter< std::complex<T>, std::complex<U> > {
+        std::complex<T> operator()(std::complex<U> const & from)
         {
           return std::complex<T>(
               boost::conversion::convert_to<T>(from.real()),
@@ -39,8 +38,8 @@
         }
       };
       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)
+      struct assigner< std::complex<T>, std::complex<U> > {
+        std::complex<T>& operator()(std::complex<T>& to, const std::complex<U>& from)
         {
           to.real() = boost::conversion::convert_to<T>(from.real());
           to.imag() = boost::conversion::convert_to<T>(from.imag());
@@ -48,7 +47,6 @@
         }
       };
 
-    }
   }
 }
 

Modified: sandbox/conversion/boost/conversion/std/pair.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/pair.hpp	(original)
+++ sandbox/conversion/boost/conversion/std/pair.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -21,20 +21,21 @@
 //#include <boost/conversion/convert_to.hpp>
 #include <boost/conversion/assign_to.hpp>
 
-namespace boost { namespace conversion {
+namespace boost {
+  namespace conversion {
 
     // std namespace can not be overloaded
-    namespace overload_workaround {
         template < class T1, class T2, class U1, class U2>
-        struct convert_to< std::pair<T1,T2>, std::pair<U1,U2> > {
-            inline static std::pair<T1,T2> apply(std::pair<U1,U2> const & from)
+        struct converter< std::pair<T1,T2>, std::pair<U1,U2> > {
+            std::pair<T1,T2> operator()(std::pair<U1,U2> const & from)
             {
                 return std::pair<T1,T2>(boost::conversion::convert_to<T1>(from.first), boost::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)
+        struct assigner< std::pair<T1,T2>, std::pair<U1,U2> >
+        {
+            std::pair<T1,T2>& operator()(std::pair<T1,T2>& to, const std::pair<U1,U2>& from)
             {
                 to.first = boost::conversion::convert_to<T1>(from.first);
                 to.second = boost::conversion::convert_to<T2>(from.second);
@@ -42,7 +43,7 @@
             }
         };
     }
-}}
+}
 
 #endif
 

Modified: sandbox/conversion/boost/conversion/std/string.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/string.hpp	(original)
+++ sandbox/conversion/boost/conversion/std/string.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Vicente J. Botet Escriba 2009. Distributed under the Boost
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
 //
@@ -29,11 +29,10 @@
   namespace conversion {
 
     // std namespace can not be overloaded
-    namespace overload_workaround {
       
       template<typename T, typename CharT, typename Traits, typename Alloc>
-      struct convert_to< std::basic_string<CharT,Traits,Alloc>, T > {
-        inline static std::basic_string<CharT,Traits,Alloc> apply(T const & from)
+      struct converter< std::basic_string<CharT,Traits,Alloc>, T > {
+        std::basic_string<CharT,Traits,Alloc> operator()(T const & from)
         {
 #if !defined(BOOST_CONVERSION_USE_CONVERT)
           return lexical_cast<std::basic_string<CharT,Traits,Alloc> >(from);
@@ -43,8 +42,8 @@
         }
       };
       template<typename T, typename CharT, typename Traits, typename Alloc>
-      struct convert_to< T, std::basic_string<CharT,Traits,Alloc> > {
-        inline static T apply(std::basic_string<CharT,Traits,Alloc> const & from)
+      struct converter< T, std::basic_string<CharT,Traits,Alloc> > {
+        T operator()(std::basic_string<CharT,Traits,Alloc> const & from)
         {
 #if !defined(BOOST_CONVERSION_USE_CONVERT)
           return lexical_cast<T>(from);
@@ -55,18 +54,17 @@
       };
 
       template<typename T, typename CharT, typename Traits, typename Alloc>
-      struct assign_to< std::basic_string<CharT,Traits,Alloc>, T > {
-        inline static std::basic_string<CharT,Traits,Alloc>& 
-        apply(std::basic_string<CharT,Traits,Alloc>& to, const T& from)
+      struct assigner< std::basic_string<CharT,Traits,Alloc>, T > {
+        std::basic_string<CharT,Traits,Alloc>&
+        operator()(std::basic_string<CharT,Traits,Alloc>& to, const T& from)
         {
           to = boost::conversion::convert_to<std::basic_string<CharT,Traits,Alloc> >(from);
           return to;
         }
       };
       template<typename T, typename CharT, typename Traits, typename Alloc>
-      struct assign_to< T, std::basic_string<CharT,Traits,Alloc> > {
-        inline static T& 
-        apply(T& to, const std::basic_string<CharT,Traits,Alloc>& from)
+      struct assigner< T, std::basic_string<CharT,Traits,Alloc> > {
+        T& operator()(T& to, const std::basic_string<CharT,Traits,Alloc>& from)
         {
           to = boost::conversion::convert_to<T>(from);
           return to;
@@ -74,7 +72,6 @@
       };
 
       
-    }
   }
 }
 

Modified: sandbox/conversion/boost/conversion/std/vector.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/vector.hpp	(original)
+++ sandbox/conversion/boost/conversion/std/vector.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Vicente J. Botet Escriba 2009. Distributed under the Boost
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
 //
@@ -28,40 +28,27 @@
   namespace conversion {
 
     // std namespace can not be overloaded
-    namespace overload_workaround {
         template < class T1, class A1, class T2, class A2>
-        struct convert_to< std::vector<T1,A1>, std::vector<T2,A2> > {
-            inline static std::vector<T1,A1> apply(std::vector<T2,A2> const & from)
+        struct converter< std::vector<T1,A1>, std::vector<T2,A2> > {
+            std::vector<T1,A1> operator()(std::vector<T2,A2> const & from)
             {
                 std::vector<T1,A1> res;
                 boost::conversion::assign_to(res, from);
                 return res;
             }
         };
-        template < class T1, class A1, class T2, class A2>
-        struct assign_to< std::vector<T1,A1>, std::vector<T2,A2> > {
-            inline static std::vector<T1,A1>& apply(
-                std::vector<T1,A1>& to,
-                std::vector<T2,A2> const & from)
-            {
-                to.resize(from.size());
-                for (unsigned int i=0; i<from.size(); ++i) {
-                    boost::conversion::assign_to(to[i], from[i]);
-                }
-                return to;
-            }
-        };
 
         template < class T1, class A1, class T2, class A2>
-        struct convert_to< std::vector<T1,A1>,
+        struct converter< std::vector<T1,A1>,
                 //~ typename boost::conversion::result_of::pack2<std::vector<T2,A2> const, A1 const>::type
                 //~ boost::fusion::tuple<
                 std::pair<
                     boost::reference_wrapper<std::vector<T2,A2> const>,
                     boost::reference_wrapper<A1 const>
                 >
-            > {
-            inline static std::vector<T1,A1> apply(
+            >
+        {
+            std::vector<T1,A1> operator()(
                 typename boost::conversion::result_of::pack2<std::vector<T2,A2> const, A1 const>::type
                 const & pack)
             {
@@ -73,8 +60,21 @@
             }
         };
 
+        template < class T1, class A1, class T2, class A2>
+        struct assigner< std::vector<T1,A1>, std::vector<T2,A2> > {
+            std::vector<T1,A1>& operator()(
+                std::vector<T1,A1>& to,
+                std::vector<T2,A2> const & from)
+            {
+                to.resize(from.size());
+                for (unsigned int i=0; i<from.size(); ++i) {
+                    boost::conversion::assign_to(to[i], from[i]);
+                }
+                return to;
+            }
+        };
     }
-}}
+}
 
 #endif
 

Modified: sandbox/conversion/boost/conversion/try_assign_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/try_assign_to.hpp	(original)
+++ sandbox/conversion/boost/conversion/try_assign_to.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -37,56 +37,54 @@
 
 namespace boost {
   namespace conversion {
-    namespace overload_workaround {
-      //! <c>struct try_assign_to</c> used when overloading can not be applied.
-      //! This struct can be specialized by the user.
-      template < typename To, typename From >
-      struct try_assign_to
+    //! This struct can be specialized by the user.
+    template < typename To, typename From >
+    struct try_assigner
+    {
+      //! @Effects  Converts the @c from parameter to  the @c to parameter, using by default the assignment operator.
+      //! @NoThrow
+      //! @Returns the converted value if success or the fallback when conversion fails.
+      bool operator()(To& to, const From& from)
       {
-        //! @Effects  Converts the @c from parameter to  the @c to parameter, using by default the assignment operator.
-        //! @NoThrow
-        //! @Returns the converted value if success or the fallback when conversion fails.
-        inline static bool apply(To& to, const From& from)
+        To rollback = to;
+        try
         {
-          To rollback = to;
-          try 
-          {
-            boost::conversion::assign_to<To>(to , from);
-            return true;
-          } 
-          catch (...)
-          {
-            to = rollback; 
-            return false;
-          }
+          boost::conversion::assign_to<To>(to , from);
+          return true;
+        }
+        catch (...)
+        {
+          to = rollback;
+          return false;
         }
-      };
-      template < typename To, typename From, std::size_t N  >
-      struct try_assign_to<To[N],From[N]>
+      }
+    };
+    template < typename To, typename From, std::size_t N  >
+    struct try_assigner<To[N],From[N]>
+    {
+      //! @Effects  Converts the @c from parameter to  the @c to parameter, using by default the assignment operator on each vector element.
+      //! @NoThrow
+      //! @Returns the converted value if success or the fallback when conversion fails.
+      bool operator()(To(&to)[N], const From(& from)[N])
       {
-        //! @Effects  Converts the @c from parameter to  the @c to parameter, using by default the assignment operator on each vector element.
-        //! @NoThrow
-        //! @Returns the converted value if success or the fallback when conversion fails.
-        inline static bool apply(To(&to)[N], const From(& from)[N])
+        To rollback[N];
+        boost::conversion::assign_to<To>(rollback, to);
+        try
         {
-          To rollback[N];
-          boost::conversion::assign_to<To>(rollback, to);
-          try 
-          {
-            for (std::size_t i = 0; i < N; ++i)
-            {
-              boost::conversion::assign_to<To>(to[i] , from[i]);
-            }
-            return true;
-          } 
-          catch (...)
+          for (std::size_t i = 0; i < N; ++i)
           {
-            boost::conversion::assign_to<To>(to, rollback);
-            return false;
+            boost::conversion::assign_to<To>(to[i] , from[i]);
           }
+          return true;
         }
-      };
-    }
+        catch (...)
+        {
+          boost::conversion::assign_to<To>(to, rollback);
+          return false;
+        }
+      }
+    };
+
   }
 
 #if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
@@ -100,7 +98,7 @@
     template < typename To, typename From >
     bool try_assign_to(To& to, const From& from)
     {
-      return conversion::overload_workaround::try_assign_to<To,From>::apply(to, from);
+      return conversion::try_assigner<To,From>()(to, from);
     }
   }
 

Modified: sandbox/conversion/boost/conversion/try_convert_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/try_convert_to.hpp	(original)
+++ sandbox/conversion/boost/conversion/try_convert_to.hpp	2011-06-01 09:01:09 EDT (Wed, 01 Jun 2011)
@@ -38,50 +38,48 @@
 
 namespace boost {
   namespace conversion {
-    namespace overload_workaround {
-      //! <c>struct try_convert_to</c> used when overloading can not be applied.
-      //! This struct can be specialized by the user.
-      template < typename To, typename From >
-      struct try_convert_to {
-        //! @Effects  Converts the @c from parameter to an instance of the @c To type, using by default the conversion operator or copy constructor.
-        //! @NoThrow
-        //! @Returns A optional<Ratget> uninitialized when conversion fails.
-        inline static optional<To> apply(const From& val)
+    //! This struct can be specialized by the user.
+    template < typename To, typename From >
+    struct try_converter {
+      //! @Effects  Converts the @c from parameter to an instance of the @c To type, using by default the conversion operator or copy constructor.
+      //! @NoThrow
+      //! @Returns A optional<Ratget> uninitialized when conversion fails.
+      optional<To> operator()(const From& val)
+      {
+        try
         {
-          try 
-          {
-            return make_optional(boost::conversion::convert_to<To>(val));
-          } 
-          catch (...)
-          {
-            return optional<To>();
-          }
+          return make_optional(boost::conversion::convert_to<To>(val));
         }
-      };
-    }
+        catch (...)
+        {
+          return optional<To>();
+        }
+      }
+    };
+
 
 #if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
-  namespace impl_2 {
+    namespace impl_2 {
 
-    //! @brief Default @c try_convert_to overload, used when ADL fails.
-    //!
-    //! @Effects  Converts the @c from parameter to an instance of the @c To type, using by default the conversion operator or copy constructor.
-    //! @NoThrow
-    //! @Returns A optional<Target> uninitialized when conversion fails.
-    //! Forwards the call to the overload workaround, which can yet be specialized by the user for standard C++ types.
-    template < typename To, typename From >
-    optional<To> try_convert_to(const From& val, dummy::type_tag<To> const&) {
-      return conversion::overload_workaround::try_convert_to<To,From>::apply(val);
+      //! @brief Default @c try_convert_to overload, used when ADL fails.
+      //!
+      //! @Effects  Converts the @c from parameter to an instance of the @c To type, using by default the conversion operator or copy constructor.
+      //! @NoThrow
+      //! @Returns A optional<Target> uninitialized when conversion fails.
+      //! Forwards the call to the overload workaround, which can yet be specialized by the user for standard C++ types.
+      template < typename To, typename From >
+      optional<To> try_convert_to(const From& val, dummy::type_tag<To> const&) {
+        return conversion::try_converter<To,From>()(val);
+      }
     }
-  }
-  namespace impl {
-    template <typename Target, typename Source>
-    optional<Target> try_convert_to_impl(Source const& from) {
-      using namespace boost::conversion::impl_2;
-      //use boost::conversion::try_convert_to if ADL fails
-      return try_convert_to(from, dummy::type_tag<Target>());
+    namespace impl {
+      template <typename Target, typename Source>
+      optional<Target> try_convert_to_impl(Source const& from) {
+        using namespace boost::conversion::impl_2;
+        //use boost::conversion::try_convert_to if ADL fails
+        return try_convert_to(from, dummy::type_tag<Target>());
+      }
     }
-  }
 #endif