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

Subject: [Boost-commit] svn:boost r63065 - in sandbox/chrono/boost/conversion: . boost std
From: vicente.botet_at_[hidden]
Date: 2010-06-17 17:11:21

Author: viboes
Date: 2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
New Revision: 63065
URL: http://svn.boost.org/trac/boost/changeset/63065

Log:
Add Conversion lib on Chrono
Added:
   sandbox/chrono/boost/conversion/
   sandbox/chrono/boost/conversion/assign_to.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/boost/
   sandbox/chrono/boost/conversion/boost/array.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/boost/chrono_posix_time.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/boost/interval.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/boost/optional.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/boost/rational.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/boost/tuple.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/ca_wrapper.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/convert_to.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/convert_to_via.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/pack.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/std/
   sandbox/chrono/boost/conversion/std/complex.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/std/pair.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/std/string.hpp   (contents, props changed)
   sandbox/chrono/boost/conversion/std/vector.hpp   (contents, props changed)

Added: sandbox/chrono/boost/conversion/assign_to.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/assign_to.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,65 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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>
+
+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::convert_to<To>(from[i]);
+                    }
+                    return to;
+                }
+            };
+        }
+
+        template < typename To, typename From >
+        To& assign_to(To& to, const From& from, dummy::type_tag<To> const&) {
+            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;
+            //use boost::conversion::assign_to if ADL fails
+            return assign_to(to, from, boost::dummy::type_tag<Target>());
+        }
+    }
+
+    template <typename Target, typename Source>
+    Target& assign_to(Target& to, const Source& from, boost::dummy::base_tag<Target> const& p=boost::dummy::base_tag<Target>()) {
+        return conversion_impl::assign_to_impl<Target, Source>(to, from);
+    }
+}
+
+
+
+#endif
+

Added: sandbox/chrono/boost/conversion/boost/array.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/boost/array.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,69 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONVERT_TO_ARRAY__HPP
+#define BOOST_CONVERT_TO_ARRAY__HPP
+
+#include <boost/array.hpp>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <algorithm>
+#include <boost/config.hpp>
+
+namespace boost {
+
+    #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    namespace conversion { namespace partial_specialization_workaround {
+        template < typename T1, typename T2, std::size_t N>
+        struct convert_to< array<T1,N>, array<T2,N> > {
+            inline static array<T1,N> apply(array<T2,N> const & from)
+            {
+                array<T1,N> to;
+                boost::assign_to(to, from);
+                return to;
+            }
+        };
+        template < typename T1, typename T2, std::size_t N>
+        struct assign_to< array<T1,N>, array<T2,N> > {
+            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]);
+                }
+                return to;
+            }
+        };
+    }}
+    #else
+    template < typename T1, typename T2, std::size_t N>
+    inline array<T1,N> convert_to(array<T2,N> const & from
+                        , boost::dummy::type_tag<array<T1,N> > const&
+    )
+    {
+        array<T1,N> to;
+        boost::assign_to(to, from);
+        return to;
+    }
+
+    template < typename T1, typename T2, std::size_t N>
+    inline array<T1,N>& assign_to(array<T1,N>& to, array<T2,N> const & from
+    , boost::dummy::type_tag<array<T1,N> > const&
+    )
+    {
+        for (unsigned int i =0; i<N; ++i) {
+            to[i]=boost::convert_to<T1>(from[i]);
+        }
+        return to;
+    }
+    #endif
+}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,118 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONVERT_TO_CHRONO_DURATION_TO_POSIX_TIME_DURATION__HPP
+#define BOOST_CONVERT_TO_CHRONO_DURATION_TO_POSIX_TIME_DURATION__HPP
+
+#include <boost/chrono/chrono.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/config.hpp>
+
+namespace boost {
+    #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    namespace conversion { namespace partial_specialization_workaround {
+        template < class Rep, class Period>
+        struct convert_to<posix_time::time_duration, chrono::duration<Rep, Period> > {
+            inline static posix_time::time_duration apply(chrono::duration<Rep, Period> const & from)
+            {
+                typedef chrono::duration<Rep, Period> src_duration_t;
+                typedef chrono::nanoseconds duration_t;
+                typedef duration_t::rep rep_t;
+                rep_t d = chrono::duration_cast<duration_t>(from).count();
+                rep_t sec = d/1000000000;
+                rep_t nsec = d%1000000000;
+                return  posix_time::seconds(static_cast<long>(sec))+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+                        posix_time::nanoseconds(nsec);
+#else
+                        posix_time::microseconds((nsec+500)/1000);
+#endif
+            }
+        };
+        template < class Rep, class Period>
+        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);
+                return to;
+            }
+        };
+
+        template < class Rep, class Period>
+        struct convert_to<chrono::duration<Rep, Period>, posix_time::time_duration> {
+            inline static chrono::duration<Rep, Period> apply(posix_time::time_duration const & from)
+            {
+                return  chrono::duration_cast<chrono::duration<Rep, Period> >(chrono::nanoseconds(from.total_nanoseconds()));
+            }
+        };
+        template < class Rep, class Period>
+        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);
+                return to;
+            }
+        };
+    }}
+    #else
+    namespace chrono {
+        template < class Rep, class Period>
+        inline posix_time::time_duration convert_to(chrono::duration<Rep, Period> const & from
+                        , boost::dummy::type_tag<posix_time::time_duration> const&)
+        {
+            typedef duration<Rep, Period> src_duration_t;
+            typedef nanoseconds duration_t;
+            typedef duration_t::rep rep_t;
+            rep_t d = chrono::duration_cast<duration_t>(from).count();
+            rep_t sec = d/1000000000;
+            rep_t nsec = d%1000000000;
+            return  posix_time::seconds(static_cast<long>(sec))+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+                    posix_time::nanoseconds(nsec);
+#else
+                    posix_time::microseconds((nsec+500)/1000);
+#endif
+        }
+
+        template < class Rep, class Period>
+        inline chrono::duration<Rep, Period> & assign_to(chrono::duration<Rep, Period> & to, const posix_time::time_duration& from
+                            , boost::dummy::type_tag<chrono::duration<Rep, Period> > const&
+        )
+
+        {
+            to = boost::convert_to<duration<Rep, Period> >(from);
+            return to;
+        }
+    }
+
+    namespace posix_time {
+        template < class Rep, class Period>
+        inline chrono::duration<Rep, Period> convert_to(time_duration const & from
+                            , boost::dummy::type_tag<chrono::duration<Rep, Period> > const&)
+        {
+            return  chrono::duration_cast<chrono::duration<Rep, Period> >(chrono::nanoseconds(from.total_nanoseconds()));
+        }
+
+        template < class Rep, class Period>
+        inline time_duration& assign_to(time_duration& to, const chrono::duration<Rep, Period>& from
+                        , boost::dummy::type_tag<posix_time::time_duration> const&
+        )
+        {
+            to = boost::convert_to<time_duration>(from);
+            return to;
+        }
+    }
+    #endif
+}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/boost/chrono_posix_time.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/boost/chrono_posix_time.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,18 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONVERT_TO_CHRONO_POSIX_TIME__HPP
+#define BOOST_CONVERT_TO_CHRONO_POSIX_TIME__HPP
+
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+
+#endif
+

Added: sandbox/chrono/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,130 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//[CHRONO_TIME_POINT_TO_POSIX_TIME_PTIME__HPP
+#ifndef BOOST_CONVERT_TO_CHRONO_TIME_POINT_TO_POSIX_TIME_PTIME__HPP
+#define BOOST_CONVERT_TO_CHRONO_TIME_POINT_TO_POSIX_TIME_PTIME__HPP
+
+#include <boost/chrono/chrono.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/date_time/posix_time/conversion.hpp>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/config.hpp>
+
+namespace boost {
+    #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    namespace conversion { namespace partial_specialization_workaround {
+        template < class Clock, class Duration>
+        struct convert_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
+            inline static posix_time::ptime apply(const chrono::time_point<Clock, Duration>& from)
+            {
+                typedef chrono::time_point<Clock, Duration> time_point_t;
+                typedef chrono::nanoseconds duration_t;
+                typedef duration_t::rep rep_t;
+                rep_t d = chrono::duration_cast<duration_t>(from.time_since_epoch()).count();
+                rep_t sec = d/1000000000;
+                rep_t nsec = d%1000000000;
+                return  posix_time::from_time_t(0)+
+                        posix_time::seconds(static_cast<long>(sec))+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+                        posix_time::nanoseconds(nsec);
+#else
+                        posix_time::microseconds((nsec+500)/1000);
+#endif
+            }
+        };
+        template < class Clock, class Duration>
+        struct assign_to<posix_time::ptime, chrono::time_point<Clock, Duration> > {
+            inline static posix_time::ptime& apply(posix_time::ptime& to, const chrono::time_point<Clock, Duration>& from)
+            {
+                to = boost::convert_to<posix_time::ptime>(from);
+                return to;
+            }
+        };
+
+        template < class Clock, class Duration>
+        struct convert_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
+            inline static chrono::time_point<Clock, Duration> apply(const posix_time::ptime& from)
+            {
+                posix_time::time_duration const time_since_epoch=from-posix_time::from_time_t(0);
+                chrono::time_point<Clock, Duration> t=chrono::system_clock::from_time_t(time_since_epoch.total_seconds());
+                long nsec=time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second());
+                return  t+chrono::nanoseconds(nsec);
+
+            }
+        };
+        template < class Clock, class Duration>
+        struct assign_to<chrono::time_point<Clock, Duration>, posix_time::ptime> {
+            inline static chrono::time_point<Clock, Duration>& apply(chrono::time_point<Clock, Duration>& to, const posix_time::ptime& from)
+            {
+                to = boost::convert_to<chrono::time_point<Clock, Duration> >(from);
+                return to;
+            }
+        };
+    }}
+    #else
+    namespace chrono {
+        template < class Clock, class Duration>
+        inline posix_time::ptime convert_to(const chrono::time_point<Clock, Duration>& from
+                    , boost::dummy::type_tag<posix_time::ptime> const&)
+        {
+                typedef chrono::time_point<Clock, Duration> time_point_t;
+                typedef chrono::nanoseconds duration_t;
+                typedef duration_t::rep rep_t;
+                rep_t d = chrono::duration_cast<duration_t>(from.time_since_epoch()).count();
+                rep_t sec = d/1000000000;
+                rep_t nsec = d%1000000000;
+                return  posix_time::from_time_t(0)+
+                        posix_time::seconds(static_cast<long>(sec))+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+                        posix_time::nanoseconds(nsec);
+#else
+                        posix_time::microseconds((nsec+500)/1000);
+#endif
+        }
+
+
+        template < class Clock, class Duration>
+        inline chrono::time_point<Clock, Duration>& assign_to(chrono::time_point<Clock, Duration>& to, const posix_time::ptime& from
+                        , boost::dummy::type_tag<chrono::time_point<Clock, Duration> > const&
+        )
+        {
+            to = boost::convert_to<chrono::time_point<Clock, Duration> >(from);
+            return to;
+        }
+
+    }
+    namespace posix_time {
+        template < class Clock, class Duration>
+        inline chrono::time_point<Clock, Duration> convert_to(const ptime& from
+                , boost::dummy::type_tag<chrono::time_point<Clock, Duration> > const&)
+        {
+            time_duration const time_since_epoch=from-from_time_t(0);
+            chrono::time_point<Clock, Duration> t=chrono::system_clock::from_time_t(time_since_epoch.total_seconds());
+            long nsec=time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second());
+            return  t+chrono::nanoseconds(nsec);
+        }
+
+        template < class Clock, class Duration>
+        inline ptime& assign_to(ptime& to, const chrono::time_point<Clock, Duration>& from
+                    , boost::dummy::type_tag<posix_time::ptime> const&
+        )
+        {
+            to = boost::convert_to<ptime>(from);
+            return to;
+        }
+
+    }
+    #endif
+}
+
+#endif
+//]

Added: sandbox/chrono/boost/conversion/boost/interval.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/boost/interval.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,60 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONVERT_TO_INTERVAL__HPP
+#define BOOST_CONVERT_TO_INTERVAL__HPP
+
+#include <boost/numeric/interval.hpp>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+
+namespace boost {
+
+    #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    namespace conversion { namespace partial_specialization_workaround {
+        template < class T, class PT, class U, class PU>
+        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()));
+            }
+        };
+        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()));
+                return to;
+            }
+        };
+
+    }}
+    #else
+    namespace numeric {
+        template < class T, class PT, class U, class PU>
+        inline interval<T,PT> convert_to(interval<U,PU> const & from
+                        , boost::dummy::type_tag<interval<T,PT> > const&)
+        {
+            return interval<T,PT>(boost::convert_to<T>(from.lower()), boost::convert_to<U>(from.upper()));
+        }
+        template < class T, class PT, class U, class PU>
+        inline interval<T,PT>& assign_to(interval<T,PT>& to, const interval<U,PU>& from
+                        , boost::dummy::type_tag<interval<T,PT> > const&
+                    )
+        {
+            to.assign(boost::convert_to<T>(from.lower()),boost::convert_to<U>(from.upper()));
+            return to;
+        }
+    }
+    #endif
+}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/boost/optional.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/boost/optional.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,63 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//[OPTIONAL__HPP
+#ifndef BOOST_CONVERT_TO_OPTIONAL__HPP
+#define BOOST_CONVERT_TO_OPTIONAL__HPP
+
+#include <boost/optional.hpp>
+#include <boost/none.hpp>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/config.hpp>
+
+namespace boost {
+
+    #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    namespace conversion { namespace partial_specialization_workaround {
+        template < class Target, class Source>
+        struct convert_to< optional<Target>, optional<Source> > {
+            inline static optional<Target> apply(optional<Source> const & from)
+            {
+                return (from?optional<Target>(boost::convert_to<Target>(from.get())):optional<Target>());
+            }
+        };
+        template < class Target, class Source>
+        struct assign_to< optional<Target>, optional<Source> > {
+            inline static optional<Target>& apply(optional<Target>& to, const optional<Source>& from)
+            {
+                to = from?boost::convert_to<Target>(from.get()):optional<Target>();
+                return to;
+            }
+        };
+
+    }}
+    #else
+    template < class Target, class Source>
+    inline optional<Target> convert_to(optional<Source> const & from
+                , boost::dummy::type_tag<optional<Target> > const&)
+    {
+        return (from?optional<Target>(boost::convert_to<Target>(from.get())):optional<Target>());
+    }
+
+    template < class Target, class Source>
+    inline optional<Target>& assign_to(optional<Target>& to, const optional<Source>& from
+                , boost::dummy::type_tag<optional<Target> > const&
+                )
+    {
+        to = from?boost::convert_to<Target>(from.get()):optional<Target>();
+        return to;
+    }
+    #endif
+}
+
+#endif
+
+//]

Added: sandbox/chrono/boost/conversion/boost/rational.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/boost/rational.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,62 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONVERT_TO_PAIR__HPP
+#define BOOST_CONVERT_TO_PAIR__HPP
+
+#include <boost/rational.hpp>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/config.hpp>
+
+namespace boost {
+
+    #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    namespace conversion { namespace partial_specialization_workaround {
+        template < class T, class U>
+        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()));
+            }
+        };
+        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()));
+                return to;
+            }
+        };
+
+    }}
+    #else
+    template < class T, class U>
+    inline rational<T> convert_to(rational<U> const & from
+                        , boost::dummy::type_tag<rational<T> > const&)
+    {
+        return rational<T>(boost::convert_to<T>(from.numerator()), boost::convert_to<T>(from.denominator()));
+    }
+
+    template < class T, class U>
+    inline rational<T>& assign_to(rational<T>& to, const rational<U>& from
+                        , boost::dummy::type_tag<rational<T> > const&
+    )
+    {
+        to.assign(boost::convert_to<T>(from.numerator()), boost::convert_to<T>(from.denominator()));
+        return to;
+    }
+    #endif
+
+
+}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/boost/tuple.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/boost/tuple.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,108 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONVERT_TO_PAIR__HPP
+#define BOOST_CONVERT_TO_PAIR__HPP
+
+#include <boost/fusion/tuple.hpp>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/config.hpp>
+
+namespace boost {
+
+    #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    namespace conversion { namespace partial_specialization_workaround {
+        template < class 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)
+            {
+                return fusion::tuple<T1,T2>(
+                    boost::convert_to<T1>(fusion::get<0>(from))
+                    , boost::convert_to<T2>(fusion::get<1>(from))
+                );
+            }
+        };
+        template < class T1, class T2, class U1, class U2>
+        struct assign_to< fusion::tuple<T1,T2>, fusion::tuple<U1,U2> > {
+            inline static fusion::tuple<T1,T2>& apply(fusion::tuple<T1,T2>& to, fusion::tuple<U1,U2> const & from)
+            {
+                to = boost::convert_to<fusion::tuple<T1,T2> >(from);
+                return to;
+            }
+        };
+        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)
+            {
+                return fusion::tuple<T1,T2, T3>(
+                      boost::convert_to<T1>(fusion::get<0>(from))
+                    , boost::convert_to<T2>(fusion::get<1>(from))
+                    , boost::convert_to<T3>(fusion::get<2>(from))
+                );
+            }
+        };
+        template < class T1, class T2, class T3, class U1, class U2, class U3>
+        struct assign_to< fusion::tuple<T1,T2,T3>, fusion::tuple<U1,U2,U3> > {
+            inline static fusion::tuple<T1,T2,T3> apply(fusion::tuple<T1,T2,T3>& to, fusion::tuple<U1,U2,U3> const & from)
+            {
+                to = boost::convert_to<fusion::tuple<T1,T2> >(from);
+                return to;
+            }
+        };
+
+    }}
+    #else
+    namespace fusion {
+    template < class T1, class T2, class U1, class U2>
+    inline tuple<T1,T2> convert_to(tuple<U1,U2> const & from
+                    , boost::dummy::type_tag<tuple<T1,T2> > const&)
+    {
+        return tuple<T1,T2>(
+            boost::convert_to<T1>(boost::fusion::get<0>(from))
+            , boost::convert_to<T2>(boost::fusion::get<1>(from))
+        );
+    }
+
+    template < class T1, class T2, class U1, class U2>
+    inline tuple<T1,T2>& assign_to(tuple<T1,T2>& to, tuple<U1,U2> const & from
+                    , boost::dummy::type_tag<tuple<T1,T2> > const&
+    )
+    {
+        to = boost::convert_to<boost::fusion::tuple<T1,T2> >(from);
+        return to;
+    }
+
+    template < class T1, class T2, class T3, class U1, class U2, class U3>
+    inline tuple<T1,T2,T3> convert_to(tuple<U1,U2,U3> const & from
+                    , boost::dummy::type_tag<tuple<T1,T2,T3> > const&
+    )
+    {
+        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))
+        );
+    }
+
+    template < class T1, class T2, class T3, class U1, class U2, class U3>
+    inline tuple<T1,T2,T3> assign_to(tuple<T1,T2,T3>& to, boost::fusion::tuple<U1,U2,U3> const & from
+                    , boost::dummy::type_tag<tuple<T1,T2,T3> > const&
+    )
+    {
+        to = boost::convert_to<boost::fusion::tuple<T1,T2> >(from);
+        return to;
+    }
+    }
+    #endif
+}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/ca_wrapper.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/ca_wrapper.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,43 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CA_WRAPPER__HPP
+#define BOOST_CA_WRAPPER__HPP
+
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+
+namespace boost {
+    namespace conversion {
+
+        template <typename T>
+        class ca_wrapper {
+            T& ref_;
+        public:
+            ca_wrapper(T& r) : ref_(r) {}
+            template <typename U>
+            operator U() {
+                return boost::convert_to<U>(ref_);
+            }
+            template <typename U>
+            T& operator =(U const& u) {
+                return boost::assign_to(ref_, u);
+            }
+        };
+    }
+    template <typename T>
+    conversion::ca_wrapper<T> mca(T& r) {
+        return conversion::ca_wrapper<T>(r);
+    }
+
+}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/convert_to.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/convert_to.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,53 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONVERT_TO__HPP
+#define BOOST_CONVERT_TO__HPP
+
+#include <cstddef> //for std::size_t
+
+namespace boost {
+    namespace dummy {
+        template <typename T> struct base_tag {};
+        template <typename T> struct type_tag : public base_tag<T> {};
+    }
+    namespace conversion {
+        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, dummy::type_tag<To> const&) {
+            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;
+                //use boost::conversion::convert_to if ADL fails
+                return convert_to(from, boost::dummy::type_tag<Target>());
+            }
+    }
+    template <typename Target, typename Source>
+    Target convert_to(Source const& from, boost::dummy::base_tag<Target> const& p=boost::dummy::base_tag<Target>()) {
+        return conversion_impl::convert_to_impl<Target>(from);
+    }
+
+}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/convert_to_via.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/convert_to_via.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,25 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONVERT_TO_VIA__HPP
+#define BOOST_CONVERT_TO_VIA__HPP
+
+#include <boost/conversion/convert_to.hpp>
+
+namespace boost { namespace conversion {
+
+    template < typename To, typename Via, typename From >
+    To convert_to_via(const From& val) {
+        boost::convert_to<To>(boost::convert_to<Via>(val));
+    }
+}}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/pack.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/pack.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,82 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_PACK__HPP
+#define BOOST_CONVERSION_PACK__HPP
+
+#include <boost/ref.hpp>
+#include <boost/fusion/adapted/std_pair.hpp>
+#include <boost/fusion/tuple.hpp>
+#include <boost/fusion/include/at_c.hpp>
+
+namespace boost { namespace conversion {
+    
+
+namespace result_of {
+    template <typename T1, typename T2> struct pack2 {
+        typedef 
+        std::pair<
+        //~ fusion::tuple<
+          boost::reference_wrapper<T1>
+        , boost::reference_wrapper<T2>
+        > type;
+    };
+    template <typename T1, typename T2, typename T3=fusion::void_> struct pack3 {
+        typedef fusion::tuple<
+            boost::reference_wrapper<T1>
+        , boost::reference_wrapper<T2>
+        , boost::reference_wrapper<T3>
+        > type;
+    };
+}
+    
+template <typename T1, typename T2>
+typename boost::conversion::result_of::pack2<T1 const, T2 const>::type pack(
+        T1 const& t1, T2 const& t2) {
+        return std::make_pair
+        //~ return boost::fusion::make_tuple
+            (boost::cref(t1), boost::cref(t2));
+}
+
+template <typename T1, typename T2>
+typename boost::conversion::result_of::pack2<T1 const, T2>::type pack(T1 const& t1, T2 & t2) {
+        return std::make_pair
+        //~ return boost::fusion::make_tuple
+            (boost::cref(t1), boost::ref(t2));
+}
+
+template <typename T1, typename T2, typename T3>
+typename boost::conversion::result_of::pack3<T1 const, T2 const, T3 const>::type pack(
+        T1 const& t1, T2 const& t2, T3 const& t3) {
+        return fusion::make_tuple(boost::cref(t1), boost::cref(t2), boost::cref(t3));
+}
+
+template <typename T1, typename T2, typename T3>
+typename boost::conversion::result_of::pack3<T1 const, T2 const, T3>::type pack(
+        T1 const& t1, T2 const& t2, T3 & t3) {
+        return fusion::make_tuple(boost::cref(t1), boost::cref(t2), boost::ref(t3));
+}
+
+template <typename T1, typename T2, typename T3>
+typename boost::conversion::result_of::pack3<T1 const, T2, T3 const>::type pack(
+        T1 const& t1, T2 & t2, T3 const& t3) {
+        return fusion::make_tuple(boost::cref(t1), boost::ref(t2), boost::cref(t3));
+}
+
+template <typename T1, typename T2, typename T3>
+typename boost::conversion::result_of::pack3<T1 const, T2, T3>::type pack(
+        T1 const& t1, T2 & t2, T3 & t3) {
+        return fusion::make_tuple(boost::cref(t1), boost::ref(t2), boost::ref(t3));
+}
+
+}}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/std/complex.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/std/complex.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,44 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONVERT_TO_COMPLEX__HPP
+#define BOOST_CONVERT_TO_COMPLEX__HPP
+
+#include <complex>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+
+namespace boost {
+namespace conversion {
+
+    // std namespace can not be overloaded
+    namespace partial_specialization_workaround {
+        template < class T, class U>
+        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()));
+            }
+        };
+        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());
+                return to;
+            }
+        };
+
+    }
+}}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/std/pair.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/std/pair.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,44 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//[PAIR__HPP
+#ifndef BOOST_CONVERT_TO_PAIR__HPP
+#define BOOST_CONVERT_TO_PAIR__HPP
+
+#include <utility>
+//#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+
+namespace boost { namespace conversion {
+
+    // std namespace can not be overloaded
+    namespace partial_specialization_workaround {
+        template < class T1, class T2, class U1, class U2>
+        struct convert_to< std::pair<T1,T2>, std::pair<U1,U2> > {
+            inline static std::pair<T1,T2> apply(std::pair<U1,U2> const & from)
+            {
+                return std::pair<T1,T2>(boost::convert_to<T1>(from.first), boost::convert_to<T2>(from.second));
+            }
+        };
+        template < class T1, class T2, class U1, class U2>
+        struct assign_to< std::pair<T1,T2>, std::pair<U1,U2> > {
+            inline static std::pair<T1,T2>& apply(std::pair<T1,T2>& to, const std::pair<U1,U2>& from)
+            {
+                to.first = boost::convert_to<T1>(from.first);
+                to.second = boost::convert_to<T2>(from.second);
+                return to;
+            }
+        };
+    }
+}}
+
+#endif
+
+//]

Added: sandbox/chrono/boost/conversion/std/string.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/std/string.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,60 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_CONVERT_TO_PAIR__HPP
+#define BOOST_CONVERT_TO_PAIR__HPP
+
+#include <string>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/convert/convert.hpp>
+
+namespace boost {
+namespace conversion {
+
+    // std namespace can not be overloaded
+    namespace partial_specialization_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)
+            {
+                return convert<std::basic_string<CharT,Traits,Alloc> >::from(from);
+            }
+        }
+        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)
+            {
+                to = convert<std::basic_string<CharT,Traits,Alloc> >::from(from);
+                return to;
+            }
+        };
+        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)
+            {
+                return convert<T>::from(from);
+            }
+        };
+        template<typename T, typename CharT, typename Traits, typename Alloc>
+        struct assign_to< T, std::basic_string<CharT,Traits,Alloc>> {
+            inline static void apply(T& to, const std::basic_string<CharT,Traits,Alloc>& from)
+            {
+                to = convert<T>::from(from);
+                return to;
+            }
+        };
+
+    }
+}}
+
+#endif
+

Added: sandbox/chrono/boost/conversion/std/vector.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/conversion/std/vector.hpp	2010-06-17 17:11:19 EDT (Thu, 17 Jun 2010)
@@ -0,0 +1,72 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//[VECTOR__HPP
+#ifndef BOOST_CONVERT_TO_PAIR__HPP
+#define BOOST_CONVERT_TO_PAIR__HPP
+
+#include <vector>
+#include <boost/conversion/convert_to.hpp>
+#include <boost/conversion/assign_to.hpp>
+#include <boost/conversion/pack.hpp>
+
+
+namespace boost { namespace conversion {
+
+    // std namespace can not be overloaded
+    namespace partial_specialization_workaround {
+        template < class T1, class A1, class T2, class A2>
+        struct convert_to< std::vector<T1,A1>, std::vector<T2,A2> > {
+            inline static std::vector<T1,A1> apply(std::vector<T2,A2> const & from)
+            {
+                std::vector<T1,A1> res;
+                boost::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::assign_to(to[i], from[i]);
+                }
+                return to;
+            }
+        };
+        
+        template < class T1, class A1, class T2, class A2>
+        struct convert_to< 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(
+                typename boost::conversion::result_of::pack2<std::vector<T2,A2> const, A1 const>::type 
+                const & pack)
+            {
+                std::vector<T1,A1> res(fusion::at_c<1>(pack));
+                boost::assign_to(res, fusion::at_c<0>(pack).get());
+                return res;
+            }
+        };
+        
+    }
+}}
+
+#endif
+
+//]