1 files changed, 585 insertions, 585 deletions
diff --git a/contrib/src/boost/move/detail/meta_utils.hpp b/contrib/src/boost/move/detail/meta_utils.hpp
index d0c7d40..e45394c 100644
--- a/contrib/src/boost/move/detail/meta_utils.hpp
+++ b/contrib/src/boost/move/detail/meta_utils.hpp
@@ -1,585 +1,585 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2012-2015.
-// 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/move for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! \file
-
-#ifndef BOOST_MOVE_DETAIL_META_UTILS_HPP
-#define BOOST_MOVE_DETAIL_META_UTILS_HPP
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#  pragma once
-#endif
-#include <boost/move/detail/config_begin.hpp>
-#include <boost/move/detail/workaround.hpp>  //forceinline
-#include <boost/move/detail/meta_utils_core.hpp>
-#include <cstddef>   //for std::size_t
-
-//Small meta-typetraits to support move
-
-namespace boost {
-
-//Forward declare boost::rv
-template <class T> class rv;
-
-namespace move_detail {
-
-//////////////////////////////////////
-//          is_different
-//////////////////////////////////////
-template<class T, class U>
-struct is_different
-{
-   static const bool value = !is_same<T, U>::value;
-};
-
-//////////////////////////////////////
-//             apply
-//////////////////////////////////////
-template<class F, class Param>
-struct apply
-{
-   typedef typename F::template apply<Param>::type type;
-};
-
-//////////////////////////////////////
-//             bool_
-//////////////////////////////////////
-
-template< bool C_ >
-struct bool_ : integral_constant<bool, C_>
-{
-     operator bool() const { return C_; }
-   bool operator()() const { return C_; }
-};
-
-typedef bool_<true>        true_;
-typedef bool_<false>       false_;
-
-//////////////////////////////////////
-//              nat
-//////////////////////////////////////
-struct nat{};
-
-//////////////////////////////////////
-//          yes_type/no_type
-//////////////////////////////////////
-typedef char yes_type;
-
-struct no_type
-{
-   char _[2];
-};
-
-//////////////////////////////////////
-//            natify
-//////////////////////////////////////
-template <class T> struct natify{};
-
-//////////////////////////////////////
-//          remove_reference
-//////////////////////////////////////
-template<class T>
-struct remove_reference
-{
-   typedef T type;
-};
-
-template<class T>
-struct remove_reference<T&>
-{
-   typedef T type;
-};
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-template<class T>
-struct remove_reference<T&&>
-{
-   typedef T type;
-};
-
-#else
-
-template<class T>
-struct remove_reference< rv<T> >
-{
-   typedef T type;
-};
-
-template<class T>
-struct remove_reference< rv<T> &>
-{
-   typedef T type;
-};
-
-template<class T>
-struct remove_reference< const rv<T> &>
-{
-   typedef T type;
-};
-
-#endif
-
-//////////////////////////////////////
-//             remove_pointer
-//////////////////////////////////////
-
-template< class T > struct remove_pointer                    { typedef T type;   };
-template< class T > struct remove_pointer<T*>                { typedef T type;   };
-template< class T > struct remove_pointer<T* const>          { typedef T type;   };
-template< class T > struct remove_pointer<T* volatile>       { typedef T type;   };
-template< class T > struct remove_pointer<T* const volatile> { typedef T type;   };
-
-//////////////////////////////////////
-//             add_pointer
-//////////////////////////////////////
-template< class T >
-struct add_pointer
-{
-   typedef typename remove_reference<T>::type* type;
-};
-
-//////////////////////////////////////
-//             add_const
-//////////////////////////////////////
-template<class T>
-struct add_const
-{
-   typedef const T type;
-};
-
-template<class T>
-struct add_const<T&>
-{
-   typedef const T& type;
-};
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-template<class T>
-struct add_const<T&&>
-{
-   typedef T&& type;
-};
-
-#endif
-
-//////////////////////////////////////
-//      add_lvalue_reference
-//////////////////////////////////////
-template<class T>
-struct add_lvalue_reference
-{  typedef T& type;  };
-
-template<class T> struct add_lvalue_reference<T&>                 {  typedef T& type;  };
-template<>        struct add_lvalue_reference<void>               {  typedef void type;   };
-template<>        struct add_lvalue_reference<const void>         {  typedef const void type;  };
-template<>        struct add_lvalue_reference<volatile void>      {  typedef volatile void type;   };
-template<>        struct add_lvalue_reference<const volatile void>{  typedef const volatile void type;   };
-
-template<class T>
-struct add_const_lvalue_reference
-{
-   typedef typename remove_reference<T>::type         t_unreferenced;
-   typedef typename add_const<t_unreferenced>::type   t_unreferenced_const;
-   typedef typename add_lvalue_reference
-      <t_unreferenced_const>::type                    type;
-};
-
-//////////////////////////////////////
-//             is_lvalue_reference
-//////////////////////////////////////
-template<class T>
-struct is_lvalue_reference
-{
-    static const bool value = false;
-};
-
-template<class T>
-struct is_lvalue_reference<T&>
-{
-    static const bool value = true;
-};
-
-
-//////////////////////////////////////
-//             identity
-//////////////////////////////////////
-template <class T>
-struct identity
-{
-   typedef T type;
-   typedef typename add_const_lvalue_reference<T>::type reference;
-   reference operator()(reference t)
-   {  return t;   }
-};
-
-//////////////////////////////////////
-//          is_class_or_union
-//////////////////////////////////////
-template<class T>
-struct is_class_or_union
-{
-   struct twochar { char dummy[2]; };
-   template <class U>
-   static char is_class_or_union_tester(void(U::*)(void));
-   template <class U>
-   static twochar is_class_or_union_tester(...);
-   static const bool value = sizeof(is_class_or_union_tester<T>(0)) == sizeof(char);
-};
-
-//////////////////////////////////////
-//             addressof
-//////////////////////////////////////
-template<class T>
-struct addr_impl_ref
-{
-   T & v_;
-   BOOST_MOVE_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {}
-   BOOST_MOVE_FORCEINLINE operator T& () const { return v_; }
-
-   private:
-   addr_impl_ref & operator=(const addr_impl_ref &);
-};
-
-template<class T>
-struct addressof_impl
-{
-   BOOST_MOVE_FORCEINLINE static T * f( T & v, long )
-   {
-      return reinterpret_cast<T*>(
-         &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
-   }
-
-   BOOST_MOVE_FORCEINLINE static T * f( T * v, int )
-   {  return v;  }
-};
-
-template<class T>
-BOOST_MOVE_FORCEINLINE T * addressof( T & v )
-{
-   return ::boost::move_detail::addressof_impl<T>::f
-      ( ::boost::move_detail::addr_impl_ref<T>( v ), 0 );
-}
-
-//////////////////////////////////////
-//          has_pointer_type
-//////////////////////////////////////
-template <class T>
-struct has_pointer_type
-{
-   struct two { char c[2]; };
-   template <class U> static two test(...);
-   template <class U> static char test(typename U::pointer* = 0);
-   static const bool value = sizeof(test<T>(0)) == 1;
-};
-
-//////////////////////////////////////
-//           is_convertible
-//////////////////////////////////////
-#if defined(_MSC_VER) && (_MSC_VER >= 1400)
-
-//use intrinsic since in MSVC
-//overaligned types can't go through ellipsis
-template <class T, class U>
-struct is_convertible
-{
-   static const bool value = __is_convertible_to(T, U);
-};
-
-#else
-
-template <class T, class U>
-class is_convertible
-{
-   typedef typename add_lvalue_reference<T>::type t_reference;
-   typedef char true_t;
-   class false_t { char dummy[2]; };
-   static false_t dispatch(...);
-   static true_t  dispatch(U);
-   static t_reference       trigger();
-   public:
-   static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
-};
-
-#endif
-
-template <class T, class U, bool IsSame = is_same<T, U>::value>
-struct is_same_or_convertible
-   : is_convertible<T, U>
-{};
-
-template <class T, class U>
-struct is_same_or_convertible<T, U, true>
-{
-   static const bool value = true;
-};
-
-template<
-      bool C
-    , typename F1
-    , typename F2
-    >
-struct eval_if_c
-    : if_c<C,F1,F2>::type
-{};
-
-template<
-      typename C
-    , typename T1
-    , typename T2
-    >
-struct eval_if
-    : if_<C,T1,T2>::type
-{};
-
-
-#if defined(BOOST_GCC) && (BOOST_GCC <= 40000)
-#define BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN
-#endif
-
-template<class T, class U, class R = void>
-struct enable_if_convertible
-   : enable_if< is_convertible<T, U>, R>
-{};
-
-template<class T, class U, class R = void>
-struct disable_if_convertible
-   : disable_if< is_convertible<T, U>, R>
-{};
-
-template<class T, class U, class R = void>
-struct enable_if_same_or_convertible
-   : enable_if< is_same_or_convertible<T, U>, R>
-{};
-
-template<class T, class U, class R = void>
-struct disable_if_same_or_convertible
-   : disable_if< is_same_or_convertible<T, U>, R>
-{};
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//                         and_
-//
-//////////////////////////////////////////////////////////////////////////////
-template<bool, class B = true_, class C = true_, class D = true_>
-struct and_impl
-   : and_impl<B::value, C, D>
-{};
-
-template<>
-struct and_impl<true, true_, true_, true_>
-{
-   static const bool value = true;
-};
-
-template<class B, class C, class D>
-struct and_impl<false, B, C, D>
-{
-   static const bool value = false;
-};
-
-template<class A, class B, class C = true_, class D = true_>
-struct and_
-   : and_impl<A::value, B, C, D>
-{};
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//                            or_
-//
-//////////////////////////////////////////////////////////////////////////////
-template<bool, class B = false_, class C = false_, class D = false_>
-struct or_impl
-   : or_impl<B::value, C, D>
-{};
-
-template<>
-struct or_impl<false, false_, false_, false_>
-{
-   static const bool value = false;
-};
-
-template<class B, class C, class D>
-struct or_impl<true, B, C, D>
-{
-   static const bool value = true;
-};
-
-template<class A, class B, class C = false_, class D = false_>
-struct or_
-   : or_impl<A::value, B, C, D>
-{};
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//                         not_
-//
-//////////////////////////////////////////////////////////////////////////////
-template<class T>
-struct not_
-{
-   static const bool value = !T::value;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// enable_if_and / disable_if_and / enable_if_or / disable_if_or
-//
-//////////////////////////////////////////////////////////////////////////////
-
-template<class R, class A, class B, class C = true_, class D = true_>
-struct enable_if_and
-   : enable_if_c< and_<A, B, C, D>::value, R>
-{};
-
-template<class R, class A, class B, class C = true_, class D = true_>
-struct disable_if_and
-   : disable_if_c< and_<A, B, C, D>::value, R>
-{};
-
-template<class R, class A, class B, class C = false_, class D = false_>
-struct enable_if_or
-   : enable_if_c< or_<A, B, C, D>::value, R>
-{};
-
-template<class R, class A, class B, class C = false_, class D = false_>
-struct disable_if_or
-   : disable_if_c< or_<A, B, C, D>::value, R>
-{};
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//                      has_move_emulation_enabled_impl
-//
-//////////////////////////////////////////////////////////////////////////////
-template<class T>
-struct has_move_emulation_enabled_impl
-   : is_convertible< T, ::boost::rv<T>& >
-{};
-
-template<class T>
-struct has_move_emulation_enabled_impl<T&>
-{  static const bool value = false;  };
-
-template<class T>
-struct has_move_emulation_enabled_impl< ::boost::rv<T> >
-{  static const bool value = false;  };
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//                            is_rv_impl
-//
-//////////////////////////////////////////////////////////////////////////////
-
-template <class T>
-struct is_rv_impl
-{  static const bool value = false;  };
-
-template <class T>
-struct is_rv_impl< rv<T> >
-{  static const bool value = true;  };
-
-template <class T>
-struct is_rv_impl< const rv<T> >
-{  static const bool value = true;  };
-
-// Code from Jeffrey Lee Hellrung, many thanks
-
-template< class T >
-struct is_rvalue_reference
-{  static const bool value = false;  };
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-template< class T >
-struct is_rvalue_reference< T&& >
-{  static const bool value = true;  };
-
-#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-template< class T >
-struct is_rvalue_reference< boost::rv<T>& >
-{  static const bool value = true;  };
-
-template< class T >
-struct is_rvalue_reference< const boost::rv<T>& >
-{  static const bool value = true;  };
-
-#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-template< class T >
-struct add_rvalue_reference
-{ typedef T&& type; };
-
-#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-namespace detail_add_rvalue_reference
-{
-   template< class T
-            , bool emulation = has_move_emulation_enabled_impl<T>::value
-            , bool rv        = is_rv_impl<T>::value  >
-   struct add_rvalue_reference_impl { typedef T type; };
-
-   template< class T, bool emulation>
-   struct add_rvalue_reference_impl< T, emulation, true > { typedef T & type; };
-
-   template< class T, bool rv >
-   struct add_rvalue_reference_impl< T, true, rv > { typedef ::boost::rv<T>& type; };
-} // namespace detail_add_rvalue_reference
-
-template< class T >
-struct add_rvalue_reference
-   : detail_add_rvalue_reference::add_rvalue_reference_impl<T>
-{ };
-
-template< class T >
-struct add_rvalue_reference<T &>
-{  typedef T & type; };
-
-#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-template< class T > struct remove_rvalue_reference { typedef T type; };
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-   template< class T > struct remove_rvalue_reference< T&& >                  { typedef T type; };
-#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-   template< class T > struct remove_rvalue_reference< rv<T> >                { typedef T type; };
-   template< class T > struct remove_rvalue_reference< const rv<T> >          { typedef T type; };
-   template< class T > struct remove_rvalue_reference< volatile rv<T> >       { typedef T type; };
-   template< class T > struct remove_rvalue_reference< const volatile rv<T> > { typedef T type; };
-   template< class T > struct remove_rvalue_reference< rv<T>& >               { typedef T type; };
-   template< class T > struct remove_rvalue_reference< const rv<T>& >         { typedef T type; };
-   template< class T > struct remove_rvalue_reference< volatile rv<T>& >      { typedef T type; };
-   template< class T > struct remove_rvalue_reference< const volatile rv<T>& >{ typedef T type; };
-#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-// Ideas from Boost.Move review, Jeffrey Lee Hellrung:
-//
-//- TypeTraits metafunctions is_lvalue_reference, add_lvalue_reference, and remove_lvalue_reference ?
-//  Perhaps add_reference and remove_reference can be modified so that they behave wrt emulated rvalue
-//  references the same as wrt real rvalue references, i.e., add_reference< rv<T>& > -> T& rather than
-//  rv<T>& (since T&& & -> T&).
-//
-//- Add'l TypeTraits has_[trivial_]move_{constructor,assign}...?
-//
-//- An as_lvalue(T& x) function, which amounts to an identity operation in C++0x, but strips emulated
-//  rvalue references in C++03.  This may be necessary to prevent "accidental moves".
-
-}  //namespace move_detail {
-}  //namespace boost {
-
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_DETAIL_META_UTILS_HPP
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2015.
+// 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+
+#ifndef BOOST_MOVE_DETAIL_META_UTILS_HPP
+#define BOOST_MOVE_DETAIL_META_UTILS_HPP
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/workaround.hpp>  //forceinline
+#include <boost/move/detail/meta_utils_core.hpp>
+#include <cstddef>   //for std::size_t
+
+//Small meta-typetraits to support move
+
+namespace boost {
+
+//Forward declare boost::rv
+template <class T> class rv;
+
+namespace move_detail {
+
+//////////////////////////////////////
+//          is_different
+//////////////////////////////////////
+template<class T, class U>
+struct is_different
+{
+   static const bool value = !is_same<T, U>::value;
+};
+
+//////////////////////////////////////
+//             apply
+//////////////////////////////////////
+template<class F, class Param>
+struct apply
+{
+   typedef typename F::template apply<Param>::type type;
+};
+
+//////////////////////////////////////
+//             bool_
+//////////////////////////////////////
+
+template< bool C_ >
+struct bool_ : integral_constant<bool, C_>
+{
+     operator bool() const { return C_; }
+   bool operator()() const { return C_; }
+};
+
+typedef bool_<true>        true_;
+typedef bool_<false>       false_;
+
+//////////////////////////////////////
+//              nat
+//////////////////////////////////////
+struct nat{};
+
+//////////////////////////////////////
+//          yes_type/no_type
+//////////////////////////////////////
+typedef char yes_type;
+
+struct no_type
+{
+   char _[2];
+};
+
+//////////////////////////////////////
+//            natify
+//////////////////////////////////////
+template <class T> struct natify{};
+
+//////////////////////////////////////
+//          remove_reference
+//////////////////////////////////////
+template<class T>
+struct remove_reference
+{
+   typedef T type;
+};
+
+template<class T>
+struct remove_reference<T&>
+{
+   typedef T type;
+};
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template<class T>
+struct remove_reference<T&&>
+{
+   typedef T type;
+};
+
+#else
+
+template<class T>
+struct remove_reference< rv<T> >
+{
+   typedef T type;
+};
+
+template<class T>
+struct remove_reference< rv<T> &>
+{
+   typedef T type;
+};
+
+template<class T>
+struct remove_reference< const rv<T> &>
+{
+   typedef T type;
+};
+
+#endif
+
+//////////////////////////////////////
+//             remove_pointer
+//////////////////////////////////////
+
+template< class T > struct remove_pointer                    { typedef T type;   };
+template< class T > struct remove_pointer<T*>                { typedef T type;   };
+template< class T > struct remove_pointer<T* const>          { typedef T type;   };
+template< class T > struct remove_pointer<T* volatile>       { typedef T type;   };
+template< class T > struct remove_pointer<T* const volatile> { typedef T type;   };
+
+//////////////////////////////////////
+//             add_pointer
+//////////////////////////////////////
+template< class T >
+struct add_pointer
+{
+   typedef typename remove_reference<T>::type* type;
+};
+
+//////////////////////////////////////
+//             add_const
+//////////////////////////////////////
+template<class T>
+struct add_const
+{
+   typedef const T type;
+};
+
+template<class T>
+struct add_const<T&>
+{
+   typedef const T& type;
+};
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template<class T>
+struct add_const<T&&>
+{
+   typedef T&& type;
+};
+
+#endif
+
+//////////////////////////////////////
+//      add_lvalue_reference
+//////////////////////////////////////
+template<class T>
+struct add_lvalue_reference
+{  typedef T& type;  };
+
+template<class T> struct add_lvalue_reference<T&>                 {  typedef T& type;  };
+template<>        struct add_lvalue_reference<void>               {  typedef void type;   };
+template<>        struct add_lvalue_reference<const void>         {  typedef const void type;  };
+template<>        struct add_lvalue_reference<volatile void>      {  typedef volatile void type;   };
+template<>        struct add_lvalue_reference<const volatile void>{  typedef const volatile void type;   };
+
+template<class T>
+struct add_const_lvalue_reference
+{
+   typedef typename remove_reference<T>::type         t_unreferenced;
+   typedef typename add_const<t_unreferenced>::type   t_unreferenced_const;
+   typedef typename add_lvalue_reference
+      <t_unreferenced_const>::type                    type;
+};
+
+//////////////////////////////////////
+//             is_lvalue_reference
+//////////////////////////////////////
+template<class T>
+struct is_lvalue_reference
+{
+    static const bool value = false;
+};
+
+template<class T>
+struct is_lvalue_reference<T&>
+{
+    static const bool value = true;
+};
+
+
+//////////////////////////////////////
+//             identity
+//////////////////////////////////////
+template <class T>
+struct identity
+{
+   typedef T type;
+   typedef typename add_const_lvalue_reference<T>::type reference;
+   reference operator()(reference t)
+   {  return t;   }
+};
+
+//////////////////////////////////////
+//          is_class_or_union
+//////////////////////////////////////
+template<class T>
+struct is_class_or_union
+{
+   struct twochar { char dummy[2]; };
+   template <class U>
+   static char is_class_or_union_tester(void(U::*)(void));
+   template <class U>
+   static twochar is_class_or_union_tester(...);
+   static const bool value = sizeof(is_class_or_union_tester<T>(0)) == sizeof(char);
+};
+
+//////////////////////////////////////
+//             addressof
+//////////////////////////////////////
+template<class T>
+struct addr_impl_ref
+{
+   T & v_;
+   BOOST_MOVE_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {}
+   BOOST_MOVE_FORCEINLINE operator T& () const { return v_; }
+
+   private:
+   addr_impl_ref & operator=(const addr_impl_ref &);
+};
+
+template<class T>
+struct addressof_impl
+{
+   BOOST_MOVE_FORCEINLINE static T * f( T & v, long )
+   {
+      return reinterpret_cast<T*>(
+         &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+   }
+
+   BOOST_MOVE_FORCEINLINE static T * f( T * v, int )
+   {  return v;  }
+};
+
+template<class T>
+BOOST_MOVE_FORCEINLINE T * addressof( T & v )
+{
+   return ::boost::move_detail::addressof_impl<T>::f
+      ( ::boost::move_detail::addr_impl_ref<T>( v ), 0 );
+}
+
+//////////////////////////////////////
+//          has_pointer_type
+//////////////////////////////////////
+template <class T>
+struct has_pointer_type
+{
+   struct two { char c[2]; };
+   template <class U> static two test(...);
+   template <class U> static char test(typename U::pointer* = 0);
+   static const bool value = sizeof(test<T>(0)) == 1;
+};
+
+//////////////////////////////////////
+//           is_convertible
+//////////////////////////////////////
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+
+//use intrinsic since in MSVC
+//overaligned types can't go through ellipsis
+template <class T, class U>
+struct is_convertible
+{
+   static const bool value = __is_convertible_to(T, U);
+};
+
+#else
+
+template <class T, class U>
+class is_convertible
+{
+   typedef typename add_lvalue_reference<T>::type t_reference;
+   typedef char true_t;
+   class false_t { char dummy[2]; };
+   static false_t dispatch(...);
+   static true_t  dispatch(U);
+   static t_reference       trigger();
+   public:
+   static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
+};
+
+#endif
+
+template <class T, class U, bool IsSame = is_same<T, U>::value>
+struct is_same_or_convertible
+   : is_convertible<T, U>
+{};
+
+template <class T, class U>
+struct is_same_or_convertible<T, U, true>
+{
+   static const bool value = true;
+};
+
+template<
+      bool C
+    , typename F1
+    , typename F2
+    >
+struct eval_if_c
+    : if_c<C,F1,F2>::type
+{};
+
+template<
+      typename C
+    , typename T1
+    , typename T2
+    >
+struct eval_if
+    : if_<C,T1,T2>::type
+{};
+
+
+#if defined(BOOST_GCC) && (BOOST_GCC <= 40000)
+#define BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN
+#endif
+
+template<class T, class U, class R = void>
+struct enable_if_convertible
+   : enable_if< is_convertible<T, U>, R>
+{};
+
+template<class T, class U, class R = void>
+struct disable_if_convertible
+   : disable_if< is_convertible<T, U>, R>
+{};
+
+template<class T, class U, class R = void>
+struct enable_if_same_or_convertible
+   : enable_if< is_same_or_convertible<T, U>, R>
+{};
+
+template<class T, class U, class R = void>
+struct disable_if_same_or_convertible
+   : disable_if< is_same_or_convertible<T, U>, R>
+{};
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         and_
+//
+//////////////////////////////////////////////////////////////////////////////
+template<bool, class B = true_, class C = true_, class D = true_>
+struct and_impl
+   : and_impl<B::value, C, D>
+{};
+
+template<>
+struct and_impl<true, true_, true_, true_>
+{
+   static const bool value = true;
+};
+
+template<class B, class C, class D>
+struct and_impl<false, B, C, D>
+{
+   static const bool value = false;
+};
+
+template<class A, class B, class C = true_, class D = true_>
+struct and_
+   : and_impl<A::value, B, C, D>
+{};
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                            or_
+//
+//////////////////////////////////////////////////////////////////////////////
+template<bool, class B = false_, class C = false_, class D = false_>
+struct or_impl
+   : or_impl<B::value, C, D>
+{};
+
+template<>
+struct or_impl<false, false_, false_, false_>
+{
+   static const bool value = false;
+};
+
+template<class B, class C, class D>
+struct or_impl<true, B, C, D>
+{
+   static const bool value = true;
+};
+
+template<class A, class B, class C = false_, class D = false_>
+struct or_
+   : or_impl<A::value, B, C, D>
+{};
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         not_
+//
+//////////////////////////////////////////////////////////////////////////////
+template<class T>
+struct not_
+{
+   static const bool value = !T::value;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// enable_if_and / disable_if_and / enable_if_or / disable_if_or
+//
+//////////////////////////////////////////////////////////////////////////////
+
+template<class R, class A, class B, class C = true_, class D = true_>
+struct enable_if_and
+   : enable_if_c< and_<A, B, C, D>::value, R>
+{};
+
+template<class R, class A, class B, class C = true_, class D = true_>
+struct disable_if_and
+   : disable_if_c< and_<A, B, C, D>::value, R>
+{};
+
+template<class R, class A, class B, class C = false_, class D = false_>
+struct enable_if_or
+   : enable_if_c< or_<A, B, C, D>::value, R>
+{};
+
+template<class R, class A, class B, class C = false_, class D = false_>
+struct disable_if_or
+   : disable_if_c< or_<A, B, C, D>::value, R>
+{};
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                      has_move_emulation_enabled_impl
+//
+//////////////////////////////////////////////////////////////////////////////
+template<class T>
+struct has_move_emulation_enabled_impl
+   : is_convertible< T, ::boost::rv<T>& >
+{};
+
+template<class T>
+struct has_move_emulation_enabled_impl<T&>
+{  static const bool value = false;  };
+
+template<class T>
+struct has_move_emulation_enabled_impl< ::boost::rv<T> >
+{  static const bool value = false;  };
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                            is_rv_impl
+//
+//////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+struct is_rv_impl
+{  static const bool value = false;  };
+
+template <class T>
+struct is_rv_impl< rv<T> >
+{  static const bool value = true;  };
+
+template <class T>
+struct is_rv_impl< const rv<T> >
+{  static const bool value = true;  };
+
+// Code from Jeffrey Lee Hellrung, many thanks
+
+template< class T >
+struct is_rvalue_reference
+{  static const bool value = false;  };
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template< class T >
+struct is_rvalue_reference< T&& >
+{  static const bool value = true;  };
+
+#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template< class T >
+struct is_rvalue_reference< boost::rv<T>& >
+{  static const bool value = true;  };
+
+template< class T >
+struct is_rvalue_reference< const boost::rv<T>& >
+{  static const bool value = true;  };
+
+#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template< class T >
+struct add_rvalue_reference
+{ typedef T&& type; };
+
+#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+namespace detail_add_rvalue_reference
+{
+   template< class T
+            , bool emulation = has_move_emulation_enabled_impl<T>::value
+            , bool rv        = is_rv_impl<T>::value  >
+   struct add_rvalue_reference_impl { typedef T type; };
+
+   template< class T, bool emulation>
+   struct add_rvalue_reference_impl< T, emulation, true > { typedef T & type; };
+
+   template< class T, bool rv >
+   struct add_rvalue_reference_impl< T, true, rv > { typedef ::boost::rv<T>& type; };
+} // namespace detail_add_rvalue_reference
+
+template< class T >
+struct add_rvalue_reference
+   : detail_add_rvalue_reference::add_rvalue_reference_impl<T>
+{ };
+
+template< class T >
+struct add_rvalue_reference<T &>
+{  typedef T & type; };
+
+#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template< class T > struct remove_rvalue_reference { typedef T type; };
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+   template< class T > struct remove_rvalue_reference< T&& >                  { typedef T type; };
+#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+   template< class T > struct remove_rvalue_reference< rv<T> >                { typedef T type; };
+   template< class T > struct remove_rvalue_reference< const rv<T> >          { typedef T type; };
+   template< class T > struct remove_rvalue_reference< volatile rv<T> >       { typedef T type; };
+   template< class T > struct remove_rvalue_reference< const volatile rv<T> > { typedef T type; };
+   template< class T > struct remove_rvalue_reference< rv<T>& >               { typedef T type; };
+   template< class T > struct remove_rvalue_reference< const rv<T>& >         { typedef T type; };
+   template< class T > struct remove_rvalue_reference< volatile rv<T>& >      { typedef T type; };
+   template< class T > struct remove_rvalue_reference< const volatile rv<T>& >{ typedef T type; };
+#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+// Ideas from Boost.Move review, Jeffrey Lee Hellrung:
+//
+//- TypeTraits metafunctions is_lvalue_reference, add_lvalue_reference, and remove_lvalue_reference ?
+//  Perhaps add_reference and remove_reference can be modified so that they behave wrt emulated rvalue
+//  references the same as wrt real rvalue references, i.e., add_reference< rv<T>& > -> T& rather than
+//  rv<T>& (since T&& & -> T&).
+//
+//- Add'l TypeTraits has_[trivial_]move_{constructor,assign}...?
+//
+//- An as_lvalue(T& x) function, which amounts to an identity operation in C++0x, but strips emulated
+//  rvalue references in C++03.  This may be necessary to prevent "accidental moves".
+
+}  //namespace move_detail {
+}  //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_MOVE_DETAIL_META_UTILS_HPP