summaryrefslogtreecommitdiffstats
path: root/contrib/src/boost/move/detail
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/src/boost/move/detail')
-rw-r--r--contrib/src/boost/move/detail/config_begin.hpp42
-rw-r--r--contrib/src/boost/move/detail/config_end.hpp24
-rw-r--r--contrib/src/boost/move/detail/fwd_macros.hpp661
-rw-r--r--contrib/src/boost/move/detail/iterator_traits.hpp154
-rw-r--r--contrib/src/boost/move/detail/meta_utils.hpp1170
-rw-r--r--contrib/src/boost/move/detail/meta_utils_core.hpp252
-rw-r--r--contrib/src/boost/move/detail/move_helpers.hpp256
-rw-r--r--contrib/src/boost/move/detail/std_ns_begin.hpp60
-rw-r--r--contrib/src/boost/move/detail/std_ns_end.hpp28
-rw-r--r--contrib/src/boost/move/detail/type_traits.hpp2150
-rw-r--r--contrib/src/boost/move/detail/unique_ptr_meta_utils.hpp591
-rw-r--r--contrib/src/boost/move/detail/workaround.hpp137
12 files changed, 3513 insertions, 2012 deletions
diff --git a/contrib/src/boost/move/detail/config_begin.hpp b/contrib/src/boost/move/detail/config_begin.hpp
index b2ebdb2..637eb15 100644
--- a/contrib/src/boost/move/detail/config_begin.hpp
+++ b/contrib/src/boost/move/detail/config_begin.hpp
@@ -1,21 +1,21 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2012-2012. 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.
-//
-//////////////////////////////////////////////////////////////////////////////
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifdef BOOST_MSVC
-# pragma warning (push)
-# pragma warning (disable : 4324) // structure was padded due to __declspec(align())
-# pragma warning (disable : 4675) // "function": resolved overload was found by argument-dependent lookup
-# pragma warning (disable : 4996) // "function": was declared deprecated (_CRT_SECURE_NO_DEPRECATE/_SCL_SECURE_NO_WARNINGS)
-# pragma warning (disable : 4714) // "function": marked as __forceinline not inlined
-# pragma warning (disable : 4127) // conditional expression is constant
-#endif
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2012. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+
+#ifdef BOOST_MSVC
+# pragma warning (push)
+# pragma warning (disable : 4324) // structure was padded due to __declspec(align())
+# pragma warning (disable : 4675) // "function": resolved overload was found by argument-dependent lookup
+# pragma warning (disable : 4996) // "function": was declared deprecated (_CRT_SECURE_NO_DEPRECATE/_SCL_SECURE_NO_WARNINGS)
+# pragma warning (disable : 4714) // "function": marked as __forceinline not inlined
+# pragma warning (disable : 4127) // conditional expression is constant
+#endif
diff --git a/contrib/src/boost/move/detail/config_end.hpp b/contrib/src/boost/move/detail/config_end.hpp
index f5f561f..71a99e9 100644
--- a/contrib/src/boost/move/detail/config_end.hpp
+++ b/contrib/src/boost/move/detail/config_end.hpp
@@ -1,12 +1,12 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2012-2012. 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.
-//
-//////////////////////////////////////////////////////////////////////////////
-#if defined BOOST_MSVC
-# pragma warning (pop)
-#endif
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2012. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+#if defined BOOST_MSVC
+# pragma warning (pop)
+#endif
diff --git a/contrib/src/boost/move/detail/fwd_macros.hpp b/contrib/src/boost/move/detail/fwd_macros.hpp
new file mode 100644
index 0000000..e091890
--- /dev/null
+++ b/contrib/src/boost/move/detail/fwd_macros.hpp
@@ -0,0 +1,661 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_DETAIL_FWD_MACROS_HPP
+#define BOOST_MOVE_DETAIL_FWD_MACROS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/move/detail/workaround.hpp>
+
+namespace boost {
+namespace move_detail {
+
+template <typename T> struct unvoid { typedef T type; };
+template <> struct unvoid<void> { struct type { }; };
+template <> struct unvoid<const void> { struct type { }; };
+
+} //namespace move_detail {
+} //namespace boost {
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+#if defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+namespace boost {
+namespace move_detail {
+
+ template<class T>
+ struct mref;
+
+ template<class T>
+ struct mref<T &>
+ {
+ explicit mref(T &t) : t_(t){}
+ T &t_;
+ T & get() { return t_; }
+ };
+
+ template<class T>
+ struct mref
+ {
+ explicit mref(T &&t) : t_(t) {}
+ T &t_;
+ T &&get() { return ::boost::move(t_); }
+ };
+
+} //namespace move_detail {
+} //namespace boost {
+
+#endif //BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
+#endif //!defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+//BOOST_MOVE_REPEATN(MACRO)
+#define BOOST_MOVE_REPEAT0(MACRO)
+#define BOOST_MOVE_REPEAT1(MACRO) MACRO
+#define BOOST_MOVE_REPEAT2(MACRO) BOOST_MOVE_REPEAT1(MACRO), MACRO
+#define BOOST_MOVE_REPEAT3(MACRO) BOOST_MOVE_REPEAT2(MACRO), MACRO
+#define BOOST_MOVE_REPEAT4(MACRO) BOOST_MOVE_REPEAT3(MACRO), MACRO
+#define BOOST_MOVE_REPEAT5(MACRO) BOOST_MOVE_REPEAT4(MACRO), MACRO
+#define BOOST_MOVE_REPEAT6(MACRO) BOOST_MOVE_REPEAT5(MACRO), MACRO
+#define BOOST_MOVE_REPEAT7(MACRO) BOOST_MOVE_REPEAT6(MACRO), MACRO
+#define BOOST_MOVE_REPEAT8(MACRO) BOOST_MOVE_REPEAT7(MACRO), MACRO
+#define BOOST_MOVE_REPEAT9(MACRO) BOOST_MOVE_REPEAT8(MACRO), MACRO
+
+//BOOST_MOVE_FWDN
+#define BOOST_MOVE_FWD0
+#define BOOST_MOVE_FWD1 ::boost::forward<P0>(p0)
+#define BOOST_MOVE_FWD2 BOOST_MOVE_FWD1, ::boost::forward<P1>(p1)
+#define BOOST_MOVE_FWD3 BOOST_MOVE_FWD2, ::boost::forward<P2>(p2)
+#define BOOST_MOVE_FWD4 BOOST_MOVE_FWD3, ::boost::forward<P3>(p3)
+#define BOOST_MOVE_FWD5 BOOST_MOVE_FWD4, ::boost::forward<P4>(p4)
+#define BOOST_MOVE_FWD6 BOOST_MOVE_FWD5, ::boost::forward<P5>(p5)
+#define BOOST_MOVE_FWD7 BOOST_MOVE_FWD6, ::boost::forward<P6>(p6)
+#define BOOST_MOVE_FWD8 BOOST_MOVE_FWD7, ::boost::forward<P7>(p7)
+#define BOOST_MOVE_FWD9 BOOST_MOVE_FWD8, ::boost::forward<P8>(p8)
+
+//BOOST_MOVE_FWDQN
+#define BOOST_MOVE_FWDQ0
+#define BOOST_MOVE_FWDQ1 ::boost::forward<Q0>(q0)
+#define BOOST_MOVE_FWDQ2 BOOST_MOVE_FWDQ1, ::boost::forward<Q1>(q1)
+#define BOOST_MOVE_FWDQ3 BOOST_MOVE_FWDQ2, ::boost::forward<Q2>(q2)
+#define BOOST_MOVE_FWDQ4 BOOST_MOVE_FWDQ3, ::boost::forward<Q3>(q3)
+#define BOOST_MOVE_FWDQ5 BOOST_MOVE_FWDQ4, ::boost::forward<Q4>(q4)
+#define BOOST_MOVE_FWDQ6 BOOST_MOVE_FWDQ5, ::boost::forward<Q5>(q5)
+#define BOOST_MOVE_FWDQ7 BOOST_MOVE_FWDQ6, ::boost::forward<Q6>(q6)
+#define BOOST_MOVE_FWDQ8 BOOST_MOVE_FWDQ7, ::boost::forward<Q7>(q7)
+#define BOOST_MOVE_FWDQ9 BOOST_MOVE_FWDQ8, ::boost::forward<Q8>(q8)
+
+//BOOST_MOVE_ARGN
+#define BOOST_MOVE_ARG0
+#define BOOST_MOVE_ARG1 p0
+#define BOOST_MOVE_ARG2 BOOST_MOVE_ARG1, p1
+#define BOOST_MOVE_ARG3 BOOST_MOVE_ARG2, p2
+#define BOOST_MOVE_ARG4 BOOST_MOVE_ARG3, p3
+#define BOOST_MOVE_ARG5 BOOST_MOVE_ARG4, p4
+#define BOOST_MOVE_ARG6 BOOST_MOVE_ARG5, p5
+#define BOOST_MOVE_ARG7 BOOST_MOVE_ARG6, p6
+#define BOOST_MOVE_ARG8 BOOST_MOVE_ARG7, p7
+#define BOOST_MOVE_ARG9 BOOST_MOVE_ARG8, p8
+
+//BOOST_MOVE_ARGQN
+#define BOOST_MOVE_ARGQ0
+#define BOOST_MOVE_ARGQ1 q0
+#define BOOST_MOVE_ARGQ2 BOOST_MOVE_ARGQ1, q1
+#define BOOST_MOVE_ARGQ3 BOOST_MOVE_ARGQ2, q2
+#define BOOST_MOVE_ARGQ4 BOOST_MOVE_ARGQ3, q3
+#define BOOST_MOVE_ARGQ5 BOOST_MOVE_ARGQ4, q4
+#define BOOST_MOVE_ARGQ6 BOOST_MOVE_ARGQ5, q5
+#define BOOST_MOVE_ARGQ7 BOOST_MOVE_ARGQ6, q6
+#define BOOST_MOVE_ARGQ8 BOOST_MOVE_ARGQ7, q7
+#define BOOST_MOVE_ARGQ9 BOOST_MOVE_ARGQ8, q8
+
+//BOOST_MOVE_DECLVALN
+#define BOOST_MOVE_DECLVAL0
+#define BOOST_MOVE_DECLVAL1 ::boost::move_detail::declval<P0>()
+#define BOOST_MOVE_DECLVAL2 BOOST_MOVE_DECLVAL1, ::boost::move_detail::declval<P1>()
+#define BOOST_MOVE_DECLVAL3 BOOST_MOVE_DECLVAL2, ::boost::move_detail::declval<P2>()
+#define BOOST_MOVE_DECLVAL4 BOOST_MOVE_DECLVAL3, ::boost::move_detail::declval<P3>()
+#define BOOST_MOVE_DECLVAL5 BOOST_MOVE_DECLVAL4, ::boost::move_detail::declval<P4>()
+#define BOOST_MOVE_DECLVAL6 BOOST_MOVE_DECLVAL5, ::boost::move_detail::declval<P5>()
+#define BOOST_MOVE_DECLVAL7 BOOST_MOVE_DECLVAL6, ::boost::move_detail::declval<P6>()
+#define BOOST_MOVE_DECLVAL8 BOOST_MOVE_DECLVAL7, ::boost::move_detail::declval<P7>()
+#define BOOST_MOVE_DECLVAL9 BOOST_MOVE_DECLVAL8, ::boost::move_detail::declval<P8>()
+
+//BOOST_MOVE_DECLVALQN
+#define BOOST_MOVE_DECLVALQ0
+#define BOOST_MOVE_DECLVALQ1 ::boost::move_detail::declval<Q0>()
+#define BOOST_MOVE_DECLVALQ2 BOOST_MOVE_DECLVALQ1, ::boost::move_detail::declval<Q1>()
+#define BOOST_MOVE_DECLVALQ3 BOOST_MOVE_DECLVALQ2, ::boost::move_detail::declval<Q2>()
+#define BOOST_MOVE_DECLVALQ4 BOOST_MOVE_DECLVALQ3, ::boost::move_detail::declval<Q3>()
+#define BOOST_MOVE_DECLVALQ5 BOOST_MOVE_DECLVALQ4, ::boost::move_detail::declval<Q4>()
+#define BOOST_MOVE_DECLVALQ6 BOOST_MOVE_DECLVALQ5, ::boost::move_detail::declval<Q5>()
+#define BOOST_MOVE_DECLVALQ7 BOOST_MOVE_DECLVALQ6, ::boost::move_detail::declval<Q6>()
+#define BOOST_MOVE_DECLVALQ8 BOOST_MOVE_DECLVALQ7, ::boost::move_detail::declval<Q7>()
+#define BOOST_MOVE_DECLVALQ9 BOOST_MOVE_DECLVALQ8, ::boost::move_detail::declval<Q8>()
+
+#ifdef BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
+ #define BOOST_MOVE_MREF(T) ::boost::move_detail::mref<T>
+ #define BOOST_MOVE_MFWD(N) ::boost::forward<P##N>(this->m_p##N.get())
+ #define BOOST_MOVE_MFWDQ(N) ::boost::forward<Q##N>(this->m_q##N.get())
+#else
+ #define BOOST_MOVE_MREF(T) BOOST_FWD_REF(T)
+ #define BOOST_MOVE_MFWD(N) ::boost::forward<P##N>(this->m_p##N)
+ #define BOOST_MOVE_MFWDQ(N) ::boost::forward<Q##N>(this->m_q##N)
+#endif
+#define BOOST_MOVE_MITFWD(N) *this->m_p##N
+#define BOOST_MOVE_MINC(N) ++this->m_p##N
+#define BOOST_MOVE_MITFWDQ(N) *this->m_q##N
+#define BOOST_MOVE_MINCQ(N) ++this->m_q##N
+
+
+//BOOST_MOVE_MFWDN
+#define BOOST_MOVE_MFWD0
+#define BOOST_MOVE_MFWD1 BOOST_MOVE_MFWD(0)
+#define BOOST_MOVE_MFWD2 BOOST_MOVE_MFWD1, BOOST_MOVE_MFWD(1)
+#define BOOST_MOVE_MFWD3 BOOST_MOVE_MFWD2, BOOST_MOVE_MFWD(2)
+#define BOOST_MOVE_MFWD4 BOOST_MOVE_MFWD3, BOOST_MOVE_MFWD(3)
+#define BOOST_MOVE_MFWD5 BOOST_MOVE_MFWD4, BOOST_MOVE_MFWD(4)
+#define BOOST_MOVE_MFWD6 BOOST_MOVE_MFWD5, BOOST_MOVE_MFWD(5)
+#define BOOST_MOVE_MFWD7 BOOST_MOVE_MFWD6, BOOST_MOVE_MFWD(6)
+#define BOOST_MOVE_MFWD8 BOOST_MOVE_MFWD7, BOOST_MOVE_MFWD(7)
+#define BOOST_MOVE_MFWD9 BOOST_MOVE_MFWD8, BOOST_MOVE_MFWD(8)
+
+//BOOST_MOVE_MFWDN
+#define BOOST_MOVE_MFWDQ0
+#define BOOST_MOVE_MFWDQ1 BOOST_MOVE_MFWDQ(0)
+#define BOOST_MOVE_MFWDQ2 BOOST_MOVE_MFWDQ1, BOOST_MOVE_MFWDQ(1)
+#define BOOST_MOVE_MFWDQ3 BOOST_MOVE_MFWDQ2, BOOST_MOVE_MFWDQ(2)
+#define BOOST_MOVE_MFWDQ4 BOOST_MOVE_MFWDQ3, BOOST_MOVE_MFWDQ(3)
+#define BOOST_MOVE_MFWDQ5 BOOST_MOVE_MFWDQ4, BOOST_MOVE_MFWDQ(4)
+#define BOOST_MOVE_MFWDQ6 BOOST_MOVE_MFWDQ5, BOOST_MOVE_MFWDQ(5)
+#define BOOST_MOVE_MFWDQ7 BOOST_MOVE_MFWDQ6, BOOST_MOVE_MFWDQ(6)
+#define BOOST_MOVE_MFWDQ8 BOOST_MOVE_MFWDQ7, BOOST_MOVE_MFWDQ(7)
+#define BOOST_MOVE_MFWDQ9 BOOST_MOVE_MFWDQ8, BOOST_MOVE_MFWDQ(8)
+
+//BOOST_MOVE_MINCN
+#define BOOST_MOVE_MINC0
+#define BOOST_MOVE_MINC1 BOOST_MOVE_MINC(0)
+#define BOOST_MOVE_MINC2 BOOST_MOVE_MINC1, BOOST_MOVE_MINC(1)
+#define BOOST_MOVE_MINC3 BOOST_MOVE_MINC2, BOOST_MOVE_MINC(2)
+#define BOOST_MOVE_MINC4 BOOST_MOVE_MINC3, BOOST_MOVE_MINC(3)
+#define BOOST_MOVE_MINC5 BOOST_MOVE_MINC4, BOOST_MOVE_MINC(4)
+#define BOOST_MOVE_MINC6 BOOST_MOVE_MINC5, BOOST_MOVE_MINC(5)
+#define BOOST_MOVE_MINC7 BOOST_MOVE_MINC6, BOOST_MOVE_MINC(6)
+#define BOOST_MOVE_MINC8 BOOST_MOVE_MINC7, BOOST_MOVE_MINC(7)
+#define BOOST_MOVE_MINC9 BOOST_MOVE_MINC8, BOOST_MOVE_MINC(8)
+
+//BOOST_MOVE_MINCQN
+#define BOOST_MOVE_MINCQ0
+#define BOOST_MOVE_MINCQ1 BOOST_MOVE_MINCQ(0)
+#define BOOST_MOVE_MINCQ2 BOOST_MOVE_MINCQ1, BOOST_MOVE_MINCQ(1)
+#define BOOST_MOVE_MINCQ3 BOOST_MOVE_MINCQ2, BOOST_MOVE_MINCQ(2)
+#define BOOST_MOVE_MINCQ4 BOOST_MOVE_MINCQ3, BOOST_MOVE_MINCQ(3)
+#define BOOST_MOVE_MINCQ5 BOOST_MOVE_MINCQ4, BOOST_MOVE_MINCQ(4)
+#define BOOST_MOVE_MINCQ6 BOOST_MOVE_MINCQ5, BOOST_MOVE_MINCQ(5)
+#define BOOST_MOVE_MINCQ7 BOOST_MOVE_MINCQ6, BOOST_MOVE_MINCQ(6)
+#define BOOST_MOVE_MINCQ8 BOOST_MOVE_MINCQ7, BOOST_MOVE_MINCQ(7)
+#define BOOST_MOVE_MINCQ9 BOOST_MOVE_MINCQ8, BOOST_MOVE_MINCQ(8)
+
+//BOOST_MOVE_MITFWDN
+#define BOOST_MOVE_MITFWD0
+#define BOOST_MOVE_MITFWD1 BOOST_MOVE_MITFWD(0)
+#define BOOST_MOVE_MITFWD2 BOOST_MOVE_MITFWD1, BOOST_MOVE_MITFWD(1)
+#define BOOST_MOVE_MITFWD3 BOOST_MOVE_MITFWD2, BOOST_MOVE_MITFWD(2)
+#define BOOST_MOVE_MITFWD4 BOOST_MOVE_MITFWD3, BOOST_MOVE_MITFWD(3)
+#define BOOST_MOVE_MITFWD5 BOOST_MOVE_MITFWD4, BOOST_MOVE_MITFWD(4)
+#define BOOST_MOVE_MITFWD6 BOOST_MOVE_MITFWD5, BOOST_MOVE_MITFWD(5)
+#define BOOST_MOVE_MITFWD7 BOOST_MOVE_MITFWD6, BOOST_MOVE_MITFWD(6)
+#define BOOST_MOVE_MITFWD8 BOOST_MOVE_MITFWD7, BOOST_MOVE_MITFWD(7)
+#define BOOST_MOVE_MITFWD9 BOOST_MOVE_MITFWD8, BOOST_MOVE_MITFWD(8)
+
+//BOOST_MOVE_MITFWDQN
+#define BOOST_MOVE_MITFWDQ0
+#define BOOST_MOVE_MITFWDQ1 BOOST_MOVE_MITFWDQ(0)
+#define BOOST_MOVE_MITFWDQ2 BOOST_MOVE_MITFWDQ1, BOOST_MOVE_MITFWDQ(1)
+#define BOOST_MOVE_MITFWDQ3 BOOST_MOVE_MITFWDQ2, BOOST_MOVE_MITFWDQ(2)
+#define BOOST_MOVE_MITFWDQ4 BOOST_MOVE_MITFWDQ3, BOOST_MOVE_MITFWDQ(3)
+#define BOOST_MOVE_MITFWDQ5 BOOST_MOVE_MITFWDQ4, BOOST_MOVE_MITFWDQ(4)
+#define BOOST_MOVE_MITFWDQ6 BOOST_MOVE_MITFWDQ5, BOOST_MOVE_MITFWDQ(5)
+#define BOOST_MOVE_MITFWDQ7 BOOST_MOVE_MITFWDQ6, BOOST_MOVE_MITFWDQ(6)
+#define BOOST_MOVE_MITFWDQ8 BOOST_MOVE_MITFWDQ7, BOOST_MOVE_MITFWDQ(7)
+#define BOOST_MOVE_MITFWDQ9 BOOST_MOVE_MITFWDQ8, BOOST_MOVE_MITFWDQ(8)
+
+//BOOST_MOVE_FWD_INITN
+#define BOOST_MOVE_FWD_INIT0
+#define BOOST_MOVE_FWD_INIT1 m_p0(::boost::forward<P0>(p0))
+#define BOOST_MOVE_FWD_INIT2 BOOST_MOVE_FWD_INIT1, m_p1(::boost::forward<P1>(p1))
+#define BOOST_MOVE_FWD_INIT3 BOOST_MOVE_FWD_INIT2, m_p2(::boost::forward<P2>(p2))
+#define BOOST_MOVE_FWD_INIT4 BOOST_MOVE_FWD_INIT3, m_p3(::boost::forward<P3>(p3))
+#define BOOST_MOVE_FWD_INIT5 BOOST_MOVE_FWD_INIT4, m_p4(::boost::forward<P4>(p4))
+#define BOOST_MOVE_FWD_INIT6 BOOST_MOVE_FWD_INIT5, m_p5(::boost::forward<P5>(p5))
+#define BOOST_MOVE_FWD_INIT7 BOOST_MOVE_FWD_INIT6, m_p6(::boost::forward<P6>(p6))
+#define BOOST_MOVE_FWD_INIT8 BOOST_MOVE_FWD_INIT7, m_p7(::boost::forward<P7>(p7))
+#define BOOST_MOVE_FWD_INIT9 BOOST_MOVE_FWD_INIT8, m_p8(::boost::forward<P8>(p8))
+
+//BOOST_MOVE_FWD_INITQN
+#define BOOST_MOVE_FWD_INITQ0
+#define BOOST_MOVE_FWD_INITQ1 m_q0(::boost::forward<Q0>(q0))
+#define BOOST_MOVE_FWD_INITQ2 BOOST_MOVE_FWD_INITQ1, m_q1(::boost::forward<Q1>(q1))
+#define BOOST_MOVE_FWD_INITQ3 BOOST_MOVE_FWD_INITQ2, m_q2(::boost::forward<Q2>(q2))
+#define BOOST_MOVE_FWD_INITQ4 BOOST_MOVE_FWD_INITQ3, m_q3(::boost::forward<Q3>(q3))
+#define BOOST_MOVE_FWD_INITQ5 BOOST_MOVE_FWD_INITQ4, m_q4(::boost::forward<Q4>(q4))
+#define BOOST_MOVE_FWD_INITQ6 BOOST_MOVE_FWD_INITQ5, m_q5(::boost::forward<Q5>(q5))
+#define BOOST_MOVE_FWD_INITQ7 BOOST_MOVE_FWD_INITQ6, m_q6(::boost::forward<Q6>(q6))
+#define BOOST_MOVE_FWD_INITQ8 BOOST_MOVE_FWD_INITQ7, m_q7(::boost::forward<Q7>(q7))
+#define BOOST_MOVE_FWD_INITQ9 BOOST_MOVE_FWD_INITQ8, m_q8(::boost::forward<Q8>(q8))
+
+//BOOST_MOVE_VAL_INITN
+#define BOOST_MOVE_VAL_INIT0
+#define BOOST_MOVE_VAL_INIT1 m_p0(p0)
+#define BOOST_MOVE_VAL_INIT2 BOOST_MOVE_VAL_INIT1, m_p1(p1)
+#define BOOST_MOVE_VAL_INIT3 BOOST_MOVE_VAL_INIT2, m_p2(p2)
+#define BOOST_MOVE_VAL_INIT4 BOOST_MOVE_VAL_INIT3, m_p3(p3)
+#define BOOST_MOVE_VAL_INIT5 BOOST_MOVE_VAL_INIT4, m_p4(p4)
+#define BOOST_MOVE_VAL_INIT6 BOOST_MOVE_VAL_INIT5, m_p5(p5)
+#define BOOST_MOVE_VAL_INIT7 BOOST_MOVE_VAL_INIT6, m_p6(p6)
+#define BOOST_MOVE_VAL_INIT8 BOOST_MOVE_VAL_INIT7, m_p7(p7)
+#define BOOST_MOVE_VAL_INIT9 BOOST_MOVE_VAL_INIT8, m_p8(p8)
+
+//BOOST_MOVE_VAL_INITQN
+#define BOOST_MOVE_VAL_INITQ0
+#define BOOST_MOVE_VAL_INITQ1 m_q0(q0)
+#define BOOST_MOVE_VAL_INITQ2 BOOST_MOVE_VAL_INITQ1, m_q1(q1)
+#define BOOST_MOVE_VAL_INITQ3 BOOST_MOVE_VAL_INITQ2, m_q2(q2)
+#define BOOST_MOVE_VAL_INITQ4 BOOST_MOVE_VAL_INITQ3, m_q3(q3)
+#define BOOST_MOVE_VAL_INITQ5 BOOST_MOVE_VAL_INITQ4, m_q4(q4)
+#define BOOST_MOVE_VAL_INITQ6 BOOST_MOVE_VAL_INITQ5, m_q5(q5)
+#define BOOST_MOVE_VAL_INITQ7 BOOST_MOVE_VAL_INITQ6, m_q6(q6)
+#define BOOST_MOVE_VAL_INITQ8 BOOST_MOVE_VAL_INITQ7, m_q7(q7)
+#define BOOST_MOVE_VAL_INITQ9 BOOST_MOVE_VAL_INITQ8, m_q8(q8)
+
+//BOOST_MOVE_UREFN
+#define BOOST_MOVE_UREF0
+#define BOOST_MOVE_UREF1 BOOST_FWD_REF(P0) p0
+#define BOOST_MOVE_UREF2 BOOST_MOVE_UREF1, BOOST_FWD_REF(P1) p1
+#define BOOST_MOVE_UREF3 BOOST_MOVE_UREF2, BOOST_FWD_REF(P2) p2
+#define BOOST_MOVE_UREF4 BOOST_MOVE_UREF3, BOOST_FWD_REF(P3) p3
+#define BOOST_MOVE_UREF5 BOOST_MOVE_UREF4, BOOST_FWD_REF(P4) p4
+#define BOOST_MOVE_UREF6 BOOST_MOVE_UREF5, BOOST_FWD_REF(P5) p5
+#define BOOST_MOVE_UREF7 BOOST_MOVE_UREF6, BOOST_FWD_REF(P6) p6
+#define BOOST_MOVE_UREF8 BOOST_MOVE_UREF7, BOOST_FWD_REF(P7) p7
+#define BOOST_MOVE_UREF9 BOOST_MOVE_UREF8, BOOST_FWD_REF(P8) p8
+
+//BOOST_MOVE_UREFQN
+#define BOOST_MOVE_UREFQ0
+#define BOOST_MOVE_UREFQ1 BOOST_FWD_REF(Q0) q0
+#define BOOST_MOVE_UREFQ2 BOOST_MOVE_UREFQ1, BOOST_FWD_REF(Q1) q1
+#define BOOST_MOVE_UREFQ3 BOOST_MOVE_UREFQ2, BOOST_FWD_REF(Q2) q2
+#define BOOST_MOVE_UREFQ4 BOOST_MOVE_UREFQ3, BOOST_FWD_REF(Q3) q3
+#define BOOST_MOVE_UREFQ5 BOOST_MOVE_UREFQ4, BOOST_FWD_REF(Q4) q4
+#define BOOST_MOVE_UREFQ6 BOOST_MOVE_UREFQ5, BOOST_FWD_REF(Q5) q5
+#define BOOST_MOVE_UREFQ7 BOOST_MOVE_UREFQ6, BOOST_FWD_REF(Q6) q6
+#define BOOST_MOVE_UREFQ8 BOOST_MOVE_UREFQ7, BOOST_FWD_REF(Q7) q7
+#define BOOST_MOVE_UREFQ9 BOOST_MOVE_UREFQ8, BOOST_FWD_REF(Q8) q8
+
+//BOOST_MOVE_VALN
+#define BOOST_MOVE_VAL0
+#define BOOST_MOVE_VAL1 BOOST_FWD_REF(P0) p0
+#define BOOST_MOVE_VAL2 BOOST_MOVE_VAL1, BOOST_FWD_REF(P1) p1
+#define BOOST_MOVE_VAL3 BOOST_MOVE_VAL2, BOOST_FWD_REF(P2) p2
+#define BOOST_MOVE_VAL4 BOOST_MOVE_VAL3, BOOST_FWD_REF(P3) p3
+#define BOOST_MOVE_VAL5 BOOST_MOVE_VAL4, BOOST_FWD_REF(P4) p4
+#define BOOST_MOVE_VAL6 BOOST_MOVE_VAL5, BOOST_FWD_REF(P5) p5
+#define BOOST_MOVE_VAL7 BOOST_MOVE_VAL6, BOOST_FWD_REF(P6) p6
+#define BOOST_MOVE_VAL8 BOOST_MOVE_VAL7, BOOST_FWD_REF(P7) p7
+#define BOOST_MOVE_VAL9 BOOST_MOVE_VAL8, BOOST_FWD_REF(P8) p8
+
+//BOOST_MOVE_VALQN
+#define BOOST_MOVE_VALQ0
+#define BOOST_MOVE_VALQ1 BOOST_FWD_REF(Q0) q0
+#define BOOST_MOVE_VALQ2 BOOST_MOVE_VALQ1, BOOST_FWD_REF(Q1) q1
+#define BOOST_MOVE_VALQ3 BOOST_MOVE_VALQ2, BOOST_FWD_REF(Q2) q2
+#define BOOST_MOVE_VALQ4 BOOST_MOVE_VALQ3, BOOST_FWD_REF(Q3) q3
+#define BOOST_MOVE_VALQ5 BOOST_MOVE_VALQ4, BOOST_FWD_REF(Q4) q4
+#define BOOST_MOVE_VALQ6 BOOST_MOVE_VALQ5, BOOST_FWD_REF(Q5) q5
+#define BOOST_MOVE_VALQ7 BOOST_MOVE_VALQ6, BOOST_FWD_REF(Q6) q6
+#define BOOST_MOVE_VALQ8 BOOST_MOVE_VALQ7, BOOST_FWD_REF(Q7) q7
+#define BOOST_MOVE_VALQ9 BOOST_MOVE_VALQ8, BOOST_FWD_REF(Q8) q8
+
+
+#define BOOST_MOVE_UNVOIDCREF(T) const typename boost::move_detail::unvoid<T>::type&
+//BOOST_MOVE_CREFN
+#define BOOST_MOVE_CREF0
+#define BOOST_MOVE_CREF1 BOOST_MOVE_UNVOIDCREF(P0) p0
+#define BOOST_MOVE_CREF2 BOOST_MOVE_CREF1, BOOST_MOVE_UNVOIDCREF(P1) p1
+#define BOOST_MOVE_CREF3 BOOST_MOVE_CREF2, BOOST_MOVE_UNVOIDCREF(P2) p2
+#define BOOST_MOVE_CREF4 BOOST_MOVE_CREF3, BOOST_MOVE_UNVOIDCREF(P3) p3
+#define BOOST_MOVE_CREF5 BOOST_MOVE_CREF4, BOOST_MOVE_UNVOIDCREF(P4) p4
+#define BOOST_MOVE_CREF6 BOOST_MOVE_CREF5, BOOST_MOVE_UNVOIDCREF(P5) p5
+#define BOOST_MOVE_CREF7 BOOST_MOVE_CREF6, BOOST_MOVE_UNVOIDCREF(P6) p6
+#define BOOST_MOVE_CREF8 BOOST_MOVE_CREF7, BOOST_MOVE_UNVOIDCREF(P7) p7
+#define BOOST_MOVE_CREF9 BOOST_MOVE_CREF8, BOOST_MOVE_UNVOIDCREF(P8) p8
+
+//BOOST_MOVE_CREFQN
+#define BOOST_MOVE_CREFQ0
+#define BOOST_MOVE_CREFQ1 BOOST_MOVE_UNVOIDCREF(Q0) q0
+#define BOOST_MOVE_CREFQ2 BOOST_MOVE_CREFQ1, BOOST_MOVE_UNVOIDCREF(Q1) q1
+#define BOOST_MOVE_CREFQ3 BOOST_MOVE_CREFQ2, BOOST_MOVE_UNVOIDCREF(Q2) q2
+#define BOOST_MOVE_CREFQ4 BOOST_MOVE_CREFQ3, BOOST_MOVE_UNVOIDCREF(Q3) q3
+#define BOOST_MOVE_CREFQ5 BOOST_MOVE_CREFQ4, BOOST_MOVE_UNVOIDCREF(Q4) q4
+#define BOOST_MOVE_CREFQ6 BOOST_MOVE_CREFQ5, BOOST_MOVE_UNVOIDCREF(Q5) q5
+#define BOOST_MOVE_CREFQ7 BOOST_MOVE_CREFQ6, BOOST_MOVE_UNVOIDCREF(Q6) q6
+#define BOOST_MOVE_CREFQ8 BOOST_MOVE_CREFQ7, BOOST_MOVE_UNVOIDCREF(Q7) q7
+#define BOOST_MOVE_CREFQ9 BOOST_MOVE_CREFQ8, BOOST_MOVE_UNVOIDCREF(Q8) q8
+
+//BOOST_MOVE_CLASSN
+#define BOOST_MOVE_CLASS0
+#define BOOST_MOVE_CLASS1 class P0
+#define BOOST_MOVE_CLASS2 BOOST_MOVE_CLASS1, class P1
+#define BOOST_MOVE_CLASS3 BOOST_MOVE_CLASS2, class P2
+#define BOOST_MOVE_CLASS4 BOOST_MOVE_CLASS3, class P3
+#define BOOST_MOVE_CLASS5 BOOST_MOVE_CLASS4, class P4
+#define BOOST_MOVE_CLASS6 BOOST_MOVE_CLASS5, class P5
+#define BOOST_MOVE_CLASS7 BOOST_MOVE_CLASS6, class P6
+#define BOOST_MOVE_CLASS8 BOOST_MOVE_CLASS7, class P7
+#define BOOST_MOVE_CLASS9 BOOST_MOVE_CLASS8, class P8
+
+//BOOST_MOVE_CLASSQN
+#define BOOST_MOVE_CLASSQ0
+#define BOOST_MOVE_CLASSQ1 class Q0
+#define BOOST_MOVE_CLASSQ2 BOOST_MOVE_CLASSQ1, class Q1
+#define BOOST_MOVE_CLASSQ3 BOOST_MOVE_CLASSQ2, class Q2
+#define BOOST_MOVE_CLASSQ4 BOOST_MOVE_CLASSQ3, class Q3
+#define BOOST_MOVE_CLASSQ5 BOOST_MOVE_CLASSQ4, class Q4
+#define BOOST_MOVE_CLASSQ6 BOOST_MOVE_CLASSQ5, class Q5
+#define BOOST_MOVE_CLASSQ7 BOOST_MOVE_CLASSQ6, class Q6
+#define BOOST_MOVE_CLASSQ8 BOOST_MOVE_CLASSQ7, class Q7
+#define BOOST_MOVE_CLASSQ9 BOOST_MOVE_CLASSQ8, class Q8
+
+//BOOST_MOVE_CLASSDFLTN
+#define BOOST_MOVE_CLASSDFLT0
+#define BOOST_MOVE_CLASSDFLT1 class P0 = void
+#define BOOST_MOVE_CLASSDFLT2 BOOST_MOVE_CLASSDFLT1, class P1 = void
+#define BOOST_MOVE_CLASSDFLT3 BOOST_MOVE_CLASSDFLT2, class P2 = void
+#define BOOST_MOVE_CLASSDFLT4 BOOST_MOVE_CLASSDFLT3, class P3 = void
+#define BOOST_MOVE_CLASSDFLT5 BOOST_MOVE_CLASSDFLT4, class P4 = void
+#define BOOST_MOVE_CLASSDFLT6 BOOST_MOVE_CLASSDFLT5, class P5 = void
+#define BOOST_MOVE_CLASSDFLT7 BOOST_MOVE_CLASSDFLT6, class P6 = void
+#define BOOST_MOVE_CLASSDFLT8 BOOST_MOVE_CLASSDFLT7, class P7 = void
+#define BOOST_MOVE_CLASSDFLT9 BOOST_MOVE_CLASSDFLT8, class P8 = void
+
+//BOOST_MOVE_CLASSDFLTQN
+#define BOOST_MOVE_CLASSDFLTQ0
+#define BOOST_MOVE_CLASSDFLTQ1 class Q0 = void
+#define BOOST_MOVE_CLASSDFLTQ2 BOOST_MOVE_CLASSDFLTQ1, class Q1 = void
+#define BOOST_MOVE_CLASSDFLTQ3 BOOST_MOVE_CLASSDFLTQ2, class Q2 = void
+#define BOOST_MOVE_CLASSDFLTQ4 BOOST_MOVE_CLASSDFLTQ3, class Q3 = void
+#define BOOST_MOVE_CLASSDFLTQ5 BOOST_MOVE_CLASSDFLTQ4, class Q4 = void
+#define BOOST_MOVE_CLASSDFLTQ6 BOOST_MOVE_CLASSDFLTQ5, class Q5 = void
+#define BOOST_MOVE_CLASSDFLTQ7 BOOST_MOVE_CLASSDFLTQ6, class Q6 = void
+#define BOOST_MOVE_CLASSDFLTQ8 BOOST_MOVE_CLASSDFLTQ7, class Q7 = void
+#define BOOST_MOVE_CLASSDFLTQ9 BOOST_MOVE_CLASSDFLTQ8, class Q8 = void
+
+//BOOST_MOVE_TARGN
+#define BOOST_MOVE_TARG0
+#define BOOST_MOVE_TARG1 P0
+#define BOOST_MOVE_TARG2 BOOST_MOVE_TARG1, P1
+#define BOOST_MOVE_TARG3 BOOST_MOVE_TARG2, P2
+#define BOOST_MOVE_TARG4 BOOST_MOVE_TARG3, P3
+#define BOOST_MOVE_TARG5 BOOST_MOVE_TARG4, P4
+#define BOOST_MOVE_TARG6 BOOST_MOVE_TARG5, P5
+#define BOOST_MOVE_TARG7 BOOST_MOVE_TARG6, P6
+#define BOOST_MOVE_TARG8 BOOST_MOVE_TARG7, P7
+#define BOOST_MOVE_TARG9 BOOST_MOVE_TARG8, P8
+
+//BOOST_MOVE_TARGQN
+#define BOOST_MOVE_TARGQ0
+#define BOOST_MOVE_TARGQ1 Q0
+#define BOOST_MOVE_TARGQ2 BOOST_MOVE_TARGQ1, Q1
+#define BOOST_MOVE_TARGQ3 BOOST_MOVE_TARGQ2, Q2
+#define BOOST_MOVE_TARGQ4 BOOST_MOVE_TARGQ3, Q3
+#define BOOST_MOVE_TARGQ5 BOOST_MOVE_TARGQ4, Q4
+#define BOOST_MOVE_TARGQ6 BOOST_MOVE_TARGQ5, Q5
+#define BOOST_MOVE_TARGQ7 BOOST_MOVE_TARGQ6, Q6
+#define BOOST_MOVE_TARGQ8 BOOST_MOVE_TARGQ7, Q7
+#define BOOST_MOVE_TARGQ9 BOOST_MOVE_TARGQ8, Q8
+
+//BOOST_MOVE_FWD_TN
+#define BOOST_MOVE_FWD_T0
+#define BOOST_MOVE_FWD_T1 typename ::boost::move_detail::forward_type<P0>::type
+#define BOOST_MOVE_FWD_T2 BOOST_MOVE_FWD_T1, typename ::boost::move_detail::forward_type<P1>::type
+#define BOOST_MOVE_FWD_T3 BOOST_MOVE_FWD_T2, typename ::boost::move_detail::forward_type<P2>::type
+#define BOOST_MOVE_FWD_T4 BOOST_MOVE_FWD_T3, typename ::boost::move_detail::forward_type<P3>::type
+#define BOOST_MOVE_FWD_T5 BOOST_MOVE_FWD_T4, typename ::boost::move_detail::forward_type<P4>::type
+#define BOOST_MOVE_FWD_T6 BOOST_MOVE_FWD_T5, typename ::boost::move_detail::forward_type<P5>::type
+#define BOOST_MOVE_FWD_T7 BOOST_MOVE_FWD_T6, typename ::boost::move_detail::forward_type<P6>::type
+#define BOOST_MOVE_FWD_T8 BOOST_MOVE_FWD_T7, typename ::boost::move_detail::forward_type<P7>::type
+#define BOOST_MOVE_FWD_T9 BOOST_MOVE_FWD_T8, typename ::boost::move_detail::forward_type<P8>::type
+
+//BOOST_MOVE_FWD_TQN
+#define BOOST_MOVE_FWD_TQ0
+#define BOOST_MOVE_FWD_TQ1 typename ::boost::move_detail::forward_type<Q0>::type
+#define BOOST_MOVE_FWD_TQ2 BOOST_MOVE_FWD_TQ1, typename ::boost::move_detail::forward_type<Q1>::type
+#define BOOST_MOVE_FWD_TQ3 BOOST_MOVE_FWD_TQ2, typename ::boost::move_detail::forward_type<Q2>::type
+#define BOOST_MOVE_FWD_TQ4 BOOST_MOVE_FWD_TQ3, typename ::boost::move_detail::forward_type<Q3>::type
+#define BOOST_MOVE_FWD_TQ5 BOOST_MOVE_FWD_TQ4, typename ::boost::move_detail::forward_type<Q4>::type
+#define BOOST_MOVE_FWD_TQ6 BOOST_MOVE_FWD_TQ5, typename ::boost::move_detail::forward_type<Q5>::type
+#define BOOST_MOVE_FWD_TQ7 BOOST_MOVE_FWD_TQ6, typename ::boost::move_detail::forward_type<Q6>::type
+#define BOOST_MOVE_FWD_TQ8 BOOST_MOVE_FWD_TQ7, typename ::boost::move_detail::forward_type<Q7>::type
+#define BOOST_MOVE_FWD_TQ9 BOOST_MOVE_FWD_TQ8, typename ::boost::move_detail::forward_type<Q8>::type
+
+//BOOST_MOVE_MREFX
+#define BOOST_MOVE_MREF0
+#define BOOST_MOVE_MREF1 BOOST_MOVE_MREF(P0) m_p0;
+#define BOOST_MOVE_MREF2 BOOST_MOVE_MREF1 BOOST_MOVE_MREF(P1) m_p1;
+#define BOOST_MOVE_MREF3 BOOST_MOVE_MREF2 BOOST_MOVE_MREF(P2) m_p2;
+#define BOOST_MOVE_MREF4 BOOST_MOVE_MREF3 BOOST_MOVE_MREF(P3) m_p3;
+#define BOOST_MOVE_MREF5 BOOST_MOVE_MREF4 BOOST_MOVE_MREF(P4) m_p4;
+#define BOOST_MOVE_MREF6 BOOST_MOVE_MREF5 BOOST_MOVE_MREF(P5) m_p5;
+#define BOOST_MOVE_MREF7 BOOST_MOVE_MREF6 BOOST_MOVE_MREF(P6) m_p6;
+#define BOOST_MOVE_MREF8 BOOST_MOVE_MREF7 BOOST_MOVE_MREF(P7) m_p7;
+#define BOOST_MOVE_MREF9 BOOST_MOVE_MREF8 BOOST_MOVE_MREF(P8) m_p8;
+
+//BOOST_MOVE_MREFQX
+#define BOOST_MOVE_MREFQ0
+#define BOOST_MOVE_MREFQ1 BOOST_MOVE_MREFQ(Q0) m_q0;
+#define BOOST_MOVE_MREFQ2 BOOST_MOVE_MREFQ1 BOOST_MOVE_MREFQ(Q1) m_q1;
+#define BOOST_MOVE_MREFQ3 BOOST_MOVE_MREFQ2 BOOST_MOVE_MREFQ(Q2) m_q2;
+#define BOOST_MOVE_MREFQ4 BOOST_MOVE_MREFQ3 BOOST_MOVE_MREFQ(Q3) m_q3;
+#define BOOST_MOVE_MREFQ5 BOOST_MOVE_MREFQ4 BOOST_MOVE_MREFQ(Q4) m_q4;
+#define BOOST_MOVE_MREFQ6 BOOST_MOVE_MREFQ5 BOOST_MOVE_MREFQ(Q5) m_q5;
+#define BOOST_MOVE_MREFQ7 BOOST_MOVE_MREFQ6 BOOST_MOVE_MREFQ(Q6) m_q6;
+#define BOOST_MOVE_MREFQ8 BOOST_MOVE_MREFQ7 BOOST_MOVE_MREFQ(Q7) m_q7;
+#define BOOST_MOVE_MREFQ9 BOOST_MOVE_MREFQ8 BOOST_MOVE_MREFQ(Q8) m_q8;
+
+//BOOST_MOVE_MEMBX
+#define BOOST_MOVE_MEMB0
+#define BOOST_MOVE_MEMB1 P0 m_p0;
+#define BOOST_MOVE_MEMB2 BOOST_MOVE_MEMB1 P1 m_p1;
+#define BOOST_MOVE_MEMB3 BOOST_MOVE_MEMB2 P2 m_p2;
+#define BOOST_MOVE_MEMB4 BOOST_MOVE_MEMB3 P3 m_p3;
+#define BOOST_MOVE_MEMB5 BOOST_MOVE_MEMB4 P4 m_p4;
+#define BOOST_MOVE_MEMB6 BOOST_MOVE_MEMB5 P5 m_p5;
+#define BOOST_MOVE_MEMB7 BOOST_MOVE_MEMB6 P6 m_p6;
+#define BOOST_MOVE_MEMB8 BOOST_MOVE_MEMB7 P7 m_p7;
+#define BOOST_MOVE_MEMB9 BOOST_MOVE_MEMB8 P8 m_p8;
+
+//BOOST_MOVE_MEMBQX
+#define BOOST_MOVE_MEMBQ0
+#define BOOST_MOVE_MEMBQ1 Q0 m_q0;
+#define BOOST_MOVE_MEMBQ2 BOOST_MOVE_MEMBQ1 Q1 m_q1;
+#define BOOST_MOVE_MEMBQ3 BOOST_MOVE_MEMBQ2 Q2 m_q2;
+#define BOOST_MOVE_MEMBQ4 BOOST_MOVE_MEMBQ3 Q3 m_q3;
+#define BOOST_MOVE_MEMBQ5 BOOST_MOVE_MEMBQ4 Q4 m_q4;
+#define BOOST_MOVE_MEMBQ6 BOOST_MOVE_MEMBQ5 Q5 m_q5;
+#define BOOST_MOVE_MEMBQ7 BOOST_MOVE_MEMBQ6 Q6 m_q6;
+#define BOOST_MOVE_MEMBQ8 BOOST_MOVE_MEMBQ7 Q7 m_q7;
+#define BOOST_MOVE_MEMBQ9 BOOST_MOVE_MEMBQ8 Q8 m_q8;
+
+//BOOST_MOVE_TMPL_LTN
+#define BOOST_MOVE_TMPL_LT0
+#define BOOST_MOVE_TMPL_LT1 template<
+#define BOOST_MOVE_TMPL_LT2 BOOST_MOVE_TMPL_LT1
+#define BOOST_MOVE_TMPL_LT3 BOOST_MOVE_TMPL_LT1
+#define BOOST_MOVE_TMPL_LT4 BOOST_MOVE_TMPL_LT1
+#define BOOST_MOVE_TMPL_LT5 BOOST_MOVE_TMPL_LT1
+#define BOOST_MOVE_TMPL_LT6 BOOST_MOVE_TMPL_LT1
+#define BOOST_MOVE_TMPL_LT7 BOOST_MOVE_TMPL_LT1
+#define BOOST_MOVE_TMPL_LT8 BOOST_MOVE_TMPL_LT1
+#define BOOST_MOVE_TMPL_LT9 BOOST_MOVE_TMPL_LT1
+
+//BOOST_MOVE_LTN
+#define BOOST_MOVE_LT0
+#define BOOST_MOVE_LT1 <
+#define BOOST_MOVE_LT2 BOOST_MOVE_LT1
+#define BOOST_MOVE_LT3 BOOST_MOVE_LT1
+#define BOOST_MOVE_LT4 BOOST_MOVE_LT1
+#define BOOST_MOVE_LT5 BOOST_MOVE_LT1
+#define BOOST_MOVE_LT6 BOOST_MOVE_LT1
+#define BOOST_MOVE_LT7 BOOST_MOVE_LT1
+#define BOOST_MOVE_LT8 BOOST_MOVE_LT1
+#define BOOST_MOVE_LT9 BOOST_MOVE_LT1
+
+//BOOST_MOVE_GTN
+#define BOOST_MOVE_GT0
+#define BOOST_MOVE_GT1 >
+#define BOOST_MOVE_GT2 BOOST_MOVE_GT1
+#define BOOST_MOVE_GT3 BOOST_MOVE_GT1
+#define BOOST_MOVE_GT4 BOOST_MOVE_GT1
+#define BOOST_MOVE_GT5 BOOST_MOVE_GT1
+#define BOOST_MOVE_GT6 BOOST_MOVE_GT1
+#define BOOST_MOVE_GT7 BOOST_MOVE_GT1
+#define BOOST_MOVE_GT8 BOOST_MOVE_GT1
+#define BOOST_MOVE_GT9 BOOST_MOVE_GT1
+
+//BOOST_MOVE_LPN
+#define BOOST_MOVE_LP0
+#define BOOST_MOVE_LP1 (
+#define BOOST_MOVE_LP2 BOOST_MOVE_LP1
+#define BOOST_MOVE_LP3 BOOST_MOVE_LP1
+#define BOOST_MOVE_LP4 BOOST_MOVE_LP1
+#define BOOST_MOVE_LP5 BOOST_MOVE_LP1
+#define BOOST_MOVE_LP6 BOOST_MOVE_LP1
+#define BOOST_MOVE_LP7 BOOST_MOVE_LP1
+#define BOOST_MOVE_LP8 BOOST_MOVE_LP1
+#define BOOST_MOVE_LP9 BOOST_MOVE_LP1
+
+//BOOST_MOVE_RPN
+#define BOOST_MOVE_RP0
+#define BOOST_MOVE_RP1 )
+#define BOOST_MOVE_RP2 BOOST_MOVE_RP1
+#define BOOST_MOVE_RP3 BOOST_MOVE_RP1
+#define BOOST_MOVE_RP4 BOOST_MOVE_RP1
+#define BOOST_MOVE_RP5 BOOST_MOVE_RP1
+#define BOOST_MOVE_RP6 BOOST_MOVE_RP1
+#define BOOST_MOVE_RP7 BOOST_MOVE_RP1
+#define BOOST_MOVE_RP8 BOOST_MOVE_RP1
+#define BOOST_MOVE_RP9 BOOST_MOVE_RP1
+
+//BOOST_MOVE_IN
+#define BOOST_MOVE_I0
+#define BOOST_MOVE_I1 ,
+#define BOOST_MOVE_I2 BOOST_MOVE_I1
+#define BOOST_MOVE_I3 BOOST_MOVE_I1
+#define BOOST_MOVE_I4 BOOST_MOVE_I1
+#define BOOST_MOVE_I5 BOOST_MOVE_I1
+#define BOOST_MOVE_I6 BOOST_MOVE_I1
+#define BOOST_MOVE_I7 BOOST_MOVE_I1
+#define BOOST_MOVE_I8 BOOST_MOVE_I1
+#define BOOST_MOVE_I9 BOOST_MOVE_I1
+
+//BOOST_MOVE_COLON
+#define BOOST_MOVE_COLON0
+#define BOOST_MOVE_COLON1 :
+#define BOOST_MOVE_COLON2 BOOST_MOVE_COLON1
+#define BOOST_MOVE_COLON3 BOOST_MOVE_COLON1
+#define BOOST_MOVE_COLON4 BOOST_MOVE_COLON1
+#define BOOST_MOVE_COLON5 BOOST_MOVE_COLON1
+#define BOOST_MOVE_COLON6 BOOST_MOVE_COLON1
+#define BOOST_MOVE_COLON7 BOOST_MOVE_COLON1
+#define BOOST_MOVE_COLON8 BOOST_MOVE_COLON1
+#define BOOST_MOVE_COLON9 BOOST_MOVE_COLON1
+
+//BOOST_MOVE_ITERATE_2TON
+#define BOOST_MOVE_ITERATE_2TO2(MACROFUNC) MACROFUNC(2)
+#define BOOST_MOVE_ITERATE_2TO3(MACROFUNC) BOOST_MOVE_ITERATE_2TO2(MACROFUNC) MACROFUNC(3)
+#define BOOST_MOVE_ITERATE_2TO4(MACROFUNC) BOOST_MOVE_ITERATE_2TO3(MACROFUNC) MACROFUNC(4)
+#define BOOST_MOVE_ITERATE_2TO5(MACROFUNC) BOOST_MOVE_ITERATE_2TO4(MACROFUNC) MACROFUNC(5)
+#define BOOST_MOVE_ITERATE_2TO6(MACROFUNC) BOOST_MOVE_ITERATE_2TO5(MACROFUNC) MACROFUNC(6)
+#define BOOST_MOVE_ITERATE_2TO7(MACROFUNC) BOOST_MOVE_ITERATE_2TO6(MACROFUNC) MACROFUNC(7)
+#define BOOST_MOVE_ITERATE_2TO8(MACROFUNC) BOOST_MOVE_ITERATE_2TO7(MACROFUNC) MACROFUNC(8)
+#define BOOST_MOVE_ITERATE_2TO9(MACROFUNC) BOOST_MOVE_ITERATE_2TO8(MACROFUNC) MACROFUNC(9)
+
+//BOOST_MOVE_ITERATE_1TON
+#define BOOST_MOVE_ITERATE_1TO1(MACROFUNC) MACROFUNC(1)
+#define BOOST_MOVE_ITERATE_1TO2(MACROFUNC) BOOST_MOVE_ITERATE_1TO1(MACROFUNC) MACROFUNC(2)
+#define BOOST_MOVE_ITERATE_1TO3(MACROFUNC) BOOST_MOVE_ITERATE_1TO2(MACROFUNC) MACROFUNC(3)
+#define BOOST_MOVE_ITERATE_1TO4(MACROFUNC) BOOST_MOVE_ITERATE_1TO3(MACROFUNC) MACROFUNC(4)
+#define BOOST_MOVE_ITERATE_1TO5(MACROFUNC) BOOST_MOVE_ITERATE_1TO4(MACROFUNC) MACROFUNC(5)
+#define BOOST_MOVE_ITERATE_1TO6(MACROFUNC) BOOST_MOVE_ITERATE_1TO5(MACROFUNC) MACROFUNC(6)
+#define BOOST_MOVE_ITERATE_1TO7(MACROFUNC) BOOST_MOVE_ITERATE_1TO6(MACROFUNC) MACROFUNC(7)
+#define BOOST_MOVE_ITERATE_1TO8(MACROFUNC) BOOST_MOVE_ITERATE_1TO7(MACROFUNC) MACROFUNC(8)
+#define BOOST_MOVE_ITERATE_1TO9(MACROFUNC) BOOST_MOVE_ITERATE_1TO8(MACROFUNC) MACROFUNC(9)
+
+//BOOST_MOVE_ITERATE_0TON
+#define BOOST_MOVE_ITERATE_0TO0(MACROFUNC) MACROFUNC(0)
+#define BOOST_MOVE_ITERATE_0TO1(MACROFUNC) BOOST_MOVE_ITERATE_0TO0(MACROFUNC) MACROFUNC(1)
+#define BOOST_MOVE_ITERATE_0TO2(MACROFUNC) BOOST_MOVE_ITERATE_0TO1(MACROFUNC) MACROFUNC(2)
+#define BOOST_MOVE_ITERATE_0TO3(MACROFUNC) BOOST_MOVE_ITERATE_0TO2(MACROFUNC) MACROFUNC(3)
+#define BOOST_MOVE_ITERATE_0TO4(MACROFUNC) BOOST_MOVE_ITERATE_0TO3(MACROFUNC) MACROFUNC(4)
+#define BOOST_MOVE_ITERATE_0TO5(MACROFUNC) BOOST_MOVE_ITERATE_0TO4(MACROFUNC) MACROFUNC(5)
+#define BOOST_MOVE_ITERATE_0TO6(MACROFUNC) BOOST_MOVE_ITERATE_0TO5(MACROFUNC) MACROFUNC(6)
+#define BOOST_MOVE_ITERATE_0TO7(MACROFUNC) BOOST_MOVE_ITERATE_0TO6(MACROFUNC) MACROFUNC(7)
+#define BOOST_MOVE_ITERATE_0TO8(MACROFUNC) BOOST_MOVE_ITERATE_0TO7(MACROFUNC) MACROFUNC(8)
+#define BOOST_MOVE_ITERATE_0TO9(MACROFUNC) BOOST_MOVE_ITERATE_0TO8(MACROFUNC) MACROFUNC(9)
+
+//BOOST_MOVE_ITERATE_NTON
+#define BOOST_MOVE_ITERATE_0TO0(MACROFUNC) MACROFUNC(0)
+#define BOOST_MOVE_ITERATE_1TO1(MACROFUNC) MACROFUNC(1)
+#define BOOST_MOVE_ITERATE_2TO2(MACROFUNC) MACROFUNC(2)
+#define BOOST_MOVE_ITERATE_3TO3(MACROFUNC) MACROFUNC(3)
+#define BOOST_MOVE_ITERATE_4TO4(MACROFUNC) MACROFUNC(4)
+#define BOOST_MOVE_ITERATE_5TO5(MACROFUNC) MACROFUNC(5)
+#define BOOST_MOVE_ITERATE_6TO6(MACROFUNC) MACROFUNC(6)
+#define BOOST_MOVE_ITERATE_7TO7(MACROFUNC) MACROFUNC(7)
+#define BOOST_MOVE_ITERATE_8TO8(MACROFUNC) MACROFUNC(8)
+#define BOOST_MOVE_ITERATE_9TO9(MACROFUNC) MACROFUNC(9)
+
+//BOOST_MOVE_ITER2D_0TO9
+#define BOOST_MOVE_ITER2DLOW_0TO0(MACROFUNC2D, M) MACROFUNC2D(M, 0)
+#define BOOST_MOVE_ITER2DLOW_0TO1(MACROFUNC2D, M) BOOST_MOVE_ITER2DLOW_0TO0(MACROFUNC2D, M) MACROFUNC2D(M, 1)
+#define BOOST_MOVE_ITER2DLOW_0TO2(MACROFUNC2D, M) BOOST_MOVE_ITER2DLOW_0TO1(MACROFUNC2D, M) MACROFUNC2D(M, 2)
+#define BOOST_MOVE_ITER2DLOW_0TO3(MACROFUNC2D, M) BOOST_MOVE_ITER2DLOW_0TO2(MACROFUNC2D, M) MACROFUNC2D(M, 3)
+#define BOOST_MOVE_ITER2DLOW_0TO4(MACROFUNC2D, M) BOOST_MOVE_ITER2DLOW_0TO3(MACROFUNC2D, M) MACROFUNC2D(M, 4)
+#define BOOST_MOVE_ITER2DLOW_0TO5(MACROFUNC2D, M) BOOST_MOVE_ITER2DLOW_0TO4(MACROFUNC2D, M) MACROFUNC2D(M, 5)
+#define BOOST_MOVE_ITER2DLOW_0TO6(MACROFUNC2D, M) BOOST_MOVE_ITER2DLOW_0TO5(MACROFUNC2D, M) MACROFUNC2D(M, 6)
+#define BOOST_MOVE_ITER2DLOW_0TO7(MACROFUNC2D, M) BOOST_MOVE_ITER2DLOW_0TO6(MACROFUNC2D, M) MACROFUNC2D(M, 7)
+#define BOOST_MOVE_ITER2DLOW_0TO8(MACROFUNC2D, M) BOOST_MOVE_ITER2DLOW_0TO7(MACROFUNC2D, M) MACROFUNC2D(M, 8)
+#define BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, M) BOOST_MOVE_ITER2DLOW_0TO8(MACROFUNC2D, M) MACROFUNC2D(M, 9)
+//
+#define BOOST_MOVE_ITER2D_0TO0(MACROFUNC2D) BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, 0)
+#define BOOST_MOVE_ITER2D_0TO1(MACROFUNC2D) BOOST_MOVE_ITER2D_0TO0(MACROFUNC2D) BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, 1)
+#define BOOST_MOVE_ITER2D_0TO2(MACROFUNC2D) BOOST_MOVE_ITER2D_0TO1(MACROFUNC2D) BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, 2)
+#define BOOST_MOVE_ITER2D_0TO3(MACROFUNC2D) BOOST_MOVE_ITER2D_0TO2(MACROFUNC2D) BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, 3)
+#define BOOST_MOVE_ITER2D_0TO4(MACROFUNC2D) BOOST_MOVE_ITER2D_0TO3(MACROFUNC2D) BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, 4)
+#define BOOST_MOVE_ITER2D_0TO5(MACROFUNC2D) BOOST_MOVE_ITER2D_0TO4(MACROFUNC2D) BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, 5)
+#define BOOST_MOVE_ITER2D_0TO6(MACROFUNC2D) BOOST_MOVE_ITER2D_0TO5(MACROFUNC2D) BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, 6)
+#define BOOST_MOVE_ITER2D_0TO7(MACROFUNC2D) BOOST_MOVE_ITER2D_0TO6(MACROFUNC2D) BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, 7)
+#define BOOST_MOVE_ITER2D_0TO8(MACROFUNC2D) BOOST_MOVE_ITER2D_0TO7(MACROFUNC2D) BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, 8)
+#define BOOST_MOVE_ITER2D_0TO9(MACROFUNC2D) BOOST_MOVE_ITER2D_0TO8(MACROFUNC2D) BOOST_MOVE_ITER2DLOW_0TO9(MACROFUNC2D, 9)
+
+//BOOST_MOVE_CAT
+#define BOOST_MOVE_CAT(a, b) BOOST_MOVE_CAT_I(a, b)
+#define BOOST_MOVE_CAT_I(a, b) a ## b
+//# define BOOST_MOVE_CAT_I(a, b) BOOST_MOVE_CAT_II(~, a ## b)
+//# define BOOST_MOVE_CAT_II(p, res) res
+
+#endif //#ifndef BOOST_MOVE_DETAIL_FWD_MACROS_HPP
diff --git a/contrib/src/boost/move/detail/iterator_traits.hpp b/contrib/src/boost/move/detail/iterator_traits.hpp
index b1f1d9e..5ffcb2c 100644
--- a/contrib/src/boost/move/detail/iterator_traits.hpp
+++ b/contrib/src/boost/move/detail/iterator_traits.hpp
@@ -1,77 +1,77 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2014-2014.
-// 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_ITERATOR_TRAITS_HPP
-#define BOOST_MOVE_DETAIL_ITERATOR_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-# include <boost/config.hpp>
-#endif
-#
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-# pragma once
-#endif
-
-#include <cstddef>
-#include <boost/move/detail/type_traits.hpp>
-
-#include <boost/move/detail/std_ns_begin.hpp>
-BOOST_MOVE_STD_NS_BEG
-
-struct input_iterator_tag;
-struct forward_iterator_tag;
-struct bidirectional_iterator_tag;
-struct random_access_iterator_tag;
-struct output_iterator_tag;
-
-BOOST_MOVE_STD_NS_END
-#include <boost/move/detail/std_ns_end.hpp>
-
-namespace boost{ namespace movelib{
-
-template<class Iterator>
-struct iterator_traits
-{
- typedef typename Iterator::difference_type difference_type;
- typedef typename Iterator::value_type value_type;
- typedef typename Iterator::pointer pointer;
- typedef typename Iterator::reference reference;
- typedef typename Iterator::iterator_category iterator_category;
- typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
-};
-
-template<class T>
-struct iterator_traits<T*>
-{
- typedef std::ptrdiff_t difference_type;
- typedef T value_type;
- typedef T* pointer;
- typedef T& reference;
- typedef std::random_access_iterator_tag iterator_category;
- typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
-};
-
-template<class T>
-struct iterator_traits<const T*>
-{
- typedef std::ptrdiff_t difference_type;
- typedef T value_type;
- typedef const T* pointer;
- typedef const T& reference;
- typedef std::random_access_iterator_tag iterator_category;
- typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
-};
-
-}} //namespace boost { namespace movelib{
-
-#endif //#ifndef BOOST_MOVE_DETAIL_ITERATOR_TRAITS_HPP
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014.
+// 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_ITERATOR_TRAITS_HPP
+#define BOOST_MOVE_DETAIL_ITERATOR_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <cstddef>
+#include <boost/move/detail/type_traits.hpp>
+
+#include <boost/move/detail/std_ns_begin.hpp>
+BOOST_MOVE_STD_NS_BEG
+
+struct input_iterator_tag;
+struct forward_iterator_tag;
+struct bidirectional_iterator_tag;
+struct random_access_iterator_tag;
+struct output_iterator_tag;
+
+BOOST_MOVE_STD_NS_END
+#include <boost/move/detail/std_ns_end.hpp>
+
+namespace boost{ namespace movelib{
+
+template<class Iterator>
+struct iterator_traits
+{
+ typedef typename Iterator::difference_type difference_type;
+ typedef typename Iterator::value_type value_type;
+ typedef typename Iterator::pointer pointer;
+ typedef typename Iterator::reference reference;
+ typedef typename Iterator::iterator_category iterator_category;
+ typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
+};
+
+template<class T>
+struct iterator_traits<T*>
+{
+ typedef std::ptrdiff_t difference_type;
+ typedef T value_type;
+ typedef T* pointer;
+ typedef T& reference;
+ typedef std::random_access_iterator_tag iterator_category;
+ typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
+};
+
+template<class T>
+struct iterator_traits<const T*>
+{
+ typedef std::ptrdiff_t difference_type;
+ typedef T value_type;
+ typedef const T* pointer;
+ typedef const T& reference;
+ typedef std::random_access_iterator_tag iterator_category;
+ typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
+};
+
+}} //namespace boost { namespace movelib{
+
+#endif //#ifndef BOOST_MOVE_DETAIL_ITERATOR_TRAITS_HPP
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
diff --git a/contrib/src/boost/move/detail/meta_utils_core.hpp b/contrib/src/boost/move/detail/meta_utils_core.hpp
index 30f8730..4d715a0 100644
--- a/contrib/src/boost/move/detail/meta_utils_core.hpp
+++ b/contrib/src/boost/move/detail/meta_utils_core.hpp
@@ -1,132 +1,120 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2015-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_CORE_HPP
-#define BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP
-
-#ifndef BOOST_CONFIG_HPP
-# include <boost/config.hpp>
-#endif
-#
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-# pragma once
-#endif
-
-//Small meta-typetraits to support move
-
-namespace boost {
-namespace move_detail {
-
-//////////////////////////////////////
-// if_c
-//////////////////////////////////////
-template<bool C, typename T1, typename T2>
-struct if_c
-{
- typedef T1 type;
-};
-
-template<typename T1, typename T2>
-struct if_c<false,T1,T2>
-{
- typedef T2 type;
-};
-
-//////////////////////////////////////
-// if_
-//////////////////////////////////////
-template<typename T1, typename T2, typename T3>
-struct if_ : if_c<0 != T1::value, T2, T3>
-{};
-
-//////////////////////////////////////
-// enable_if_c
-//////////////////////////////////////
-template <bool B, class T = void>
-struct enable_if_c
-{
- typedef T type;
-};
-
-template <class T>
-struct enable_if_c<false, T> {};
-
-//////////////////////////////////////
-// enable_if
-//////////////////////////////////////
-template <class Cond, class T = void>
-struct enable_if : enable_if_c<Cond::value, T> {};
-
-//////////////////////////////////////
-// disable_if_c
-//////////////////////////////////////
-template <bool B, class T = void>
-struct disable_if_c
- : enable_if_c<!B, T>
-{};
-
-//////////////////////////////////////
-// disable_if
-//////////////////////////////////////
-template <class Cond, class T = void>
-struct disable_if : enable_if_c<!Cond::value, T> {};
-
-//////////////////////////////////////
-// integral_constant
-//////////////////////////////////////
-template<class T, T v>
-struct integral_constant
-{
- static const T value = v;
- typedef T value_type;
- typedef integral_constant<T, v> type;
-
- operator T() const { return value; }
- T operator()() const { return value; }
-};
-
-typedef integral_constant<bool, true > true_type;
-typedef integral_constant<bool, false > false_type;
-
-
-//////////////////////////////////////
-// is_same
-//////////////////////////////////////
-template<class T, class U>
-struct is_same
-{
- static const bool value = false;
-};
-
-template<class T>
-struct is_same<T, T>
-{
- static const bool value = true;
-};
-
-//////////////////////////////////////
-// enable_if_same
-//////////////////////////////////////
-template <class T, class U, class R = void>
-struct enable_if_same : enable_if<is_same<T, U>, R> {};
-
-//////////////////////////////////////
-// disable_if_same
-//////////////////////////////////////
-template <class T, class U, class R = void>
-struct disable_if_same : disable_if<is_same<T, U>, R> {};
-
-} //namespace move_detail {
-} //namespace boost {
-
-#endif //#ifndef BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-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_CORE_HPP
+#define BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+//Small meta-typetraits to support move
+
+namespace boost {
+namespace move_detail {
+
+//////////////////////////////////////
+// if_c
+//////////////////////////////////////
+template<bool C, typename T1, typename T2>
+struct if_c
+{
+ typedef T1 type;
+};
+
+template<typename T1, typename T2>
+struct if_c<false,T1,T2>
+{
+ typedef T2 type;
+};
+
+//////////////////////////////////////
+// if_
+//////////////////////////////////////
+template<typename T1, typename T2, typename T3>
+struct if_ : if_c<0 != T1::value, T2, T3>
+{};
+
+//////////////////////////////////////
+// enable_if_c
+//////////////////////////////////////
+template <bool B, class T = void>
+struct enable_if_c
+{
+ typedef T type;
+};
+
+template <class T>
+struct enable_if_c<false, T> {};
+
+//////////////////////////////////////
+// enable_if
+//////////////////////////////////////
+template <class Cond, class T = void>
+struct enable_if : enable_if_c<Cond::value, T> {};
+
+//////////////////////////////////////
+// disable_if_c
+//////////////////////////////////////
+template <bool B, class T = void>
+struct disable_if_c
+ : enable_if_c<!B, T>
+{};
+
+//////////////////////////////////////
+// disable_if
+//////////////////////////////////////
+template <class Cond, class T = void>
+struct disable_if : enable_if_c<!Cond::value, T> {};
+
+//////////////////////////////////////
+// integral_constant
+//////////////////////////////////////
+template<class T, T v>
+struct integral_constant
+{
+ static const T value = v;
+ typedef T value_type;
+ typedef integral_constant<T, v> type;
+
+ operator T() const { return value; }
+ T operator()() const { return value; }
+};
+
+typedef integral_constant<bool, true > true_type;
+typedef integral_constant<bool, false > false_type;
+
+
+//////////////////////////////////////
+// is_same
+//////////////////////////////////////
+template<class T, class U>
+struct is_same
+{
+ static const bool value = false;
+};
+
+template<class T>
+struct is_same<T, T>
+{
+ static const bool value = true;
+};
+
+} //namespace move_detail {
+} //namespace boost {
+
+#endif //#ifndef BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP
diff --git a/contrib/src/boost/move/detail/move_helpers.hpp b/contrib/src/boost/move/detail/move_helpers.hpp
new file mode 100644
index 0000000..a2502bf
--- /dev/null
+++ b/contrib/src/boost/move/detail/move_helpers.hpp
@@ -0,0 +1,256 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2010-2016.
+// 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_MOVE_HELPERS_HPP
+#define BOOST_MOVE_MOVE_HELPERS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/move/core.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/move/detail/type_traits.hpp>
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+#define BOOST_MOVE_CATCH_CONST(U) \
+ typename ::boost::move_detail::if_< ::boost::move_detail::is_class<U>, BOOST_CATCH_CONST_RLVALUE(U), const U &>::type
+#define BOOST_MOVE_CATCH_RVALUE(U)\
+ typename ::boost::move_detail::if_< ::boost::move_detail::is_class<U>, BOOST_RV_REF(U), ::boost::move_detail::nat>::type
+#define BOOST_MOVE_CATCH_FWD(U) BOOST_FWD_REF(U)
+#else
+#define BOOST_MOVE_CATCH_CONST(U) const U &
+#define BOOST_MOVE_CATCH_RVALUE(U) U &&
+#define BOOST_MOVE_CATCH_FWD(U) U &&
+#endif
+
+////////////////////////////////////////
+//
+// BOOST_MOVE_CONVERSION_AWARE_CATCH
+//
+////////////////////////////////////////
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+ template<class RETURN_VALUE, class BOOST_MOVE_TEMPL_PARAM, class TYPE>
+ struct boost_move_conversion_aware_catch_1
+ : public ::boost::move_detail::enable_if_and
+ < RETURN_VALUE
+ , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>
+ , ::boost::move_detail::is_class<TYPE>
+ , ::boost::has_move_emulation_disabled<BOOST_MOVE_TEMPL_PARAM>
+ >
+ {};
+
+ template<class RETURN_VALUE, class BOOST_MOVE_TEMPL_PARAM, class TYPE>
+ struct boost_move_conversion_aware_catch_2
+ : public ::boost::move_detail::disable_if_or
+ < RETURN_VALUE
+ , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>
+ , ::boost::move_detail::is_rv_impl<BOOST_MOVE_TEMPL_PARAM>
+ , ::boost::move_detail::and_
+ < ::boost::move_detail::is_rv_impl<BOOST_MOVE_TEMPL_PARAM>
+ , ::boost::move_detail::is_class<BOOST_MOVE_TEMPL_PARAM>
+ >
+ >
+ {};
+
+ #define BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
+ \
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(::boost::move(x)); }\
+ \
+ RETURN_VALUE PUB_FUNCTION(TYPE &x)\
+ { return FWD_FUNCTION(const_cast<const TYPE &>(x)); }\
+ //
+ #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
+ #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
+ \
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+ typename boost_move_conversion_aware_catch_1< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
+ { return FWD_FUNCTION(u); }\
+ \
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+ typename boost_move_conversion_aware_catch_2< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
+ {\
+ TYPE t((u));\
+ return FWD_FUNCTION(::boost::move(t));\
+ }\
+ //
+ #else
+ #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
+ \
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename boost_move_conversion_aware_catch_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
+ PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
+ { return FWD_FUNCTION(u); }\
+ \
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename boost_move_conversion_aware_catch_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
+ PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
+ {\
+ TYPE t((u));\
+ return FWD_FUNCTION(::boost::move(t));\
+ }\
+ //
+ #endif
+#elif (defined(_MSC_VER) && (_MSC_VER == 1600))
+
+ #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
+ \
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(::boost::move(x)); }\
+ \
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename ::boost::move_detail::enable_if_c\
+ < !::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value\
+ , RETURN_VALUE >::type\
+ PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
+ {\
+ TYPE t((u));\
+ return FWD_FUNCTION(::boost::move(t));\
+ }\
+ //
+
+#else //BOOST_NO_CXX11_RVALUE_REFERENCES
+
+ #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
+ \
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(::boost::move(x)); }\
+ //
+
+#endif //BOOST_NO_CXX11_RVALUE_REFERENCES
+
+////////////////////////////////////////
+//
+// BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG
+//
+////////////////////////////////////////
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+ template<class RETURN_VALUE, class BOOST_MOVE_TEMPL_PARAM, class UNLESS_CONVERTIBLE_TO, class TYPE>
+ struct boost_move_conversion_aware_catch_1arg_1
+ : public ::boost::move_detail::enable_if_and
+ < RETURN_VALUE
+ , ::boost::move_detail::not_< ::boost::move_detail::is_same_or_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO> >
+ , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>
+ , ::boost::has_move_emulation_disabled<BOOST_MOVE_TEMPL_PARAM>
+ >
+ {};
+
+ template<class RETURN_VALUE, class BOOST_MOVE_TEMPL_PARAM, class UNLESS_CONVERTIBLE_TO, class TYPE>
+ struct boost_move_conversion_aware_catch_1arg_2
+ : public ::boost::move_detail::disable_if_or
+ < RETURN_VALUE
+ , ::boost::move_detail::is_same_or_convertible< BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO>
+ , ::boost::move_detail::is_rv_impl<BOOST_MOVE_TEMPL_PARAM>
+ , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>
+ >
+ {};
+
+ #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
+ \
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(arg1, ::boost::move(x)); }\
+ \
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
+ { return FWD_FUNCTION(arg1, const_cast<const TYPE &>(x)); }\
+ //
+ #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
+ #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
+ \
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+ typename boost_move_conversion_aware_catch_1arg_1<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
+ { return FWD_FUNCTION(arg1, u); }\
+ \
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+ typename boost_move_conversion_aware_catch_1arg_2<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
+ {\
+ TYPE t((u));\
+ return FWD_FUNCTION(arg1, ::boost::move(t));\
+ }\
+ //
+ #else
+ #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
+ \
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename boost_move_conversion_aware_catch_1arg_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
+ PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
+ { return FWD_FUNCTION(arg1, u); }\
+ \
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename boost_move_conversion_aware_catch_1arg_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
+ PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
+ {\
+ TYPE t((u));\
+ return FWD_FUNCTION(arg1, ::boost::move(t));\
+ }\
+ //
+ #endif
+
+#elif (defined(_MSC_VER) && (_MSC_VER == 1600))
+
+ #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
+ \
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(arg1, ::boost::move(x)); }\
+ \
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename ::boost::move_detail::disable_if_or\
+ < RETURN_VALUE \
+ , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM> \
+ , ::boost::move_detail::is_same_or_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO> \
+ >::type\
+ PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
+ {\
+ TYPE t((u));\
+ return FWD_FUNCTION(arg1, ::boost::move(t));\
+ }\
+ //
+
+#else
+
+ #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
+ \
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(arg1, ::boost::move(x)); }\
+ //
+
+#endif
+
+#endif //#ifndef BOOST_MOVE_MOVE_HELPERS_HPP
diff --git a/contrib/src/boost/move/detail/std_ns_begin.hpp b/contrib/src/boost/move/detail/std_ns_begin.hpp
index a178b62..a768e61 100644
--- a/contrib/src/boost/move/detail/std_ns_begin.hpp
+++ b/contrib/src/boost/move/detail/std_ns_begin.hpp
@@ -1,30 +1,30 @@
-#//////////////////////////////////////////////////////////////////////////////
-#//
-#// (C) Copyright Ion Gaztanaga 2015-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.
-#//
-#//////////////////////////////////////////////////////////////////////////////
-#
-#if defined(_LIBCPP_VERSION)
- #if defined(__clang__)
- #define BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wc++11-extensions"
- #endif
- #define BOOST_MOVE_STD_NS_BEG _LIBCPP_BEGIN_NAMESPACE_STD
- #define BOOST_MOVE_STD_NS_END _LIBCPP_END_NAMESPACE_STD
-#elif defined(BOOST_GNU_STDLIB) && defined(_GLIBCXX_BEGIN_NAMESPACE_VERSION) //GCC >= 4.6
- #define BOOST_MOVE_STD_NS_BEG namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION
- #define BOOST_MOVE_STD_NS_END _GLIBCXX_END_NAMESPACE_VERSION } // namespace
-#elif defined(BOOST_GNU_STDLIB) && defined(_GLIBCXX_BEGIN_NAMESPACE) //GCC >= 4.2
- #define BOOST_MOVE_STD_NS_BEG _GLIBCXX_BEGIN_NAMESPACE(std)
- #define BOOST_MOVE_STD_NS_END _GLIBCXX_END_NAMESPACE
-#else
- #define BOOST_MOVE_STD_NS_BEG namespace std{
- #define BOOST_MOVE_STD_NS_END }
-#endif
-
+#//////////////////////////////////////////////////////////////////////////////
+#//
+#// (C) Copyright Ion Gaztanaga 2015-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.
+#//
+#//////////////////////////////////////////////////////////////////////////////
+#
+#if defined(_LIBCPP_VERSION)
+ #if defined(__clang__)
+ #define BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wc++11-extensions"
+ #endif
+ #define BOOST_MOVE_STD_NS_BEG _LIBCPP_BEGIN_NAMESPACE_STD
+ #define BOOST_MOVE_STD_NS_END _LIBCPP_END_NAMESPACE_STD
+#elif defined(BOOST_GNU_STDLIB) && defined(_GLIBCXX_BEGIN_NAMESPACE_VERSION) //GCC >= 4.6
+ #define BOOST_MOVE_STD_NS_BEG namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ #define BOOST_MOVE_STD_NS_END _GLIBCXX_END_NAMESPACE_VERSION } // namespace
+#elif defined(BOOST_GNU_STDLIB) && defined(_GLIBCXX_BEGIN_NAMESPACE) //GCC >= 4.2
+ #define BOOST_MOVE_STD_NS_BEG _GLIBCXX_BEGIN_NAMESPACE(std)
+ #define BOOST_MOVE_STD_NS_END _GLIBCXX_END_NAMESPACE
+#else
+ #define BOOST_MOVE_STD_NS_BEG namespace std{
+ #define BOOST_MOVE_STD_NS_END }
+#endif
+
diff --git a/contrib/src/boost/move/detail/std_ns_end.hpp b/contrib/src/boost/move/detail/std_ns_end.hpp
index 39ce411..0975059 100644
--- a/contrib/src/boost/move/detail/std_ns_end.hpp
+++ b/contrib/src/boost/move/detail/std_ns_end.hpp
@@ -1,14 +1,14 @@
-#//////////////////////////////////////////////////////////////////////////////
-#//
-#// (C) Copyright Ion Gaztanaga 2015-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.
-#//
-#//////////////////////////////////////////////////////////////////////////////
-#ifdef BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
- #pragma GCC diagnostic pop
- #undef BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
-#endif //BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
+#//////////////////////////////////////////////////////////////////////////////
+#//
+#// (C) Copyright Ion Gaztanaga 2015-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.
+#//
+#//////////////////////////////////////////////////////////////////////////////
+#ifdef BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
+ #pragma GCC diagnostic pop
+ #undef BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
+#endif //BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
diff --git a/contrib/src/boost/move/detail/type_traits.hpp b/contrib/src/boost/move/detail/type_traits.hpp
index bdd557c..816fdca 100644
--- a/contrib/src/boost/move/detail/type_traits.hpp
+++ b/contrib/src/boost/move/detail/type_traits.hpp
@@ -1,1072 +1,1078 @@
-//////////////////////////////////////////////////////////////////////////////
-// (C) Copyright John Maddock 2000.
-// (C) Copyright Ion Gaztanaga 2005-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.
-//
-// The alignment and Type traits implementation comes from
-// John Maddock's TypeTraits library.
-//
-// Some other tricks come from Howard Hinnant's papers and StackOverflow replies
-//////////////////////////////////////////////////////////////////////////////
-#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP
-#define BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-# include <boost/config.hpp>
-#endif
-#
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-# pragma once
-#endif
-
-#include <boost/move/detail/config_begin.hpp>
-#include <boost/move/detail/workaround.hpp>
-
-// move/detail
-#include <boost/move/detail/meta_utils.hpp>
-// other
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
-// std
-#include <cstddef>
-
-//Use of Boost.TypeTraits leads to long preprocessed source code due to
-//MPL dependencies. We'll use intrinsics directly and make or own
-//simplified version of TypeTraits.
-//If someday Boost.TypeTraits dependencies are minimized, we should
-//revisit this file redirecting code to Boost.TypeTraits traits.
-
-//These traits don't care about volatile, reference or other checks
-//made by Boost.TypeTraits because no volatile or reference types
-//can be hold in Boost.Containers. This helps to avoid any Boost.TypeTraits
-//dependency.
-
-// Helper macros for builtin compiler support.
-// If your compiler has builtin support for any of the following
-// traits concepts, then redefine the appropriate macros to pick
-// up on the compiler support:
-//
-// (these should largely ignore cv-qualifiers)
-// BOOST_MOVE_IS_POD(T) should evaluate to true if T is a POD type
-// BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect
-// BOOST_MOVE_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
-// (Note: this trait does not guarantee T is copy constructible, the copy constructor could be deleted but still be trivial)
-// BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) should evaluate to true if T(boost::move(t)) <==> memcpy
-// BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
-// (Note: this trait does not guarantee T is assignable , the copy assignmen could be deleted but still be trivial)
-// BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) should evaluate to true if t = boost::move(u) <==> memcpy
-// BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect
-// BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw
-// BOOST_MOVE_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw
-// BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw
-// BOOST_MOVE_IS_ENUM(T) should evaluate to true it t is a union type.
-//
-// The following can also be defined: when detected our implementation is greatly simplified.
-//
-// BOOST_ALIGNMENT_OF(T) should evaluate to the alignment requirements of type T.
-
-#if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000)
- // Metrowerks compiler is acquiring intrinsic type traits support
- // post version 8. We hook into the published interface to pick up
- // user defined specializations as well as compiler intrinsics as
- // and when they become available:
-# include <msl_utility>
-# define BOOST_MOVE_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union<T>::value
-# define BOOST_MOVE_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD<T>::value
-# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor<T>::value
-# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor<T>::value
-# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment<T>::value
-# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor<T>::value
-#endif
-
-#if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\
- || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500))
-# define BOOST_MOVE_IS_UNION(T) __is_union(T)
-# define BOOST_MOVE_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T))
-# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
-# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
-# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T)|| ::boost::move_detail::is_pod<T>::value)
-# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) || ::boost::move_detail::is_pod<T>::value)
-# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) || ::boost::move_detail::is_pod<T>::value)
-# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) || ::boost::move_detail::is_trivially_default_constructible<T>::value)
-# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) || ::boost::move_detail::is_trivially_copy_constructible<T>::value)
-# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) || ::boost::move_detail::is_trivially_copy_assignable<T>::value)
-
-# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
-# if defined(_MSC_VER) && (_MSC_VER >= 1700)
-# define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__has_trivial_move_constructor(T) || ::boost::move_detail::is_pod<T>::value)
-# define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) (__has_trivial_move_assign(T) || ::boost::move_detail::is_pod<T>::value)
-# endif
-#endif
-
-#if defined(BOOST_CLANG) && defined(__has_feature)
-
-# if __has_feature(is_union)
-# define BOOST_MOVE_IS_UNION(T) __is_union(T)
-# endif
-# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_pod)
-# define BOOST_MOVE_IS_POD(T) __is_pod(T)
-# endif
-# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty)
-# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
-# endif
-# if __has_feature(has_trivial_constructor)
-# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
-# endif
-# if __has_feature(has_trivial_copy)
-# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) __has_trivial_copy(T)
-# endif
-# if __has_feature(has_trivial_assign)
-# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) )
-# endif
-# if __has_feature(has_trivial_destructor)
-# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
-# endif
-# if __has_feature(has_nothrow_constructor)
-# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
-# endif
-# if __has_feature(has_nothrow_copy)
-# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T))
-# endif
-# if __has_feature(is_nothrow_copy_assignable)
-# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T))
-# endif
-# if __has_feature(is_enum)
-# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
-# endif
-# if __has_feature(has_trivial_move_constructor)
-# define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) __has_trivial_move_constructor(T)
-# endif
-# if __has_feature(has_trivial_move_assign)
-# define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) __has_trivial_move_assign(T)
-# endif
-# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof(T)
-#endif
-
-#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG)
-
-#ifdef BOOST_INTEL
-# define BOOST_MOVE_INTEL_TT_OPTS || ::boost::move_detail::is_pod<T>::value
-#else
-# define BOOST_MOVE_INTEL_TT_OPTS
-#endif
-
-# define BOOST_MOVE_IS_UNION(T) __is_union(T)
-# define BOOST_MOVE_IS_POD(T) __is_pod(T)
-# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
-# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_MOVE_INTEL_TT_OPTS))
-# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_MOVE_INTEL_TT_OPTS))
-# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_MOVE_INTEL_TT_OPTS) )
-# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_MOVE_INTEL_TT_OPTS)
-# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_MOVE_INTEL_TT_OPTS)
-# define BOOST_MOVE_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_MOVE_INTEL_TT_OPTS))
-# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_MOVE_INTEL_TT_OPTS))
-
-# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
-# if (!defined(unix) && !defined(__unix__)) || defined(__LP64__)
- // GCC sometimes lies about alignment requirements
- // of type double on 32-bit unix platforms, use the
- // old implementation instead in that case:
-# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T)
-# endif
-#endif
-
-#if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600)
-
-# define BOOST_MOVE_IS_UNION(T) __is_union(T)
-# define BOOST_MOVE_IS_POD(T) __is_pod(T)
-# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
-# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
-# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T))
-# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T))
-# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
-# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
-# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T))
-# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T))
-
-# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
-# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T)
-#endif
-
-# if defined(__CODEGEARC__)
-# define BOOST_MOVE_IS_UNION(T) __is_union(T)
-# define BOOST_MOVE_IS_POD(T) __is_pod(T)
-# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
-# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_default_constructor(T))
-# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy_constructor(T))
-# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T))
-# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T))
-# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_default_constructor(T))
-# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy_constructor(T))
-# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T))
-
-# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
-# define BOOST_MOVE_ALIGNMENT_OF(T) alignof(T)
-
-#endif
-
-//Fallback definitions
-
-#ifdef BOOST_MOVE_IS_UNION
- #define BOOST_MOVE_IS_UNION_IMPL(T) BOOST_MOVE_IS_UNION(T)
-#else
- #define BOOST_MOVE_IS_UNION_IMPL(T) false
-#endif
-
-#ifdef BOOST_MOVE_IS_POD
- //in some compilers the intrinsic is limited to class types so add scalar and void
- #define BOOST_MOVE_IS_POD_IMPL(T) (::boost::move_detail::is_scalar<T>::value ||\
- ::boost::move_detail::is_void<T>::value ||\
- BOOST_MOVE_IS_POD(T))
-#else
- #define BOOST_MOVE_IS_POD_IMPL(T) \
- (::boost::move_detail::is_scalar<T>::value || ::boost::move_detail::is_void<T>::value)
-#endif
-
-#ifdef BOOST_MOVE_IS_EMPTY
- #define BOOST_MOVE_IS_EMPTY_IMPL(T) BOOST_MOVE_IS_EMPTY(T)
-#else
- #define BOOST_MOVE_IS_EMPTY_IMPL(T) ::boost::move_detail::is_empty_nonintrinsic<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_TRIVIAL_COPY
- #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value ||\
- (::boost::move_detail::is_copy_constructible<T>::value &&\
- BOOST_MOVE_HAS_TRIVIAL_COPY(T))
-#else
- #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR
- #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T)
-#else
- #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR
- #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)
-#else
- #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_TRIVIAL_ASSIGN
- #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value ||\
- ( ::boost::move_detail::is_copy_assignable<T>::value &&\
- BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T))
-#else
- #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN
- #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T)
-#else
- #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR
- #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T)
-#else
- #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR
- #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T)
-#else
- #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_NOTHROW_COPY
- #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_COPY(T)
-#else
- #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_NOTHROW_MOVE
- #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE(T)
-#else
- #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_NOTHROW_ASSIGN
- #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_ASSIGN(T)
-#else
- #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN
- #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T)
-#else
- #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
-#ifdef BOOST_MOVE_IS_ENUM
- #define BOOST_MOVE_IS_ENUM_IMPL(T) BOOST_MOVE_IS_ENUM(T)
-#else
- #define BOOST_MOVE_IS_ENUM_IMPL(T) ::boost::move_detail::is_enum_nonintrinsic<T>::value
-#endif
-
-namespace boost {
-namespace move_detail {
-
-//////////////////////////
-// is_reference
-//////////////////////////
-template<class T>
-struct is_reference
-{ static const bool value = false; };
-
-template<class T>
-struct is_reference<T&>
-{ static const bool value = true; };
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template<class T>
-struct is_reference<T&&>
-{ static const bool value = true; };
-#endif
-
-//////////////////////////
-// is_pointer
-//////////////////////////
-template<class T>
-struct is_pointer
-{ static const bool value = false; };
-
-template<class T>
-struct is_pointer<T*>
-{ static const bool value = true; };
-
-//////////////////////////
-// is_const
-//////////////////////////
-template<class T>
-struct is_const
-{ static const bool value = false; };
-
-template<class T>
-struct is_const<const T>
-{ static const bool value = true; };
-
-//////////////////////////
-// unvoid_ref
-//////////////////////////
-template <typename T> struct unvoid_ref : add_lvalue_reference<T>{};
-template <> struct unvoid_ref<void> { typedef unvoid_ref & type; };
-template <> struct unvoid_ref<const void> { typedef unvoid_ref & type; };
-template <> struct unvoid_ref<volatile void> { typedef unvoid_ref & type; };
-template <> struct unvoid_ref<const volatile void> { typedef unvoid_ref & type; };
-
-template <typename T>
-struct add_reference : add_lvalue_reference<T>
-{};
-
-//////////////////////////
-// add_const_reference
-//////////////////////////
-template <class T>
-struct add_const_reference
-{ typedef const T &type; };
-
-template <class T>
-struct add_const_reference<T&>
-{ typedef T& type; };
-
-//////////////////////////
-// add_const_if_c
-//////////////////////////
-template<class T, bool Add>
-struct add_const_if_c
- : if_c<Add, typename add_const<T>::type, T>
-{};
-
-//////////////////////////
-// remove_const
-//////////////////////////
-template<class T>
-struct remove_const
-{ typedef T type; };
-
-template<class T>
-struct remove_const< const T>
-{ typedef T type; };
-
-//////////////////////////
-// remove_cv
-//////////////////////////
-template<typename T> struct remove_cv { typedef T type; };
-template<typename T> struct remove_cv<const T> { typedef T type; };
-template<typename T> struct remove_cv<const volatile T> { typedef T type; };
-template<typename T> struct remove_cv<volatile T> { typedef T type; };
-
-//////////////////////////
-// make_unsigned
-//////////////////////////
-template <class T>
-struct make_unsigned_impl { typedef T type; };
-template <> struct make_unsigned_impl<signed char> { typedef unsigned char type; };
-template <> struct make_unsigned_impl<signed short> { typedef unsigned short type; };
-template <> struct make_unsigned_impl<signed int> { typedef unsigned int type; };
-template <> struct make_unsigned_impl<signed long> { typedef unsigned long type; };
-#ifdef BOOST_HAS_LONG_LONG
-template <> struct make_unsigned_impl< ::boost::long_long_type > { typedef ::boost::ulong_long_type type; };
-#endif
-
-template <class T>
-struct make_unsigned
- : make_unsigned_impl<typename remove_cv<T>::type>
-{};
-
-//////////////////////////
-// is_floating_point
-//////////////////////////
-template<class T> struct is_floating_point_cv { static const bool value = false; };
-template<> struct is_floating_point_cv<float> { static const bool value = true; };
-template<> struct is_floating_point_cv<double> { static const bool value = true; };
-template<> struct is_floating_point_cv<long double> { static const bool value = true; };
-
-template<class T>
-struct is_floating_point
- : is_floating_point_cv<typename remove_cv<T>::type>
-{};
-
-//////////////////////////
-// is_integral
-//////////////////////////
-template<class T> struct is_integral_cv { static const bool value = false; };
-template<> struct is_integral_cv< bool>{ static const bool value = true; };
-template<> struct is_integral_cv< char>{ static const bool value = true; };
-template<> struct is_integral_cv< unsigned char>{ static const bool value = true; };
-template<> struct is_integral_cv< signed char>{ static const bool value = true; };
-#ifndef BOOST_NO_CXX11_CHAR16_T
-template<> struct is_integral_cv< char16_t>{ static const bool value = true; };
-#endif
-#ifndef BOOST_NO_CXX11_CHAR32_T
-template<> struct is_integral_cv< char32_t>{ static const bool value = true; };
-#endif
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<> struct is_integral_cv< wchar_t>{ static const bool value = true; };
-#endif
-template<> struct is_integral_cv< short>{ static const bool value = true; };
-template<> struct is_integral_cv< unsigned short>{ static const bool value = true; };
-template<> struct is_integral_cv< int>{ static const bool value = true; };
-template<> struct is_integral_cv< unsigned int>{ static const bool value = true; };
-template<> struct is_integral_cv< long>{ static const bool value = true; };
-template<> struct is_integral_cv< unsigned long>{ static const bool value = true; };
-#ifdef BOOST_HAS_LONG_LONG
-template<> struct is_integral_cv< ::boost:: long_long_type>{ static const bool value = true; };
-template<> struct is_integral_cv< ::boost::ulong_long_type>{ static const bool value = true; };
-#endif
-
-template<class T>
-struct is_integral
- : public is_integral_cv<typename remove_cv<T>::type>
-{};
-
-//////////////////////////////////////
-// remove_all_extents
-//////////////////////////////////////
-template <class T>
-struct remove_all_extents
-{ typedef T type;};
-
-template <class T>
-struct remove_all_extents<T[]>
-{ typedef typename remove_all_extents<T>::type type; };
-
-template <class T, std::size_t N>
-struct remove_all_extents<T[N]>
-{ typedef typename remove_all_extents<T>::type type;};
-
-//////////////////////////
-// is_scalar
-//////////////////////////
-template<class T>
-struct is_scalar
-{ static const bool value = is_integral<T>::value || is_floating_point<T>::value; };
-
-//////////////////////////
-// is_void
-//////////////////////////
-template<class T>
-struct is_void_cv
-{ static const bool value = false; };
-
-template<>
-struct is_void_cv<void>
-{ static const bool value = true; };
-
-template<class T>
-struct is_void
- : is_void_cv<typename remove_cv<T>::type>
-{};
-
-//////////////////////////////////////
-// is_array
-//////////////////////////////////////
-template<class T>
-struct is_array
-{ static const bool value = false; };
-
-template<class T>
-struct is_array<T[]>
-{ static const bool value = true; };
-
-template<class T, std::size_t N>
-struct is_array<T[N]>
-{ static const bool value = true; };
-
-//////////////////////////////////////
-// is_member_pointer
-//////////////////////////////////////
-template <class T> struct is_member_pointer_cv { static const bool value = false; };
-template <class T, class U>struct is_member_pointer_cv<T U::*> { static const bool value = true; };
-
-template <class T>
-struct is_member_pointer
- : is_member_pointer_cv<typename remove_cv<T>::type>
-{};
-
-//////////////////////////////////////
-// is_nullptr_t
-//////////////////////////////////////
-template <class T>
-struct is_nullptr_t_cv
-{ static const bool value = false; };
-
-#if !defined(BOOST_NO_CXX11_NULLPTR)
-template <>
-struct is_nullptr_t_cv
- #if !defined(BOOST_NO_CXX11_DECLTYPE)
- <decltype(nullptr)>
- #else
- <std::nullptr_t>
- #endif
-{ static const bool value = true; };
-#endif
-
-template <class T>
-struct is_nullptr_t
- : is_nullptr_t_cv<typename remove_cv<T>::type>
-{};
-
-//////////////////////////////////////
-// is_function
-//////////////////////////////////////
-//Inspired by libc++, thanks to Howard Hinnant
-//For a function to pointer an lvalue of function type T can be implicitly converted to a prvalue
-//pointer to that function. This does not apply to non-static member functions because lvalues
-//that refer to non-static member functions do not exist.
-template <class T>
-struct is_reference_convertible_to_pointer
-{
- struct twochar { char dummy[2]; };
- template <class U> static char test(U*);
- template <class U> static twochar test(...);
- static T& source();
- static const bool value = sizeof(char) == sizeof(test<T>(source()));
-};
-//Filter out:
-// - class types that might have implicit conversions
-// - void (to avoid forming a reference to void later)
-// - references (e.g.: filtering reference to functions)
-// - nullptr_t (convertible to pointer)
-template < class T
- , bool Filter = is_class_or_union<T>::value ||
- is_void<T>::value ||
- is_reference<T>::value ||
- is_nullptr_t<T>::value >
-struct is_function_impl
-{ static const bool value = is_reference_convertible_to_pointer<T>::value; };
-
-template <class T>
-struct is_function_impl<T, true>
-{ static const bool value = false; };
-
-template <class T>
-struct is_function
- : is_function_impl<T>
-{};
-
-//////////////////////////////////////
-// is_union
-//////////////////////////////////////
-template<class T>
-struct is_union_noextents_cv
-{ static const bool value = BOOST_MOVE_IS_UNION_IMPL(T); };
-
-template<class T>
-struct is_union
- : is_union_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type>
-{};
-
-//////////////////////////////////////
-// is_class
-//////////////////////////////////////
-template <class T>
-struct is_class
-{
- static const bool value = is_class_or_union<T>::value && ! is_union<T>::value;
-};
-
-
-//////////////////////////////////////
-// is_arithmetic
-//////////////////////////////////////
-template <class T>
-struct is_arithmetic
-{
- static const bool value = is_floating_point<T>::value ||
- is_integral<T>::value;
-};
-
-//////////////////////////////////////
-// is_member_function_pointer
-//////////////////////////////////////
-template <class T>
-struct is_member_function_pointer_cv
-{
- static const bool value = false;
-};
-
-template <class T, class C>
-struct is_member_function_pointer_cv<T C::*>
- : is_function<T>
-{};
-
-template <class T>
-struct is_member_function_pointer
- : is_member_function_pointer_cv<typename remove_cv<T>::type>
-{};
-
-//////////////////////////////////////
-// is_enum
-//////////////////////////////////////
-#if !defined(BOOST_MOVE_IS_ENUM)
-//Based on (http://howardhinnant.github.io/TypeHiearchy.pdf)
-template <class T>
-struct is_enum_nonintrinsic
-{
- static const bool value = !is_arithmetic<T>::value &&
- !is_reference<T>::value &&
- !is_class_or_union<T>::value &&
- !is_array<T>::value &&
- !is_void<T>::value &&
- !is_nullptr_t<T>::value &&
- !is_member_pointer<T>::value &&
- !is_pointer<T>::value &&
- !is_function<T>::value;
-};
-#endif
-
-template <class T>
-struct is_enum
-{ static const bool value = BOOST_MOVE_IS_ENUM_IMPL(T); };
-
-//////////////////////////////////////
-// is_pod
-//////////////////////////////////////
-template<class T>
-struct is_pod_noextents_cv //for non-c++11 compilers, a safe fallback
-{ static const bool value = BOOST_MOVE_IS_POD_IMPL(T); };
-
-template<class T>
-struct is_pod
- : is_pod_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type>
-{};
-
-//////////////////////////////////////
-// is_empty
-//////////////////////////////////////
-#if !defined(BOOST_MOVE_IS_EMPTY)
-
-template <typename T>
-struct empty_helper_t1 : public T
-{
- empty_helper_t1(); // hh compiler bug workaround
- int i[256];
- private:
-
- empty_helper_t1(const empty_helper_t1&);
- empty_helper_t1& operator=(const empty_helper_t1&);
-};
-
-struct empty_helper_t2 { int i[256]; };
-
-template <typename T, bool IsClass = is_class<T>::value >
-struct is_empty_nonintrinsic
-{
- static const bool value = false;
-};
-
-template <typename T>
-struct is_empty_nonintrinsic<T, true>
-{
- static const bool value = sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2);
-};
-#endif
-
-template <class T>
-struct is_empty
-{ static const bool value = BOOST_MOVE_IS_EMPTY_IMPL(T); };
-
-
-template<class T>
-struct has_boost_move_no_copy_constructor_or_assign_type
-{
- template <class U>
- static yes_type test(typename U::boost_move_no_copy_constructor_or_assign*);
-
- template <class U>
- static no_type test(...);
-
- static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
-};
-
-//////////////////////////////////////
-// is_copy_constructible
-//////////////////////////////////////
-#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \
- && !defined(BOOST_INTEL_CXX_VERSION) && \
- !(defined(BOOST_MSVC) && _MSC_VER == 1800)
-#define BOOST_MOVE_TT_CXX11_IS_COPY_CONSTRUCTIBLE
-#endif
-
-template<class T>
-struct is_copy_constructible
-{
- // Intel compiler has problems with SFINAE for copy constructors and deleted functions:
- //
- // error: function *function_name* cannot be referenced -- it is a deleted function
- // static yes_type test(U&, decltype(U(boost::declval<U&>()))* = 0);
- // ^
- // MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See:
- // https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken
- #if defined(BOOST_MOVE_TT_CXX11_IS_COPY_CONSTRUCTIBLE)
- template<class U> static typename add_reference<U>::type source();
- static no_type test(...);
- #ifdef BOOST_NO_CXX11_DECLTYPE
- template <class U>
- static yes_type test(U&, bool_<sizeof(U(source<U>()))>* = 0);
- #else
- template <class U>
- static yes_type test(U&, decltype(U(source<U>()))* = 0);
- #endif
- static const bool value = sizeof(test(source<T>())) == sizeof(yes_type);
- #else
- static const bool value = !has_boost_move_no_copy_constructor_or_assign_type<T>::value;
- #endif
-};
-
-
-//////////////////////////////////////
-// is_copy_assignable
-//////////////////////////////////////
-#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \
- && !defined(BOOST_INTEL_CXX_VERSION) && \
- !(defined(BOOST_MSVC) && _MSC_VER == 1800)
-#define BOOST_MOVE_TT_CXX11_IS_COPY_ASSIGNABLE
-#endif
-
-template <class T>
-struct is_copy_assignable
-{
-// Intel compiler has problems with SFINAE for copy constructors and deleted functions:
-//
-// error: function *function_name* cannot be referenced -- it is a deleted function
-// static boost::type_traits::yes_type test(T1&, decltype(T1(boost::declval<T1&>()))* = 0);
-// ^
-//
-// MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See:
-// https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken
-#if defined(BOOST_MOVE_TT_CXX11_IS_COPY_ASSIGNABLE)
- typedef char yes_type;
- struct no_type { char dummy[2]; };
-
- template <class U> static typename add_reference<U>::type source();
- template <class U> static decltype(source<U&>() = source<const U&>(), yes_type() ) test(int);
- template <class> static no_type test(...);
-
- static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
-#else
- static const bool value = !has_boost_move_no_copy_constructor_or_assign_type<T>::value;
-#endif
-};
-
-//////////////////////////////////////
-// is_trivially_destructible
-//////////////////////////////////////
-template<class T>
-struct is_trivially_destructible
-{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T); };
-
-//////////////////////////////////////
-// is_trivially_default_constructible
-//////////////////////////////////////
-template<class T>
-struct is_trivially_default_constructible
-{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T); };
-
-//////////////////////////////////////
-// is_trivially_copy_constructible
-//////////////////////////////////////
-template<class T>
-struct is_trivially_copy_constructible
-{
- //In several compilers BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE return true even with
- //deleted copy constructors so make sure the type is copy constructible.
- static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T);
-};
-
-//////////////////////////////////////
-// is_trivially_move_constructible
-//////////////////////////////////////
-template<class T>
-struct is_trivially_move_constructible
-{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T); };
-
-//////////////////////////////////////
-// is_trivially_copy_assignable
-//////////////////////////////////////
-template<class T>
-struct is_trivially_copy_assignable
-{
- //In several compilers BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE return true even with
- //deleted copy constructors so make sure the type is copy constructible.
- static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T);
-};
-
-//////////////////////////////////////
-// is_trivially_move_assignable
-//////////////////////////////////////
-template<class T>
-struct is_trivially_move_assignable
-{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T); };
-
-//////////////////////////////////////
-// is_nothrow_default_constructible
-//////////////////////////////////////
-template<class T>
-struct is_nothrow_default_constructible
- : is_pod<T>
-{ static const bool value = BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T); };
-
-//////////////////////////////////////
-// is_nothrow_copy_constructible
-//////////////////////////////////////
-template<class T>
-struct is_nothrow_copy_constructible
-{ static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T); };
-
-//////////////////////////////////////
-// is_nothrow_move_constructible
-//////////////////////////////////////
-template<class T>
-struct is_nothrow_move_constructible
-{ static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T); };
-
-//////////////////////////////////////
-// is_nothrow_copy_assignable
-//////////////////////////////////////
-template<class T>
-struct is_nothrow_copy_assignable
-{ static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T); };
-
-//////////////////////////////////////
-// is_nothrow_move_assignable
-//////////////////////////////////////
-template<class T>
-struct is_nothrow_move_assignable
-{ static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T); };
-
-//////////////////////////////////////
-// is_nothrow_swappable
-//////////////////////////////////////
-template<class T>
-struct is_nothrow_swappable
-{
- static const bool value = is_empty<T>::value || is_pod<T>::value;
-};
-
-//////////////////////////////////////
-// alignment_of
-//////////////////////////////////////
-template <typename T>
-struct alignment_of_hack
-{
- T t1;
- char c;
- T t2;
- alignment_of_hack();
-};
-
-template <unsigned A, unsigned S>
-struct alignment_logic
-{ static const std::size_t value = A < S ? A : S; };
-
-template< typename T >
-struct alignment_of_impl
-#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
- // With MSVC both the native __alignof operator
- // and our own logic gets things wrong from time to time :-(
- // Using a combination of the two seems to make the most of a bad job:
- : alignment_logic< sizeof(alignment_of_hack<T>) - 2*sizeof(T), __alignof(T)>
-{};
-#elif !defined(BOOST_MOVE_ALIGNMENT_OF)
- : alignment_logic< sizeof(alignment_of_hack<T>) - 2*sizeof(T), sizeof(T)>
-{};
-#else
-{ static const std::size_t value = BOOST_MOVE_ALIGNMENT_OF(T); };
-#endif
-
-template< typename T >
-struct alignment_of
- : alignment_of_impl<T>
-{};
-
-class alignment_dummy;
-typedef void (*function_ptr)();
-typedef int (alignment_dummy::*member_ptr);
-typedef int (alignment_dummy::*member_function_ptr)();
-struct alignment_struct
-{ long double dummy[4]; };
-
-/////////////////////////////
-// max_align_t
-/////////////////////////////
-//This is not standard, but should work with all compilers
-union max_align
-{
- char char_;
- short short_;
- int int_;
- long long_;
- #ifdef BOOST_HAS_LONG_LONG
- ::boost::long_long_type long_long_;
- #endif
- float float_;
- double double_;
- void * void_ptr_;
- long double long_double_[4];
- alignment_dummy *unknown_class_ptr_;
- function_ptr function_ptr_;
- member_function_ptr member_function_ptr_;
- alignment_struct alignment_struct_;
-};
-
-typedef union max_align max_align_t;
-
-/////////////////////////////
-// aligned_storage
-/////////////////////////////
-
-#if !defined(BOOST_NO_ALIGNMENT)
-
-template<std::size_t Len, std::size_t Align>
-struct aligned_storage_impl;
-
-#define BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(A)\
-template<std::size_t Len>\
-struct BOOST_ALIGNMENT(A) aligned_storage_impl<Len, A>\
-{\
- char dummy[Len];\
- typedef aligned_storage_impl<Len, A> type;\
-};\
-//
-
-//Up to 4K alignment (typical page size)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x2)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x4)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x8)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x10)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x20)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x40)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x80)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x100)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x200)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x400)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x800)
-BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1000)
-
-#undef BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT
-
-#else //BOOST_NO_ALIGNMENT
-
-template<class T, std::size_t Len>
-union aligned_union
-{
- T aligner;
- char dummy[Len];
-};
-
-template<std::size_t Len, std::size_t Align, class T, bool Ok>
-struct aligned_next;
-
-template<std::size_t Len, std::size_t Align, class T>
-struct aligned_next<Len, Align, T, true>
-{
- BOOST_STATIC_ASSERT((alignment_of<T>::value == Align));
- typedef aligned_union<T, Len> type;
-};
-
-//End of search defaults to max_align_t
-template<std::size_t Len, std::size_t Align>
-struct aligned_next<Len, Align, max_align_t, false>
-{ typedef aligned_union<max_align_t, Len> type; };
-
-//Now define a search list through types
-#define BOOST_MOVE_ALIGNED_NEXT_STEP(TYPE, NEXT_TYPE)\
- template<std::size_t Len, std::size_t Align>\
- struct aligned_next<Len, Align, TYPE, false>\
- : aligned_next<Len, Align, NEXT_TYPE, Align == alignment_of<NEXT_TYPE>::value>\
- {};\
- //
- BOOST_MOVE_ALIGNED_NEXT_STEP(long double, max_align_t)
- BOOST_MOVE_ALIGNED_NEXT_STEP(double, long double)
- #ifdef BOOST_HAS_LONG_LONG
- BOOST_MOVE_ALIGNED_NEXT_STEP(::boost::long_long_type, double)
- BOOST_MOVE_ALIGNED_NEXT_STEP(long, ::boost::long_long_type)
- #else
- BOOST_MOVE_ALIGNED_NEXT_STEP(long, double)
- #endif
- BOOST_MOVE_ALIGNED_NEXT_STEP(int, long)
- BOOST_MOVE_ALIGNED_NEXT_STEP(short, int)
- BOOST_MOVE_ALIGNED_NEXT_STEP(char, short)
-#undef BOOST_MOVE_ALIGNED_NEXT_STEP
-
-template<std::size_t Len, std::size_t Align>
-struct aligned_storage_impl
- : aligned_next<Len, Align, char, Align == alignment_of<char>::value>
-{};
-
-#endif
-
-template<std::size_t Len, std::size_t Align = alignment_of<max_align_t>::value>
-struct aligned_storage
-{
- //Sanity checks for input parameters
- BOOST_STATIC_ASSERT(Align > 0);
-
- //Sanity checks for output type
- typedef typename aligned_storage_impl<Len ? Len : 1, Align>::type type;
- static const std::size_t value = alignment_of<type>::value;
- BOOST_STATIC_ASSERT(value >= Align);
- BOOST_STATIC_ASSERT((value % Align) == 0);
-
- //Just in case someone instantiates aligned_storage
- //instead of aligned_storage::type (typical error).
- private:
- aligned_storage();
-};
-
-} //namespace move_detail {
-} //namespace boost {
-
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP
+//////////////////////////////////////////////////////////////////////////////
+// (C) Copyright John Maddock 2000.
+// (C) Copyright Ion Gaztanaga 2005-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.
+//
+// The alignment and Type traits implementation comes from
+// John Maddock's TypeTraits library.
+//
+// Some other tricks come from Howard Hinnant's papers and StackOverflow replies
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP
+#define BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/workaround.hpp>
+
+// move/detail
+#include <boost/move/detail/meta_utils.hpp>
+// other
+#include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+// std
+#include <cstddef>
+
+//Use of Boost.TypeTraits leads to long preprocessed source code due to
+//MPL dependencies. We'll use intrinsics directly and make or own
+//simplified version of TypeTraits.
+//If someday Boost.TypeTraits dependencies are minimized, we should
+//revisit this file redirecting code to Boost.TypeTraits traits.
+
+//These traits don't care about volatile, reference or other checks
+//made by Boost.TypeTraits because no volatile or reference types
+//can be hold in Boost.Containers. This helps to avoid any Boost.TypeTraits
+//dependency.
+
+// Helper macros for builtin compiler support.
+// If your compiler has builtin support for any of the following
+// traits concepts, then redefine the appropriate macros to pick
+// up on the compiler support:
+//
+// (these should largely ignore cv-qualifiers)
+// BOOST_MOVE_IS_POD(T) should evaluate to true if T is a POD type
+// BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect
+// BOOST_MOVE_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
+// BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) should evaluate to true if T(boost::move(t)) <==> memcpy
+// BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
+// BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) should evaluate to true if t = boost::move(u) <==> memcpy
+// BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect
+// BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw
+// BOOST_MOVE_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw
+// BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw
+// BOOST_MOVE_IS_ENUM(T) should evaluate to true it t is a union type.
+//
+// The following can also be defined: when detected our implementation is greatly simplified.
+//
+// BOOST_ALIGNMENT_OF(T) should evaluate to the alignment requirements of type T.
+
+#if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000)
+ // Metrowerks compiler is acquiring intrinsic type traits support
+ // post version 8. We hook into the published interface to pick up
+ // user defined specializations as well as compiler intrinsics as
+ // and when they become available:
+# include <msl_utility>
+# define BOOST_MOVE_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union<T>::value
+# define BOOST_MOVE_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD<T>::value
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor<T>::value
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor<T>::value
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment<T>::value
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor<T>::value
+#endif
+
+#if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\
+ || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500))
+# define BOOST_MOVE_IS_UNION(T) __is_union(T)
+# define BOOST_MOVE_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T))
+# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T)|| ::boost::move_detail::is_pod<T>::value)
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) || ::boost::move_detail::is_pod<T>::value)
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) || ::boost::move_detail::is_pod<T>::value)
+# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) || ::boost::move_detail::is_trivially_default_constructible<T>::value)
+# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) || ::boost::move_detail::is_trivially_copy_constructible<T>::value)
+# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) || ::boost::move_detail::is_trivially_copy_assignable<T>::value)
+
+# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+# if defined(_MSC_VER) && (_MSC_VER >= 1700)
+# define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__has_trivial_move_constructor(T) || ::boost::move_detail::is_pod<T>::value)
+# define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) (__has_trivial_move_assign(T) || ::boost::move_detail::is_pod<T>::value)
+# endif
+#endif
+
+#if defined(BOOST_CLANG) && defined(__has_feature)
+
+# if __has_feature(is_union)
+# define BOOST_MOVE_IS_UNION(T) __is_union(T)
+# endif
+# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_pod)
+# define BOOST_MOVE_IS_POD(T) __is_pod(T)
+# endif
+# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty)
+# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
+# endif
+# if __has_feature(has_trivial_constructor)
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
+# endif
+# if __has_feature(has_trivial_copy)
+# //There are problems with deleted copy constructors detected as trivially copyable.
+# //http://stackoverflow.com/questions/12754886/has-trivial-copy-behaves-differently-in-clang-and-gcc-whos-right
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && ::boost::move_detail::is_copy_constructible<T>::value)
+# endif
+# if __has_feature(has_trivial_assign)
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) )
+# endif
+# if __has_feature(has_trivial_destructor)
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
+# endif
+# if __has_feature(has_nothrow_constructor)
+# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
+# endif
+# if __has_feature(has_nothrow_copy)
+# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T))
+# endif
+# if __has_feature(is_nothrow_copy_assignable)
+# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T))
+# endif
+# if __has_feature(is_enum)
+# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+# endif
+# if __has_feature(has_trivial_move_constructor)
+# define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) __has_trivial_move_constructor(T)
+# endif
+# if __has_feature(has_trivial_move_assign)
+# define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) __has_trivial_move_assign(T)
+# endif
+# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof(T)
+#endif
+
+#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG)
+
+#ifdef BOOST_INTEL
+# define BOOST_MOVE_INTEL_TT_OPTS || ::boost::move_detail::is_pod<T>::value
+#else
+# define BOOST_MOVE_INTEL_TT_OPTS
+#endif
+
+# define BOOST_MOVE_IS_UNION(T) __is_union(T)
+# define BOOST_MOVE_IS_POD(T) __is_pod(T)
+# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_MOVE_INTEL_TT_OPTS))
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_MOVE_INTEL_TT_OPTS))
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_MOVE_INTEL_TT_OPTS) )
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_MOVE_INTEL_TT_OPTS)
+# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_MOVE_INTEL_TT_OPTS)
+# define BOOST_MOVE_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_MOVE_INTEL_TT_OPTS))
+# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_MOVE_INTEL_TT_OPTS))
+
+# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+# if (!defined(unix) && !defined(__unix__)) || defined(__LP64__)
+ // GCC sometimes lies about alignment requirements
+ // of type double on 32-bit unix platforms, use the
+ // old implementation instead in that case:
+# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T)
+# endif
+#endif
+
+#if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600)
+
+# define BOOST_MOVE_IS_UNION(T) __is_union(T)
+# define BOOST_MOVE_IS_POD(T) __is_pod(T)
+# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T))
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T))
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
+# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
+# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T))
+# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T))
+
+# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T)
+#endif
+
+# if defined(__CODEGEARC__)
+# define BOOST_MOVE_IS_UNION(T) __is_union(T)
+# define BOOST_MOVE_IS_POD(T) __is_pod(T)
+# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_default_constructor(T))
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy_constructor(T))
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T))
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T))
+# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_default_constructor(T))
+# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy_constructor(T))
+# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T))
+
+# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+# define BOOST_MOVE_ALIGNMENT_OF(T) alignof(T)
+
+#endif
+
+//Fallback definitions
+
+#ifdef BOOST_MOVE_IS_UNION
+ #define BOOST_MOVE_IS_UNION_IMPL(T) BOOST_MOVE_IS_UNION(T)
+#else
+ #define BOOST_MOVE_IS_UNION_IMPL(T) false
+#endif
+
+#ifdef BOOST_MOVE_IS_POD
+ //in some compilers the intrinsic is limited to class types so add scalar and void
+ #define BOOST_MOVE_IS_POD_IMPL(T) (::boost::move_detail::is_scalar<T>::value ||\
+ ::boost::move_detail::is_void<T>::value ||\
+ BOOST_MOVE_IS_POD(T))
+#else
+ #define BOOST_MOVE_IS_POD_IMPL(T) \
+ (::boost::move_detail::is_scalar<T>::value || ::boost::move_detail::is_void<T>::value)
+#endif
+
+#ifdef BOOST_MOVE_IS_EMPTY
+ #define BOOST_MOVE_IS_EMPTY_IMPL(T) BOOST_MOVE_IS_EMPTY(T)
+#else
+ #define BOOST_MOVE_IS_EMPTY_IMPL(T) ::boost::move_detail::is_empty_nonintrinsic<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_COPY
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_COPY(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR
+ #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_COPY
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_COPY(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR
+ #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_ASSIGN
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN
+ #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR
+ #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR
+ #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T)
+#else
+ #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_NOTHROW_COPY
+ #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_COPY(T)
+#else
+ #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_NOTHROW_MOVE
+ #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE(T)
+#else
+ #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_NOTHROW_ASSIGN
+ #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_ASSIGN(T)
+#else
+ #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN
+ #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T)
+#else
+ #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_IS_ENUM
+ #define BOOST_MOVE_IS_ENUM_IMPL(T) BOOST_MOVE_IS_ENUM(T)
+#else
+ #define BOOST_MOVE_IS_ENUM_IMPL(T) ::boost::move_detail::is_enum_nonintrinsic<T>::value
+#endif
+
+namespace boost {
+namespace move_detail {
+
+//////////////////////////
+// is_reference
+//////////////////////////
+template<class T>
+struct is_reference
+{ static const bool value = false; };
+
+template<class T>
+struct is_reference<T&>
+{ static const bool value = true; };
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+template<class T>
+struct is_reference<T&&>
+{ static const bool value = true; };
+#endif
+
+//////////////////////////
+// is_pointer
+//////////////////////////
+template<class T>
+struct is_pointer
+{ static const bool value = false; };
+
+template<class T>
+struct is_pointer<T*>
+{ static const bool value = true; };
+
+//////////////////////////
+// is_const
+//////////////////////////
+template<class T>
+struct is_const
+{ static const bool value = false; };
+
+template<class T>
+struct is_const<const T>
+{ static const bool value = true; };
+
+//////////////////////////
+// unvoid_ref
+//////////////////////////
+template <typename T> struct unvoid_ref : add_lvalue_reference<T>{};
+template <> struct unvoid_ref<void> { typedef unvoid_ref & type; };
+template <> struct unvoid_ref<const void> { typedef unvoid_ref & type; };
+template <> struct unvoid_ref<volatile void> { typedef unvoid_ref & type; };
+template <> struct unvoid_ref<const volatile void> { typedef unvoid_ref & type; };
+
+template <typename T>
+struct add_reference : add_lvalue_reference<T>
+{};
+
+//////////////////////////
+// add_const_reference
+//////////////////////////
+template <class T>
+struct add_const_reference
+{ typedef const T &type; };
+
+template <class T>
+struct add_const_reference<T&>
+{ typedef T& type; };
+
+//////////////////////////
+// add_const_if_c
+//////////////////////////
+template<class T, bool Add>
+struct add_const_if_c
+ : if_c<Add, typename add_const<T>::type, T>
+{};
+
+//////////////////////////
+// remove_const
+//////////////////////////
+template<class T>
+struct remove_const
+{ typedef T type; };
+
+template<class T>
+struct remove_const< const T>
+{ typedef T type; };
+
+//////////////////////////
+// remove_cv
+//////////////////////////
+template<typename T> struct remove_cv { typedef T type; };
+template<typename T> struct remove_cv<const T> { typedef T type; };
+template<typename T> struct remove_cv<const volatile T> { typedef T type; };
+template<typename T> struct remove_cv<volatile T> { typedef T type; };
+
+//////////////////////////
+// make_unsigned
+//////////////////////////
+template <class T>
+struct make_unsigned_impl { typedef T type; };
+template <> struct make_unsigned_impl<signed char> { typedef unsigned char type; };
+template <> struct make_unsigned_impl<signed short> { typedef unsigned short type; };
+template <> struct make_unsigned_impl<signed int> { typedef unsigned int type; };
+template <> struct make_unsigned_impl<signed long> { typedef unsigned long type; };
+#ifdef BOOST_HAS_LONG_LONG
+template <> struct make_unsigned_impl< ::boost::long_long_type > { typedef ::boost::ulong_long_type type; };
+#endif
+
+template <class T>
+struct make_unsigned
+ : make_unsigned_impl<typename remove_cv<T>::type>
+{};
+
+//////////////////////////
+// is_floating_point
+//////////////////////////
+template<class T> struct is_floating_point_cv { static const bool value = false; };
+template<> struct is_floating_point_cv<float> { static const bool value = true; };
+template<> struct is_floating_point_cv<double> { static const bool value = true; };
+template<> struct is_floating_point_cv<long double> { static const bool value = true; };
+
+template<class T>
+struct is_floating_point
+ : is_floating_point_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////
+// is_integral
+//////////////////////////
+template<class T> struct is_integral_cv { static const bool value = false; };
+template<> struct is_integral_cv< bool>{ static const bool value = true; };
+template<> struct is_integral_cv< char>{ static const bool value = true; };
+template<> struct is_integral_cv< unsigned char>{ static const bool value = true; };
+template<> struct is_integral_cv< signed char>{ static const bool value = true; };
+#ifndef BOOST_NO_CXX11_CHAR16_T
+template<> struct is_integral_cv< char16_t>{ static const bool value = true; };
+#endif
+#ifndef BOOST_NO_CXX11_CHAR32_T
+template<> struct is_integral_cv< char32_t>{ static const bool value = true; };
+#endif
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<> struct is_integral_cv< wchar_t>{ static const bool value = true; };
+#endif
+template<> struct is_integral_cv< short>{ static const bool value = true; };
+template<> struct is_integral_cv< unsigned short>{ static const bool value = true; };
+template<> struct is_integral_cv< int>{ static const bool value = true; };
+template<> struct is_integral_cv< unsigned int>{ static const bool value = true; };
+template<> struct is_integral_cv< long>{ static const bool value = true; };
+template<> struct is_integral_cv< unsigned long>{ static const bool value = true; };
+#ifdef BOOST_HAS_LONG_LONG
+template<> struct is_integral_cv< ::boost:: long_long_type>{ static const bool value = true; };
+template<> struct is_integral_cv< ::boost::ulong_long_type>{ static const bool value = true; };
+#endif
+
+template<class T>
+struct is_integral
+ : public is_integral_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////////////////
+// remove_all_extents
+//////////////////////////////////////
+template <class T>
+struct remove_all_extents
+{ typedef T type;};
+
+template <class T>
+struct remove_all_extents<T[]>
+{ typedef typename remove_all_extents<T>::type type; };
+
+template <class T, std::size_t N>
+struct remove_all_extents<T[N]>
+{ typedef typename remove_all_extents<T>::type type;};
+
+//////////////////////////
+// is_scalar
+//////////////////////////
+template<class T>
+struct is_scalar
+{ static const bool value = is_integral<T>::value || is_floating_point<T>::value; };
+
+//////////////////////////
+// is_void
+//////////////////////////
+template<class T>
+struct is_void_cv
+{ static const bool value = false; };
+
+template<>
+struct is_void_cv<void>
+{ static const bool value = true; };
+
+template<class T>
+struct is_void
+ : is_void_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////////////////
+// is_array
+//////////////////////////////////////
+template<class T>
+struct is_array
+{ static const bool value = false; };
+
+template<class T>
+struct is_array<T[]>
+{ static const bool value = true; };
+
+template<class T, std::size_t N>
+struct is_array<T[N]>
+{ static const bool value = true; };
+
+//////////////////////////////////////
+// is_member_pointer
+//////////////////////////////////////
+template <class T> struct is_member_pointer_cv { static const bool value = false; };
+template <class T, class U>struct is_member_pointer_cv<T U::*> { static const bool value = true; };
+
+template <class T>
+struct is_member_pointer
+ : is_member_pointer_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////////////////
+// is_nullptr_t
+//////////////////////////////////////
+template <class T>
+struct is_nullptr_t_cv
+{ static const bool value = false; };
+
+#if !defined(BOOST_NO_CXX11_NULLPTR)
+template <>
+struct is_nullptr_t_cv
+ #if !defined(BOOST_NO_CXX11_DECLTYPE)
+ <decltype(nullptr)>
+ #else
+ <std::nullptr_t>
+ #endif
+{ static const bool value = true; };
+#endif
+
+template <class T>
+struct is_nullptr_t
+ : is_nullptr_t_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////////////////
+// is_function
+//////////////////////////////////////
+//Inspired by libc++, thanks to Howard Hinnant
+//For a function to pointer an lvalue of function type T can be implicitly converted to a prvalue
+//pointer to that function. This does not apply to non-static member functions because lvalues
+//that refer to non-static member functions do not exist.
+template <class T>
+struct is_reference_convertible_to_pointer
+{
+ struct twochar { char dummy[2]; };
+ template <class U> static char test(U*);
+ template <class U> static twochar test(...);
+ static T& source();
+ static const bool value = sizeof(char) == sizeof(test<T>(source()));
+};
+//Filter out:
+// - class types that might have implicit conversions
+// - void (to avoid forming a reference to void later)
+// - references (e.g.: filtering reference to functions)
+// - nullptr_t (convertible to pointer)
+template < class T
+ , bool Filter = is_class_or_union<T>::value ||
+ is_void<T>::value ||
+ is_reference<T>::value ||
+ is_nullptr_t<T>::value >
+struct is_function_impl
+{ static const bool value = is_reference_convertible_to_pointer<T>::value; };
+
+template <class T>
+struct is_function_impl<T, true>
+{ static const bool value = false; };
+
+template <class T>
+struct is_function
+ : is_function_impl<T>
+{};
+
+//////////////////////////////////////
+// is_union
+//////////////////////////////////////
+template<class T>
+struct is_union_noextents_cv
+{ static const bool value = BOOST_MOVE_IS_UNION_IMPL(T); };
+
+template<class T>
+struct is_union
+ : is_union_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type>
+{};
+
+//////////////////////////////////////
+// is_class
+//////////////////////////////////////
+template <class T>
+struct is_class
+{
+ static const bool value = is_class_or_union<T>::value && ! is_union<T>::value;
+};
+
+
+//////////////////////////////////////
+// is_arithmetic
+//////////////////////////////////////
+template <class T>
+struct is_arithmetic
+{
+ static const bool value = is_floating_point<T>::value ||
+ is_integral<T>::value;
+};
+
+//////////////////////////////////////
+// is_member_function_pointer
+//////////////////////////////////////
+template <class T>
+struct is_member_function_pointer_cv
+{
+ static const bool value = false;
+};
+
+template <class T, class C>
+struct is_member_function_pointer_cv<T C::*>
+ : is_function<T>
+{};
+
+template <class T>
+struct is_member_function_pointer
+ : is_member_function_pointer_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////////////////
+// is_enum
+//////////////////////////////////////
+#if !defined(BOOST_MOVE_IS_ENUM)
+//Based on (http://howardhinnant.github.io/TypeHiearchy.pdf)
+template <class T>
+struct is_enum_nonintrinsic
+{
+ static const bool value = !is_arithmetic<T>::value &&
+ !is_reference<T>::value &&
+ !is_class_or_union<T>::value &&
+ !is_array<T>::value &&
+ !is_void<T>::value &&
+ !is_nullptr_t<T>::value &&
+ !is_member_pointer<T>::value &&
+ !is_pointer<T>::value &&
+ !is_function<T>::value;
+};
+#endif
+
+template <class T>
+struct is_enum
+{ static const bool value = BOOST_MOVE_IS_ENUM_IMPL(T); };
+
+//////////////////////////////////////
+// is_pod
+//////////////////////////////////////
+template<class T>
+struct is_pod_noextents_cv //for non-c++11 compilers, a safe fallback
+{ static const bool value = BOOST_MOVE_IS_POD_IMPL(T); };
+
+template<class T>
+struct is_pod
+ : is_pod_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type>
+{};
+
+//////////////////////////////////////
+// is_empty
+//////////////////////////////////////
+#if !defined(BOOST_MOVE_IS_EMPTY)
+
+template <typename T>
+struct empty_helper_t1 : public T
+{
+ empty_helper_t1(); // hh compiler bug workaround
+ int i[256];
+ private:
+
+ empty_helper_t1(const empty_helper_t1&);
+ empty_helper_t1& operator=(const empty_helper_t1&);
+};
+
+struct empty_helper_t2 { int i[256]; };
+
+template <typename T, bool IsClass = is_class<T>::value >
+struct is_empty_nonintrinsic
+{
+ static const bool value = false;
+};
+
+template <typename T>
+struct is_empty_nonintrinsic<T, true>
+{
+ static const bool value = sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2);
+};
+#endif
+
+template <class T>
+struct is_empty
+{ static const bool value = BOOST_MOVE_IS_EMPTY_IMPL(T); };
+
+
+template<class T>
+struct has_boost_move_no_copy_constructor_or_assign_type
+{
+ template <class U>
+ static yes_type test(typename U::boost_move_no_copy_constructor_or_assign*);
+
+ template <class U>
+ static no_type test(...);
+
+ static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
+};
+
+//////////////////////////////////////
+// is_copy_constructible
+//////////////////////////////////////
+#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \
+ && !defined(BOOST_INTEL_CXX_VERSION) && \
+ !(defined(BOOST_MSVC) && _MSC_VER == 1800)
+#define BOOST_MOVE_TT_CXX11_IS_COPY_CONSTRUCTIBLE
+#endif
+
+template<class T>
+struct is_copy_constructible
+{
+ // Intel compiler has problems with SFINAE for copy constructors and deleted functions:
+ //
+ // error: function *function_name* cannot be referenced -- it is a deleted function
+ // static yes_type test(U&, decltype(U(boost::declval<U&>()))* = 0);
+ // ^
+ // MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See:
+ // https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken
+ #if defined(BOOST_MOVE_TT_CXX11_IS_COPY_CONSTRUCTIBLE)
+ template<class U> static typename add_reference<U>::type source();
+ static no_type test(...);
+ #ifdef BOOST_NO_CXX11_DECLTYPE
+ template <class U>
+ static yes_type test(U&, bool_<sizeof(U(source<U>()))>* = 0);
+ #else
+ template <class U>
+ static yes_type test(U&, decltype(U(source<U>()))* = 0);
+ #endif
+ static const bool value = sizeof(test(source<T>())) == sizeof(yes_type);
+ #else
+ static const bool value = !has_boost_move_no_copy_constructor_or_assign_type<T>::value;
+ #endif
+};
+
+
+//////////////////////////////////////
+// is_copy_assignable
+//////////////////////////////////////
+#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \
+ && !defined(BOOST_INTEL_CXX_VERSION) && \
+ !(defined(BOOST_MSVC) && _MSC_VER == 1800)
+#define BOOST_MOVE_TT_CXX11_IS_COPY_ASSIGNABLE
+#endif
+
+template <class T>
+struct is_copy_assignable
+{
+// Intel compiler has problems with SFINAE for copy constructors and deleted functions:
+//
+// error: function *function_name* cannot be referenced -- it is a deleted function
+// static boost::type_traits::yes_type test(T1&, decltype(T1(boost::declval<T1&>()))* = 0);
+// ^
+//
+// MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See:
+// https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken
+#if defined(BOOST_MOVE_TT_CXX11_IS_COPY_ASSIGNABLE)
+ typedef char yes_type;
+ struct no_type { char dummy[2]; };
+
+ template <class U> static typename add_reference<U>::type source();
+ template <class U> static decltype(source<U&>() = source<const U&>(), yes_type() ) test(int);
+ template <class> static no_type test(...);
+
+ static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
+#else
+ static const bool value = !has_boost_move_no_copy_constructor_or_assign_type<T>::value;
+#endif
+};
+
+//////////////////////////////////////
+// is_trivially_destructible
+//////////////////////////////////////
+template<class T>
+struct is_trivially_destructible
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_trivially_default_constructible
+//////////////////////////////////////
+template<class T>
+struct is_trivially_default_constructible
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_trivially_copy_constructible
+//////////////////////////////////////
+template<class T>
+struct is_trivially_copy_constructible
+{
+ //In several compilers BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE return true even with
+ //deleted copy constructors so make sure the type is copy constructible.
+ static const bool value = ::boost::move_detail::is_pod<T>::value ||
+ ( ::boost::move_detail::is_copy_constructible<T>::value &&
+ BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) );
+};
+
+//////////////////////////////////////
+// is_trivially_move_constructible
+//////////////////////////////////////
+template<class T>
+struct is_trivially_move_constructible
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_trivially_copy_assignable
+//////////////////////////////////////
+template<class T>
+struct is_trivially_copy_assignable
+{
+ //In several compilers BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE return true even with
+ //deleted copy constructors so make sure the type is copy constructible.
+ static const bool value = ::boost::move_detail::is_pod<T>::value ||
+ ( ::boost::move_detail::is_copy_assignable<T>::value &&
+ BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) );
+};
+
+//////////////////////////////////////
+// is_trivially_move_assignable
+//////////////////////////////////////
+template<class T>
+struct is_trivially_move_assignable
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_default_constructible
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_default_constructible
+ : is_pod<T>
+{ static const bool value = BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_copy_constructible
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_copy_constructible
+{ static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_move_constructible
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_move_constructible
+{ static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_copy_assignable
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_copy_assignable
+{ static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_move_assignable
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_move_assignable
+{ static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_swappable
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_swappable
+{
+ static const bool value = is_empty<T>::value || is_pod<T>::value;
+};
+
+//////////////////////////////////////
+// alignment_of
+//////////////////////////////////////
+template <typename T>
+struct alignment_of_hack
+{
+ T t1;
+ char c;
+ T t2;
+ alignment_of_hack();
+};
+
+template <unsigned A, unsigned S>
+struct alignment_logic
+{ static const std::size_t value = A < S ? A : S; };
+
+template< typename T >
+struct alignment_of_impl
+#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
+ // With MSVC both the native __alignof operator
+ // and our own logic gets things wrong from time to time :-(
+ // Using a combination of the two seems to make the most of a bad job:
+ : alignment_logic< sizeof(alignment_of_hack<T>) - 2*sizeof(T), __alignof(T)>
+{};
+#elif !defined(BOOST_MOVE_ALIGNMENT_OF)
+ : alignment_logic< sizeof(alignment_of_hack<T>) - 2*sizeof(T), sizeof(T)>
+{};
+#else
+{ static const std::size_t value = BOOST_MOVE_ALIGNMENT_OF(T); };
+#endif
+
+template< typename T >
+struct alignment_of
+ : alignment_of_impl<T>
+{};
+
+class alignment_dummy;
+typedef void (*function_ptr)();
+typedef int (alignment_dummy::*member_ptr);
+typedef int (alignment_dummy::*member_function_ptr)();
+struct alignment_struct
+{ long double dummy[4]; };
+
+/////////////////////////////
+// max_align_t
+/////////////////////////////
+//This is not standard, but should work with all compilers
+union max_align
+{
+ char char_;
+ short short_;
+ int int_;
+ long long_;
+ #ifdef BOOST_HAS_LONG_LONG
+ ::boost::long_long_type long_long_;
+ #endif
+ float float_;
+ double double_;
+ void * void_ptr_;
+ long double long_double_[4];
+ alignment_dummy *unknown_class_ptr_;
+ function_ptr function_ptr_;
+ member_function_ptr member_function_ptr_;
+ alignment_struct alignment_struct_;
+};
+
+typedef union max_align max_align_t;
+
+/////////////////////////////
+// aligned_storage
+/////////////////////////////
+
+#if !defined(BOOST_NO_ALIGNMENT)
+
+template<std::size_t Len, std::size_t Align>
+struct aligned_storage_impl;
+
+#define BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(A)\
+template<std::size_t Len>\
+struct BOOST_ALIGNMENT(A) aligned_storage_impl<Len, A>\
+{\
+ char dummy[Len];\
+ typedef aligned_storage_impl<Len, A> type;\
+};\
+//
+
+//Up to 4K alignment (typical page size)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x2)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x4)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x8)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x10)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x20)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x40)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x80)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x100)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x200)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x400)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x800)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1000)
+
+#undef BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT
+
+#else //BOOST_NO_ALIGNMENT
+
+template<class T, std::size_t Len>
+union aligned_union
+{
+ T aligner;
+ char dummy[Len];
+};
+
+template<std::size_t Len, std::size_t Align, class T, bool Ok>
+struct aligned_next;
+
+template<std::size_t Len, std::size_t Align, class T>
+struct aligned_next<Len, Align, T, true>
+{
+ BOOST_STATIC_ASSERT((alignment_of<T>::value == Align));
+ typedef aligned_union<T, Len> type;
+};
+
+//End of search defaults to max_align_t
+template<std::size_t Len, std::size_t Align>
+struct aligned_next<Len, Align, max_align_t, false>
+{ typedef aligned_union<max_align_t, Len> type; };
+
+//Now define a search list through types
+#define BOOST_MOVE_ALIGNED_NEXT_STEP(TYPE, NEXT_TYPE)\
+ template<std::size_t Len, std::size_t Align>\
+ struct aligned_next<Len, Align, TYPE, false>\
+ : aligned_next<Len, Align, NEXT_TYPE, Align == alignment_of<NEXT_TYPE>::value>\
+ {};\
+ //
+ BOOST_MOVE_ALIGNED_NEXT_STEP(long double, max_align_t)
+ BOOST_MOVE_ALIGNED_NEXT_STEP(double, long double)
+ #ifdef BOOST_HAS_LONG_LONG
+ BOOST_MOVE_ALIGNED_NEXT_STEP(::boost::long_long_type, double)
+ BOOST_MOVE_ALIGNED_NEXT_STEP(long, ::boost::long_long_type)
+ #else
+ BOOST_MOVE_ALIGNED_NEXT_STEP(long, double)
+ #endif
+ BOOST_MOVE_ALIGNED_NEXT_STEP(int, long)
+ BOOST_MOVE_ALIGNED_NEXT_STEP(short, int)
+ BOOST_MOVE_ALIGNED_NEXT_STEP(char, short)
+#undef BOOST_MOVE_ALIGNED_NEXT_STEP
+
+template<std::size_t Len, std::size_t Align>
+struct aligned_storage_impl
+ : aligned_next<Len, Align, char, Align == alignment_of<char>::value>
+{};
+
+#endif
+
+template<std::size_t Len, std::size_t Align = alignment_of<max_align_t>::value>
+struct aligned_storage
+{
+ //Sanity checks for input parameters
+ BOOST_STATIC_ASSERT(Align > 0);
+
+ //Sanity checks for output type
+ typedef typename aligned_storage_impl<Len ? Len : 1, Align>::type type;
+ static const std::size_t value = alignment_of<type>::value;
+ BOOST_STATIC_ASSERT(value >= Align);
+ BOOST_STATIC_ASSERT((value % Align) == 0);
+
+ //Just in case someone instantiates aligned_storage
+ //instead of aligned_storage::type (typical error).
+ private:
+ aligned_storage();
+};
+
+} //namespace move_detail {
+} //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP
diff --git a/contrib/src/boost/move/detail/unique_ptr_meta_utils.hpp b/contrib/src/boost/move/detail/unique_ptr_meta_utils.hpp
new file mode 100644
index 0000000..3372068
--- /dev/null
+++ b/contrib/src/boost/move/detail/unique_ptr_meta_utils.hpp
@@ -0,0 +1,591 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2012.
+// 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_UNIQUE_PTR_DETAIL_META_UTILS_HPP
+#define BOOST_MOVE_UNIQUE_PTR_DETAIL_META_UTILS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <cstddef> //for std::size_t
+
+//Small meta-typetraits to support move
+
+namespace boost {
+
+namespace movelib {
+
+template <class T>
+struct default_delete;
+
+} //namespace movelib {
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+//Forward declare boost::rv
+template <class T> class rv;
+#endif
+
+namespace move_upmu {
+
+//////////////////////////////////////
+// nat
+//////////////////////////////////////
+struct nat{};
+
+//////////////////////////////////////
+// natify
+//////////////////////////////////////
+template <class T> struct natify{};
+
+//////////////////////////////////////
+// if_c
+//////////////////////////////////////
+template<bool C, typename T1, typename T2>
+struct if_c
+{
+ typedef T1 type;
+};
+
+template<typename T1, typename T2>
+struct if_c<false,T1,T2>
+{
+ typedef T2 type;
+};
+
+//////////////////////////////////////
+// if_
+//////////////////////////////////////
+template<typename T1, typename T2, typename T3>
+struct if_ : if_c<0 != T1::value, T2, T3>
+{};
+
+//enable_if_
+template <bool B, class T = nat>
+struct enable_if_c
+{
+ typedef T type;
+};
+
+//////////////////////////////////////
+// enable_if_c
+//////////////////////////////////////
+template <class T>
+struct enable_if_c<false, T> {};
+
+//////////////////////////////////////
+// enable_if
+//////////////////////////////////////
+template <class Cond, class T = nat>
+struct enable_if : public enable_if_c<Cond::value, T> {};
+
+//////////////////////////////////////
+// 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_const
+//////////////////////////////////////
+template< class T >
+struct remove_const
+{
+ typedef T type;
+};
+
+template< class T >
+struct remove_const<const T>
+{
+ typedef T type;
+};
+
+//////////////////////////////////////
+// remove_volatile
+//////////////////////////////////////
+template< class T >
+struct remove_volatile
+{
+ typedef T type;
+};
+
+template< class T >
+struct remove_volatile<volatile T>
+{
+ typedef T type;
+};
+
+//////////////////////////////////////
+// remove_cv
+//////////////////////////////////////
+template< class T >
+struct remove_cv
+{
+ typedef typename remove_volatile
+ <typename remove_const<T>::type>::type type;
+};
+
+//////////////////////////////////////
+// remove_extent
+//////////////////////////////////////
+template<class T>
+struct remove_extent
+{
+ typedef T type;
+};
+
+template<class T>
+struct remove_extent<T[]>
+{
+ typedef T type;
+};
+
+template<class T, std::size_t N>
+struct remove_extent<T[N]>
+{
+ typedef T type;
+};
+
+//////////////////////////////////////
+// extent
+//////////////////////////////////////
+
+template<class T, unsigned N = 0>
+struct extent
+{
+ static const std::size_t value = 0;
+};
+
+template<class T>
+struct extent<T[], 0>
+{
+ static const std::size_t value = 0;
+};
+
+template<class T, unsigned N>
+struct extent<T[], N>
+{
+ static const std::size_t value = extent<T, N-1>::value;
+};
+
+template<class T, std::size_t N>
+struct extent<T[N], 0>
+{
+ static const std::size_t value = N;
+};
+
+template<class T, std::size_t I, unsigned N>
+struct extent<T[I], N>
+{
+ static const std::size_t value = extent<T, N-1>::value;
+};
+
+//////////////////////////////////////
+// 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 const t_unreferenced t_unreferenced_const;
+ typedef typename add_lvalue_reference
+ <t_unreferenced_const>::type type;
+};
+
+//////////////////////////////////////
+// is_same
+//////////////////////////////////////
+template<class T, class U>
+struct is_same
+{
+ static const bool value = false;
+};
+
+template<class T>
+struct is_same<T, T>
+{
+ static const bool value = true;
+};
+
+//////////////////////////////////////
+// is_pointer
+//////////////////////////////////////
+template< class T >
+struct is_pointer
+{
+ static const bool value = false;
+};
+
+template< class T >
+struct is_pointer<T*>
+{
+ static const bool value = true;
+};
+
+//////////////////////////////////////
+// is_reference
+//////////////////////////////////////
+template< class T >
+struct is_reference
+{
+ static const bool value = false;
+};
+
+template< class T >
+struct is_reference<T&>
+{
+ static const bool value = true;
+};
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template< class T >
+struct is_reference<T&&>
+{
+ static const bool value = true;
+};
+
+#endif
+
+//////////////////////////////////////
+// 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;
+};
+
+//////////////////////////////////////
+// is_array
+//////////////////////////////////////
+template<class T>
+struct is_array
+{
+ static const bool value = false;
+};
+
+template<class T>
+struct is_array<T[]>
+{
+ static const bool value = true;
+};
+
+template<class T, std::size_t N>
+struct is_array<T[N]>
+{
+ static const bool value = true;
+};
+
+//////////////////////////////////////
+// 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;
+};
+
+//////////////////////////////////////
+// pointer_type
+//////////////////////////////////////
+template <class T, class D, bool = has_pointer_type<D>::value>
+struct pointer_type_imp
+{
+ typedef typename D::pointer type;
+};
+
+template <class T, class D>
+struct pointer_type_imp<T, D, false>
+{
+ typedef typename remove_extent<T>::type* type;
+};
+
+template <class T, class D>
+struct pointer_type
+{
+ typedef typename pointer_type_imp
+ <typename remove_extent<T>::type, typename remove_reference<D>::type>::type type;
+};
+
+//////////////////////////////////////
+// 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
+
+//////////////////////////////////////
+// is_unary_function
+//////////////////////////////////////
+#if defined(BOOST_MSVC) || defined(__BORLANDC_)
+#define BOOST_MOVE_TT_DECL __cdecl
+#else
+#define BOOST_MOVE_TT_DECL
+#endif
+
+#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(UNDER_CE)
+#define BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
+#endif
+
+template <typename T>
+struct is_unary_function_impl
+{ static const bool value = false; };
+
+// avoid duplicate definitions of is_unary_function_impl
+#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
+
+template <typename R>
+struct is_unary_function_impl<R (*)()>
+{ static const bool value = true; };
+
+template <typename R>
+struct is_unary_function_impl<R (*)(...)>
+{ static const bool value = true; };
+
+#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
+
+template <typename R>
+struct is_unary_function_impl<R (__stdcall*)()>
+{ static const bool value = true; };
+
+#ifndef _MANAGED
+
+template <typename R>
+struct is_unary_function_impl<R (__fastcall*)()>
+{ static const bool value = true; };
+
+#endif
+
+template <typename R>
+struct is_unary_function_impl<R (__cdecl*)()>
+{ static const bool value = true; };
+
+template <typename R>
+struct is_unary_function_impl<R (__cdecl*)(...)>
+{ static const bool value = true; };
+
+#endif
+
+// avoid duplicate definitions of is_unary_function_impl
+#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
+
+template <typename R, class T0>
+struct is_unary_function_impl<R (*)(T0)>
+{ static const bool value = true; };
+
+template <typename R, class T0>
+struct is_unary_function_impl<R (*)(T0...)>
+{ static const bool value = true; };
+
+#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
+
+template <typename R, class T0>
+struct is_unary_function_impl<R (__stdcall*)(T0)>
+{ static const bool value = true; };
+
+#ifndef _MANAGED
+
+template <typename R, class T0>
+struct is_unary_function_impl<R (__fastcall*)(T0)>
+{ static const bool value = true; };
+
+#endif
+
+template <typename R, class T0>
+struct is_unary_function_impl<R (__cdecl*)(T0)>
+{ static const bool value = true; };
+
+template <typename R, class T0>
+struct is_unary_function_impl<R (__cdecl*)(T0...)>
+{ static const bool value = true; };
+
+#endif
+
+template <typename T>
+struct is_unary_function_impl<T&>
+{ static const bool value = false; };
+
+template<typename T>
+struct is_unary_function
+{ static const bool value = is_unary_function_impl<T>::value; };
+
+//////////////////////////////////////
+// has_virtual_destructor
+//////////////////////////////////////
+#if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\
+ || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500))
+# define BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
+#elif defined(BOOST_CLANG) && defined(__has_feature)
+# if __has_feature(has_virtual_destructor)
+# define BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
+# endif
+#elif defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG)
+# define BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
+#elif defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600)
+# define BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
+#elif defined(__CODEGEARC__)
+# define BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
+#endif
+
+#ifdef BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR
+ template<class T>
+ struct has_virtual_destructor{ static const bool value = BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T); };
+#else
+ //If no intrinsic is available you trust the programmer knows what is doing
+ template<class T>
+ struct has_virtual_destructor{ static const bool value = true; };
+#endif
+
+//////////////////////////////////////
+// missing_virtual_destructor
+//////////////////////////////////////
+
+template< class T, class U
+ , bool enable = is_convertible< U*, T*>::value &&
+ !is_array<T>::value &&
+ !is_same<typename remove_cv<T>::type, void>::value &&
+ !is_same<typename remove_cv<U>::type, typename remove_cv<T>::type>::value
+ >
+struct missing_virtual_destructor_default_delete
+{ static const bool value = !has_virtual_destructor<T>::value; };
+
+template<class T, class U>
+struct missing_virtual_destructor_default_delete<T, U, false>
+{ static const bool value = false; };
+
+template<class Deleter, class U>
+struct missing_virtual_destructor
+{ static const bool value = false; };
+
+template<class T, class U>
+struct missing_virtual_destructor< ::boost::movelib::default_delete<T>, U >
+ : missing_virtual_destructor_default_delete<T, U>
+{};
+
+} //namespace move_upmu {
+} //namespace boost {
+
+#endif //#ifndef BOOST_MOVE_UNIQUE_PTR_DETAIL_META_UTILS_HPP
diff --git a/contrib/src/boost/move/detail/workaround.hpp b/contrib/src/boost/move/detail/workaround.hpp
index 488492f..befe141 100644
--- a/contrib/src/boost/move/detail/workaround.hpp
+++ b/contrib/src/boost/move/detail/workaround.hpp
@@ -1,69 +1,68 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2014-2014. 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/interprocess for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
-#define BOOST_MOVE_DETAIL_WORKAROUND_HPP
-
-#ifndef BOOST_CONFIG_HPP
-# include <boost/config.hpp>
-#endif
-#
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-# pragma once
-#endif
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
- #define BOOST_MOVE_PERFECT_FORWARDING
-#endif
-
-#if defined(__has_feature)
- #define BOOST_MOVE_HAS_FEATURE __has_feature
-#else
- #define BOOST_MOVE_HAS_FEATURE(x) 0
-#endif
-
-#if BOOST_MOVE_HAS_FEATURE(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
- #define BOOST_MOVE_ADDRESS_SANITIZER_ON
-#endif
-
-//Macros for documentation purposes. For code, expands to the argument
-#define BOOST_MOVE_IMPDEF(TYPE) TYPE
-#define BOOST_MOVE_SEEDOC(TYPE) TYPE
-#define BOOST_MOVE_DOC0PTR(TYPE) TYPE
-#define BOOST_MOVE_DOC1ST(TYPE1, TYPE2) TYPE2
-#define BOOST_MOVE_I ,
-#define BOOST_MOVE_DOCIGN(T1) T1
-
-#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 5) && !defined(__clang__)
- //Pre-standard rvalue binding rules
- #define BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
-#elif defined(_MSC_VER) && (_MSC_VER == 1600)
- //Standard rvalue binding rules but with some bugs
- #define BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
- #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG
-#elif defined(_MSC_VER) && (_MSC_VER == 1700)
- #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG
-#endif
-
-#if defined(BOOST_MOVE_DISABLE_FORCEINLINE)
- #define BOOST_MOVE_FORCEINLINE inline
-#elif defined(BOOST_MOVE_FORCEINLINE_IS_BOOST_FORCELINE)
- #define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
-#elif defined(BOOST_MSVC) && defined(_DEBUG)
- //"__forceinline" and MSVC seems to have some bugs in debug mode
- #define BOOST_MOVE_FORCEINLINE inline
-#elif defined(__GNUC__) && ((__GNUC__ < 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ < 5)))
- //Older GCCs have problems with forceinline
- #define BOOST_MOVE_FORCEINLINE inline
-#else
- #define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
-#endif
-
-#endif //#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014. 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/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
+#define BOOST_MOVE_DETAIL_WORKAROUND_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ #define BOOST_MOVE_PERFECT_FORWARDING
+#endif
+
+#if defined(__has_feature)
+ #define BOOST_MOVE_HAS_FEATURE __has_feature
+#else
+ #define BOOST_MOVE_HAS_FEATURE(x) 0
+#endif
+
+#if BOOST_MOVE_HAS_FEATURE(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
+ #define BOOST_MOVE_ADDRESS_SANITIZER_ON
+#endif
+
+//Macros for documentation purposes. For code, expands to the argument
+#define BOOST_MOVE_IMPDEF(TYPE) TYPE
+#define BOOST_MOVE_SEEDOC(TYPE) TYPE
+#define BOOST_MOVE_DOC0PTR(TYPE) TYPE
+#define BOOST_MOVE_DOC1ST(TYPE1, TYPE2) TYPE2
+#define BOOST_MOVE_I ,
+#define BOOST_MOVE_DOCIGN(T1) T1
+
+#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 5) && !defined(__clang__)
+ //Pre-standard rvalue binding rules
+ #define BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+#elif defined(_MSC_VER) && (_MSC_VER == 1600)
+ //Standard rvalue binding rules but with some bugs
+ #define BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
+ #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG
+#elif defined(_MSC_VER) && (_MSC_VER == 1700)
+ #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG
+#endif
+
+#define BOOST_MOVE_DISABLE_FORCEINLINE
+
+#if defined(BOOST_MOVE_DISABLE_FORCEINLINE)
+ #define BOOST_MOVE_FORCEINLINE inline
+#elif defined(BOOST_MOVE_FORCEINLINE_IS_BOOST_FORCELINE)
+ #define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
+#elif defined(BOOST_MSVC) && defined(_DEBUG)
+ //"__forceinline" and MSVC seems to have some bugs in debug mode
+ #define BOOST_MOVE_FORCEINLINE inline
+#else
+ #define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
+#endif
+
+#endif //#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
generated by cgit v0.12 at 2024-07-01 02:16:24 (GMT)