diff options
Diffstat (limited to 'contrib/src/boost/move')
24 files changed, 6803 insertions, 3727 deletions
diff --git a/contrib/src/boost/move/adl_move_swap.hpp b/contrib/src/boost/move/adl_move_swap.hpp new file mode 100644 index 0000000..9303201 --- /dev/null +++ b/contrib/src/boost/move/adl_move_swap.hpp @@ -0,0 +1,266 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker +// (C) Copyright Ion Gaztanaga 2005-2013. 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_ADL_MOVE_SWAP_HPP +#define BOOST_MOVE_ADL_MOVE_SWAP_HPP + +#ifndef BOOST_CONFIG_HPP +# include <boost/config.hpp> +#endif +# +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +//Based on Boost.Core's swap. +//Many thanks to Steven Watanabe, Joseph Gauterin and Niels Dekker. +#include <cstddef> //for std::size_t +#include <boost/move/detail/workaround.hpp> //forceinline + +//Try to avoid including <algorithm>, as it's quite big +#if defined(_MSC_VER) && defined(BOOST_DINKUMWARE_STDLIB) + #include <utility> //Dinkum libraries define std::swap in utility which is lighter than algorithm +#elif defined(BOOST_GNU_STDLIB) + //For non-GCC compilers, where GNUC version is not very reliable, or old GCC versions + //use the good old stl_algobase header, which is quite lightweight + #if !defined(BOOST_GCC) || ((__GNUC__ < 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ < 3))) + #include <bits/stl_algobase.h> + #elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 3) + //In GCC 4.3 a tiny stl_move.h was created with swap and move utilities + #include <bits/stl_move.h> + #else + //In GCC 4.4 stl_move.h was renamed to move.h + #include <bits/move.h> + #endif +#elif defined(_LIBCPP_VERSION) + #include <type_traits> //The initial import of libc++ defines std::swap and still there +#elif __cplusplus >= 201103L + #include <utility> //Fallback for C++ >= 2011 +#else + #include <algorithm> //Fallback for C++98/03 +#endif + +#include <boost/move/utility_core.hpp> //for boost::move + +#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +namespace boost_move_member_swap { + +struct dont_care +{ + dont_care(...); +}; + +struct private_type +{ + static private_type p; + private_type const &operator,(int) const; +}; + +typedef char yes_type; +struct no_type{ char dummy[2]; }; + +template<typename T> +no_type is_private_type(T const &); + +yes_type is_private_type(private_type const &); + +template <typename Type> +class has_member_function_named_swap +{ + struct BaseMixin + { + void swap(); + }; + + struct Base : public Type, public BaseMixin { Base(); }; + template <typename T, T t> class Helper{}; + + template <typename U> + static no_type deduce(U*, Helper<void (BaseMixin::*)(), &U::swap>* = 0); + static yes_type deduce(...); + + public: + static const bool value = sizeof(yes_type) == sizeof(deduce((Base*)(0))); +}; + +template<typename Fun, bool HasFunc> +struct has_member_swap_impl +{ + static const bool value = false; +}; + +template<typename Fun> +struct has_member_swap_impl<Fun, true> +{ + struct FunWrap : Fun + { + FunWrap(); + + using Fun::swap; + private_type swap(dont_care) const; + }; + + static Fun &declval_fun(); + static FunWrap declval_wrap(); + + static bool const value = + sizeof(no_type) == sizeof(is_private_type( (declval_wrap().swap(declval_fun()), 0)) ); +}; + +template<typename Fun> +struct has_member_swap : public has_member_swap_impl + <Fun, has_member_function_named_swap<Fun>::value> +{}; + +} //namespace boost_move_member_swap + +namespace boost_move_adl_swap{ + +template<class P1, class P2, bool = P1::value> +struct and_op_impl +{ static const bool value = false; }; + +template<class P1, class P2> +struct and_op_impl<P1, P2, true> +{ static const bool value = P2::value; }; + +template<class P1, class P2> +struct and_op + : and_op_impl<P1, P2> +{}; + +////// + +template<class P1, class P2, bool = P1::value> +struct and_op_not_impl +{ static const bool value = false; }; + +template<class P1, class P2> +struct and_op_not_impl<P1, P2, true> +{ static const bool value = !P2::value; }; + +template<class P1, class P2> +struct and_op_not + : and_op_not_impl<P1, P2> +{}; + +template<class T> +BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y, typename boost::move_detail::enable_if_c<!boost::move_detail::has_move_emulation_enabled_impl<T>::value>::type* = 0) +{ + //use std::swap if argument dependent lookup fails + //Use using directive ("using namespace xxx;") instead as some older compilers + //don't do ADL with using declarations ("using ns::func;"). + using namespace std; + swap(x, y); +} + +template<class T> +BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y + , typename boost::move_detail::enable_if< and_op_not_impl<boost::move_detail::has_move_emulation_enabled_impl<T> + , boost_move_member_swap::has_member_swap<T> > + >::type* = 0) +{ T t(::boost::move(x)); x = ::boost::move(y); y = ::boost::move(t); } + +template<class T> +BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y + , typename boost::move_detail::enable_if< and_op_impl< boost::move_detail::has_move_emulation_enabled_impl<T> + , boost_move_member_swap::has_member_swap<T> > + >::type* = 0) +{ x.swap(y); } + +} //namespace boost_move_adl_swap{ + +#else + +namespace boost_move_adl_swap{ + +template<class T> +BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y) +{ + using std::swap; + swap(x, y); +} + +} //namespace boost_move_adl_swap{ + +#endif //#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + +namespace boost_move_adl_swap{ + +template<class T, std::size_t N> +void swap_proxy(T (& x)[N], T (& y)[N]) +{ + for (std::size_t i = 0; i < N; ++i){ + ::boost_move_adl_swap::swap_proxy(x[i], y[i]); + } +} + +} //namespace boost_move_adl_swap { + +#endif //!defined(BOOST_MOVE_DOXYGEN_INVOKED) + +namespace boost{ + +//! Exchanges the values of a and b, using Argument Dependent Lookup (ADL) to select a +//! specialized swap function if available. If no specialized swap function is available, +//! std::swap is used. +//! +//! <b>Exception</b>: If T uses Boost.Move's move emulation and the compiler has +//! no rvalue references then: +//! +//! - If T has a <code>T::swap(T&)</code> member, that member is called. +//! - Otherwise a move-based swap is called, equivalent to: +//! <code>T t(::boost::move(x)); x = ::boost::move(y); y = ::boost::move(t);</code>. +template<class T> +BOOST_MOVE_FORCEINLINE void adl_move_swap(T& x, T& y) +{ + ::boost_move_adl_swap::swap_proxy(x, y); +} + +//! Exchanges elements between range [first1, last1) and another range starting at first2 +//! using boost::adl_move_swap. +//! +//! Parameters: +//! first1, last1 - the first range of elements to swap +//! first2 - beginning of the second range of elements to swap +//! +//! Type requirements: +//! - ForwardIt1, ForwardIt2 must meet the requirements of ForwardIterator. +//! - The types of dereferenced ForwardIt1 and ForwardIt2 must meet the +//! requirements of Swappable +//! +//! Return value: Iterator to the element past the last element exchanged in the range +//! beginning with first2. +template<class ForwardIt1, class ForwardIt2> +ForwardIt2 adl_move_swap_ranges(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2) +{ + while (first1 != last1) { + ::boost::adl_move_swap(*first1, *first2); + ++first1; + ++first2; + } + return first2; +} + +template<class BidirIt1, class BidirIt2> +BidirIt2 adl_move_swap_ranges_backward(BidirIt1 first1, BidirIt1 last1, BidirIt2 last2) +{ + while (first1 != last1) { + ::boost::adl_move_swap(*(--last1), *(--last2)); + } + return last2; +} + +} //namespace boost{ + +#endif //#ifndef BOOST_MOVE_ADL_MOVE_SWAP_HPP diff --git a/contrib/src/boost/move/algo/move.hpp b/contrib/src/boost/move/algo/move.hpp index ce96bba..943f286 100644 --- a/contrib/src/boost/move/algo/move.hpp +++ b/contrib/src/boost/move/algo/move.hpp @@ -1,155 +1,155 @@ -//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2012-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.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! \file
-
-#ifndef BOOST_MOVE_ALGO_MOVE_HPP
-#define BOOST_MOVE_ALGO_MOVE_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/utility_core.hpp>
-#include <boost/move/detail/iterator_traits.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-
-namespace boost {
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// move
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#if !defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
-
- //! <b>Effects</b>: Moves elements in the range [first,last) into the range [result,result + (last -
- //! first)) starting from first and proceeding to last. For each non-negative integer n < (last-first),
- //! performs *(result + n) = ::boost::move (*(first + n)).
- //!
- //! <b>Effects</b>: result + (last - first).
- //!
- //! <b>Requires</b>: result shall not be in the range [first,last).
- //!
- //! <b>Complexity</b>: Exactly last - first move assignments.
- template <typename I, // I models InputIterator
- typename O> // O models OutputIterator
- O move(I f, I l, O result)
- {
- while (f != l) {
- *result = ::boost::move(*f);
- ++f; ++result;
- }
- return result;
- }
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // move_backward
- //
- //////////////////////////////////////////////////////////////////////////////
-
- //! <b>Effects</b>: Moves elements in the range [first,last) into the range
- //! [result - (last-first),result) starting from last - 1 and proceeding to
- //! first. For each positive integer n <= (last - first),
- //! performs *(result - n) = ::boost::move(*(last - n)).
- //!
- //! <b>Requires</b>: result shall not be in the range [first,last).
- //!
- //! <b>Returns</b>: result - (last - first).
- //!
- //! <b>Complexity</b>: Exactly last - first assignments.
- template <typename I, // I models BidirectionalIterator
- typename O> // O models BidirectionalIterator
- O move_backward(I f, I l, O result)
- {
- while (f != l) {
- --l; --result;
- *result = ::boost::move(*l);
- }
- return result;
- }
-
-#else
-
- using ::std::move_backward;
-
-#endif //!defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// uninitialized_move
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! <b>Effects</b>:
-//! \code
-//! for (; first != last; ++result, ++first)
-//! new (static_cast<void*>(&*result))
-//! typename iterator_traits<ForwardIterator>::value_type(boost::move(*first));
-//! \endcode
-//!
-//! <b>Returns</b>: result
-template
- <typename I, // I models InputIterator
- typename F> // F models ForwardIterator
-F uninitialized_move(I f, I l, F r
- /// @cond
-// ,typename ::boost::move_detail::enable_if<has_move_emulation_enabled<typename boost::movelib::iterator_traits<I>::value_type> >::type* = 0
- /// @endcond
- )
-{
- typedef typename boost::movelib::iterator_traits<I>::value_type input_value_type;
-
- F back = r;
- BOOST_TRY{
- while (f != l) {
- void * const addr = static_cast<void*>(::boost::move_detail::addressof(*r));
- ::new(addr) input_value_type(::boost::move(*f));
- ++f; ++r;
- }
- }
- BOOST_CATCH(...){
- for (; back != r; ++back){
- back->~input_value_type();
- }
- BOOST_RETHROW;
- }
- BOOST_CATCH_END
- return r;
-}
-
-/// @cond
-/*
-template
- <typename I, // I models InputIterator
- typename F> // F models ForwardIterator
-F uninitialized_move(I f, I l, F r,
- typename ::boost::move_detail::disable_if<has_move_emulation_enabled<typename boost::movelib::iterator_traits<I>::value_type> >::type* = 0)
-{
- return std::uninitialized_copy(f, l, r);
-}
-*/
-
-/// @endcond
-
-} //namespace boost {
-
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_ALGO_MOVE_HPP
+////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2012-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. +// +////////////////////////////////////////////////////////////////////////////// + +//! \file + +#ifndef BOOST_MOVE_ALGO_MOVE_HPP +#define BOOST_MOVE_ALGO_MOVE_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/utility_core.hpp> +#include <boost/move/detail/iterator_traits.hpp> +#include <boost/detail/no_exceptions_support.hpp> + +namespace boost { + +////////////////////////////////////////////////////////////////////////////// +// +// move +// +////////////////////////////////////////////////////////////////////////////// + +#if !defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE) + + //! <b>Effects</b>: Moves elements in the range [first,last) into the range [result,result + (last - + //! first)) starting from first and proceeding to last. For each non-negative integer n < (last-first), + //! performs *(result + n) = ::boost::move (*(first + n)). + //! + //! <b>Effects</b>: result + (last - first). + //! + //! <b>Requires</b>: result shall not be in the range [first,last). + //! + //! <b>Complexity</b>: Exactly last - first move assignments. + template <typename I, // I models InputIterator + typename O> // O models OutputIterator + O move(I f, I l, O result) + { + while (f != l) { + *result = ::boost::move(*f); + ++f; ++result; + } + return result; + } + + ////////////////////////////////////////////////////////////////////////////// + // + // move_backward + // + ////////////////////////////////////////////////////////////////////////////// + + //! <b>Effects</b>: Moves elements in the range [first,last) into the range + //! [result - (last-first),result) starting from last - 1 and proceeding to + //! first. For each positive integer n <= (last - first), + //! performs *(result - n) = ::boost::move(*(last - n)). + //! + //! <b>Requires</b>: result shall not be in the range [first,last). + //! + //! <b>Returns</b>: result - (last - first). + //! + //! <b>Complexity</b>: Exactly last - first assignments. + template <typename I, // I models BidirectionalIterator + typename O> // O models BidirectionalIterator + O move_backward(I f, I l, O result) + { + while (f != l) { + --l; --result; + *result = ::boost::move(*l); + } + return result; + } + +#else + + using ::std::move_backward; + +#endif //!defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE) + +////////////////////////////////////////////////////////////////////////////// +// +// uninitialized_move +// +////////////////////////////////////////////////////////////////////////////// + +//! <b>Effects</b>: +//! \code +//! for (; first != last; ++result, ++first) +//! new (static_cast<void*>(&*result)) +//! typename iterator_traits<ForwardIterator>::value_type(boost::move(*first)); +//! \endcode +//! +//! <b>Returns</b>: result +template + <typename I, // I models InputIterator + typename F> // F models ForwardIterator +F uninitialized_move(I f, I l, F r + /// @cond +// ,typename ::boost::move_detail::enable_if<has_move_emulation_enabled<typename boost::movelib::iterator_traits<I>::value_type> >::type* = 0 + /// @endcond + ) +{ + typedef typename boost::movelib::iterator_traits<I>::value_type input_value_type; + + F back = r; + BOOST_TRY{ + while (f != l) { + void * const addr = static_cast<void*>(::boost::move_detail::addressof(*r)); + ::new(addr) input_value_type(::boost::move(*f)); + ++f; ++r; + } + } + BOOST_CATCH(...){ + for (; back != r; ++back){ + back->~input_value_type(); + } + BOOST_RETHROW; + } + BOOST_CATCH_END + return r; +} + +/// @cond +/* +template + <typename I, // I models InputIterator + typename F> // F models ForwardIterator +F uninitialized_move(I f, I l, F r, + typename ::boost::move_detail::disable_if<has_move_emulation_enabled<typename boost::movelib::iterator_traits<I>::value_type> >::type* = 0) +{ + return std::uninitialized_copy(f, l, r); +} +*/ + +/// @endcond + +} //namespace boost { + +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_ALGO_MOVE_HPP diff --git a/contrib/src/boost/move/algorithm.hpp b/contrib/src/boost/move/algorithm.hpp index 8354e8d..825d771 100644 --- a/contrib/src/boost/move/algorithm.hpp +++ b/contrib/src/boost/move/algorithm.hpp @@ -1,167 +1,167 @@ -//////////////////////////////////////////////////////////////////////////////
-//
-// (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_ALGORITHM_HPP
-#define BOOST_MOVE_ALGORITHM_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/utility_core.hpp>
-#include <boost/move/iterator.hpp>
-#include <boost/move/algo/move.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-
-#include <algorithm> //copy, copy_backward
-#include <memory> //uninitialized_copy
-
-namespace boost {
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// uninitialized_copy_or_move
-//
-//////////////////////////////////////////////////////////////////////////////
-
-namespace move_detail {
-
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-inline F uninitialized_move_move_iterator(I f, I l, F r
-// ,typename ::boost::move_detail::enable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0
-)
-{
- return ::boost::uninitialized_move(f, l, r);
-}
-/*
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-F uninitialized_move_move_iterator(I f, I l, F r,
- typename ::boost::move_detail::disable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0)
-{
- return std::uninitialized_copy(f.base(), l.base(), r);
-}
-*/
-} //namespace move_detail {
-
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-inline F uninitialized_copy_or_move(I f, I l, F r,
- typename ::boost::move_detail::enable_if< move_detail::is_move_iterator<I> >::type* = 0)
-{
- return ::boost::move_detail::uninitialized_move_move_iterator(f, l, r);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// copy_or_move
-//
-//////////////////////////////////////////////////////////////////////////////
-
-namespace move_detail {
-
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-inline F move_move_iterator(I f, I l, F r
-// ,typename ::boost::move_detail::enable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0
-)
-{
- return ::boost::move(f, l, r);
-}
-/*
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-F move_move_iterator(I f, I l, F r,
- typename ::boost::move_detail::disable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0)
-{
- return std::copy(f.base(), l.base(), r);
-}
-*/
-
-} //namespace move_detail {
-
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-inline F copy_or_move(I f, I l, F r,
- typename ::boost::move_detail::enable_if< move_detail::is_move_iterator<I> >::type* = 0)
-{
- return ::boost::move_detail::move_move_iterator(f, l, r);
-}
-
-/// @endcond
-
-//! <b>Effects</b>:
-//! \code
-//! for (; first != last; ++result, ++first)
-//! new (static_cast<void*>(&*result))
-//! typename iterator_traits<ForwardIterator>::value_type(*first);
-//! \endcode
-//!
-//! <b>Returns</b>: result
-//!
-//! <b>Note</b>: This function is provided because
-//! <i>std::uninitialized_copy</i> from some STL implementations
-//! is not compatible with <i>move_iterator</i>
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-inline F uninitialized_copy_or_move(I f, I l, F r
- /// @cond
- ,typename ::boost::move_detail::disable_if< move_detail::is_move_iterator<I> >::type* = 0
- /// @endcond
- )
-{
- return std::uninitialized_copy(f, l, r);
-}
-
-//! <b>Effects</b>:
-//! \code
-//! for (; first != last; ++result, ++first)
-//! *result = *first;
-//! \endcode
-//!
-//! <b>Returns</b>: result
-//!
-//! <b>Note</b>: This function is provided because
-//! <i>std::uninitialized_copy</i> from some STL implementations
-//! is not compatible with <i>move_iterator</i>
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-inline F copy_or_move(I f, I l, F r
- /// @cond
- ,typename ::boost::move_detail::disable_if< move_detail::is_move_iterator<I> >::type* = 0
- /// @endcond
- )
-{
- return std::copy(f, l, r);
-}
-
-} //namespace boost {
-
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_ALGORITHM_HPP
+////////////////////////////////////////////////////////////////////////////// +// +// (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_ALGORITHM_HPP +#define BOOST_MOVE_ALGORITHM_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/utility_core.hpp> +#include <boost/move/iterator.hpp> +#include <boost/move/algo/move.hpp> +#include <boost/detail/no_exceptions_support.hpp> + +#include <algorithm> //copy, copy_backward +#include <memory> //uninitialized_copy + +namespace boost { + +////////////////////////////////////////////////////////////////////////////// +// +// uninitialized_copy_or_move +// +////////////////////////////////////////////////////////////////////////////// + +namespace move_detail { + +template +<typename I, // I models InputIterator +typename F> // F models ForwardIterator +inline F uninitialized_move_move_iterator(I f, I l, F r +// ,typename ::boost::move_detail::enable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0 +) +{ + return ::boost::uninitialized_move(f, l, r); +} +/* +template +<typename I, // I models InputIterator +typename F> // F models ForwardIterator +F uninitialized_move_move_iterator(I f, I l, F r, + typename ::boost::move_detail::disable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0) +{ + return std::uninitialized_copy(f.base(), l.base(), r); +} +*/ +} //namespace move_detail { + +template +<typename I, // I models InputIterator +typename F> // F models ForwardIterator +inline F uninitialized_copy_or_move(I f, I l, F r, + typename ::boost::move_detail::enable_if< move_detail::is_move_iterator<I> >::type* = 0) +{ + return ::boost::move_detail::uninitialized_move_move_iterator(f, l, r); +} + +////////////////////////////////////////////////////////////////////////////// +// +// copy_or_move +// +////////////////////////////////////////////////////////////////////////////// + +namespace move_detail { + +template +<typename I, // I models InputIterator +typename F> // F models ForwardIterator +inline F move_move_iterator(I f, I l, F r +// ,typename ::boost::move_detail::enable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0 +) +{ + return ::boost::move(f, l, r); +} +/* +template +<typename I, // I models InputIterator +typename F> // F models ForwardIterator +F move_move_iterator(I f, I l, F r, + typename ::boost::move_detail::disable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0) +{ + return std::copy(f.base(), l.base(), r); +} +*/ + +} //namespace move_detail { + +template +<typename I, // I models InputIterator +typename F> // F models ForwardIterator +inline F copy_or_move(I f, I l, F r, + typename ::boost::move_detail::enable_if< move_detail::is_move_iterator<I> >::type* = 0) +{ + return ::boost::move_detail::move_move_iterator(f, l, r); +} + +/// @endcond + +//! <b>Effects</b>: +//! \code +//! for (; first != last; ++result, ++first) +//! new (static_cast<void*>(&*result)) +//! typename iterator_traits<ForwardIterator>::value_type(*first); +//! \endcode +//! +//! <b>Returns</b>: result +//! +//! <b>Note</b>: This function is provided because +//! <i>std::uninitialized_copy</i> from some STL implementations +//! is not compatible with <i>move_iterator</i> +template +<typename I, // I models InputIterator +typename F> // F models ForwardIterator +inline F uninitialized_copy_or_move(I f, I l, F r + /// @cond + ,typename ::boost::move_detail::disable_if< move_detail::is_move_iterator<I> >::type* = 0 + /// @endcond + ) +{ + return std::uninitialized_copy(f, l, r); +} + +//! <b>Effects</b>: +//! \code +//! for (; first != last; ++result, ++first) +//! *result = *first; +//! \endcode +//! +//! <b>Returns</b>: result +//! +//! <b>Note</b>: This function is provided because +//! <i>std::uninitialized_copy</i> from some STL implementations +//! is not compatible with <i>move_iterator</i> +template +<typename I, // I models InputIterator +typename F> // F models ForwardIterator +inline F copy_or_move(I f, I l, F r + /// @cond + ,typename ::boost::move_detail::disable_if< move_detail::is_move_iterator<I> >::type* = 0 + /// @endcond + ) +{ + return std::copy(f, l, r); +} + +} //namespace boost { + +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_ALGORITHM_HPP diff --git a/contrib/src/boost/move/core.hpp b/contrib/src/boost/move/core.hpp index 785b20e..c9cbec2 100644 --- a/contrib/src/boost/move/core.hpp +++ b/contrib/src/boost/move/core.hpp @@ -1,502 +1,502 @@ -//////////////////////////////////////////////////////////////////////////////
-//
-// (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
-//! This header implements macros to define movable classes and
-//! move-aware functions
-
-#ifndef BOOST_MOVE_CORE_HPP
-#define BOOST_MOVE_CORE_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>
-
-// @cond
-
-//boost_move_no_copy_constructor_or_assign typedef
-//used to detect noncopyable types for other Boost libraries.
-#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
- #define BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE) \
- private:\
- TYPE(TYPE &);\
- TYPE& operator=(TYPE &);\
- public:\
- typedef int boost_move_no_copy_constructor_or_assign; \
- private:\
- //
-#else
- #define BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE) \
- public:\
- TYPE(TYPE const &) = delete;\
- TYPE& operator=(TYPE const &) = delete;\
- public:\
- typedef int boost_move_no_copy_constructor_or_assign; \
- private:\
- //
-#endif //BOOST_NO_CXX11_DELETED_FUNCTIONS
-
-// @endcond
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- #include <boost/move/detail/type_traits.hpp>
-
- #if defined(BOOST_MOVE_ADDRESS_SANITIZER_ON)
- #define BOOST_MOVE_TO_RV_CAST(RV_TYPE, ARG) reinterpret_cast<RV_TYPE>(ARG)
- #else
- #define BOOST_MOVE_TO_RV_CAST(RV_TYPE, ARG) static_cast<RV_TYPE>(ARG)
- #endif
-
- //Move emulation rv breaks standard aliasing rules so add workarounds for some compilers
- #if defined(__GNUC__) && (__GNUC__ >= 4) && \
- (\
- defined(BOOST_GCC) || \
- (defined(BOOST_INTEL) && (BOOST_INTEL_CXX_VERSION >= 1300)) \
- )
- #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__))
- #else
- #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS
- #endif
-
- namespace boost {
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // struct rv
- //
- //////////////////////////////////////////////////////////////////////////////
- template <class T>
- class rv
- : public ::boost::move_detail::if_c
- < ::boost::move_detail::is_class<T>::value
- , T
- , ::boost::move_detail::nat
- >::type
- {
- rv();
- ~rv() throw();
- rv(rv const&);
- void operator=(rv const&);
- } BOOST_MOVE_ATTRIBUTE_MAY_ALIAS;
-
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // is_rv
- //
- //////////////////////////////////////////////////////////////////////////////
-
- namespace move_detail {
-
- template <class T>
- struct is_rv
- //Derive from integral constant because some Boost code assummes it has
- //a "type" internal typedef
- : integral_constant<bool, ::boost::move_detail::is_rv_impl<T>::value >
- {};
-
- template <class T>
- struct is_not_rv
- {
- static const bool value = !is_rv<T>::value;
- };
-
- } //namespace move_detail {
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // has_move_emulation_enabled
- //
- //////////////////////////////////////////////////////////////////////////////
- template<class T>
- struct has_move_emulation_enabled
- : ::boost::move_detail::has_move_emulation_enabled_impl<T>
- {};
-
- template<class T>
- struct has_move_emulation_disabled
- {
- static const bool value = !::boost::move_detail::has_move_emulation_enabled_impl<T>::value;
- };
-
- } //namespace boost {
-
- #define BOOST_RV_REF(TYPE)\
- ::boost::rv< TYPE >& \
- //
-
- #define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- ::boost::rv< TYPE<ARG1, ARG2> >& \
- //
-
- #define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- ::boost::rv< TYPE<ARG1, ARG2, ARG3> >& \
- //
-
- #define BOOST_RV_REF_BEG\
- ::boost::rv< \
- //
-
- #define BOOST_RV_REF_END\
- >& \
- //
-
- #define BOOST_RV_REF_BEG_IF_CXX11 \
- \
- //
-
- #define BOOST_RV_REF_END_IF_CXX11 \
- \
- //
-
- #define BOOST_FWD_REF(TYPE)\
- const TYPE & \
- //
-
- #define BOOST_COPY_ASSIGN_REF(TYPE)\
- const ::boost::rv< TYPE >& \
- //
-
- #define BOOST_COPY_ASSIGN_REF_BEG \
- const ::boost::rv< \
- //
-
- #define BOOST_COPY_ASSIGN_REF_END \
- >& \
- //
-
- #define BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- const ::boost::rv< TYPE<ARG1, ARG2> >& \
- //
-
- #define BOOST_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- const ::boost::rv< TYPE<ARG1, ARG2, ARG3> >& \
- //
-
- #define BOOST_CATCH_CONST_RLVALUE(TYPE)\
- const ::boost::rv< TYPE >& \
- //
-
- namespace boost {
- namespace move_detail {
-
- template <class Ret, class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < ::boost::move_detail::is_lvalue_reference<Ret>::value ||
- !::boost::has_move_emulation_enabled<T>::value
- , T&>::type
- move_return(T& x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- template <class Ret, class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < !::boost::move_detail::is_lvalue_reference<Ret>::value &&
- ::boost::has_move_emulation_enabled<T>::value
- , ::boost::rv<T>&>::type
- move_return(T& x) BOOST_NOEXCEPT
- {
- return *BOOST_MOVE_TO_RV_CAST(::boost::rv<T>*, ::boost::move_detail::addressof(x));
- }
-
- template <class Ret, class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < !::boost::move_detail::is_lvalue_reference<Ret>::value &&
- ::boost::has_move_emulation_enabled<T>::value
- , ::boost::rv<T>&>::type
- move_return(::boost::rv<T>& x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- } //namespace move_detail {
- } //namespace boost {
-
- #define BOOST_MOVE_RET(RET_TYPE, REF)\
- boost::move_detail::move_return< RET_TYPE >(REF)
- //
-
- #define BOOST_MOVE_BASE(BASE_TYPE, ARG) \
- ::boost::move((BASE_TYPE&)(ARG))
- //
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // BOOST_MOVABLE_BUT_NOT_COPYABLE
- //
- //////////////////////////////////////////////////////////////////////////////
- #define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
- BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE)\
- public:\
- BOOST_MOVE_FORCEINLINE operator ::boost::rv<TYPE>&() \
- { return *BOOST_MOVE_TO_RV_CAST(::boost::rv<TYPE>*, this); }\
- BOOST_MOVE_FORCEINLINE operator const ::boost::rv<TYPE>&() const \
- { return *BOOST_MOVE_TO_RV_CAST(const ::boost::rv<TYPE>*, this); }\
- private:\
- //
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // BOOST_COPYABLE_AND_MOVABLE
- //
- //////////////////////////////////////////////////////////////////////////////
-
- #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
- public:\
- BOOST_MOVE_FORCEINLINE TYPE& operator=(TYPE &t)\
- { this->operator=(const_cast<const TYPE&>(t)); return *this;}\
- public:\
- BOOST_MOVE_FORCEINLINE operator ::boost::rv<TYPE>&() \
- { return *BOOST_MOVE_TO_RV_CAST(::boost::rv<TYPE>*, this); }\
- BOOST_MOVE_FORCEINLINE operator const ::boost::rv<TYPE>&() const \
- { return *BOOST_MOVE_TO_RV_CAST(const ::boost::rv<TYPE>*, this); }\
- private:\
- //
-
- #define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE)\
- public:\
- BOOST_MOVE_FORCEINLINE operator ::boost::rv<TYPE>&() \
- { return *BOOST_MOVE_TO_RV_CAST(::boost::rv<TYPE>*, this); }\
- BOOST_MOVE_FORCEINLINE operator const ::boost::rv<TYPE>&() const \
- { return *BOOST_MOVE_TO_RV_CAST(const ::boost::rv<TYPE>*, this); }\
- private:\
- //
-
- namespace boost{
- namespace move_detail{
-
- template< class T>
- struct forward_type
- { typedef const T &type; };
-
- template< class T>
- struct forward_type< boost::rv<T> >
- { typedef T type; };
-
- }}
-
-#else //BOOST_NO_CXX11_RVALUE_REFERENCES
-
- //! This macro marks a type as movable but not copyable, disabling copy construction
- //! and assignment. The user will need to write a move constructor/assignment as explained
- //! in the documentation to fully write a movable but not copyable class.
- #define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
- BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE)\
- public:\
- typedef int boost_move_emulation_t;\
- private:\
- //
-
- //! This macro marks a type as copyable and movable.
- //! The user will need to write a move constructor/assignment and a copy assignment
- //! as explained in the documentation to fully write a copyable and movable class.
- #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
- //
-
- #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- #define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE)\
- //
- #endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- namespace boost {
-
- //!This trait yields to a compile-time true boolean if T was marked as
- //!BOOST_MOVABLE_BUT_NOT_COPYABLE or BOOST_COPYABLE_AND_MOVABLE and
- //!rvalue references are not available on the platform. False otherwise.
- template<class T>
- struct has_move_emulation_enabled
- {
- static const bool value = false;
- };
-
- template<class T>
- struct has_move_emulation_disabled
- {
- static const bool value = true;
- };
-
- } //namespace boost{
-
- //!This macro is used to achieve portable syntax in move
- //!constructors and assignments for classes marked as
- //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE
- #define BOOST_RV_REF(TYPE)\
- TYPE && \
- //
-
- //!This macro is used to achieve portable syntax in move
- //!constructors and assignments for template classes marked as
- //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE.
- //!As macros have problems with comma-separated template arguments,
- //!the template argument must be preceded with BOOST_RV_REF_BEG
- //!and ended with BOOST_RV_REF_END
- #define BOOST_RV_REF_BEG\
- \
- //
-
- //!This macro is used to achieve portable syntax in move
- //!constructors and assignments for template classes marked as
- //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE.
- //!As macros have problems with comma-separated template arguments,
- //!the template argument must be preceded with BOOST_RV_REF_BEG
- //!and ended with BOOST_RV_REF_END
- #define BOOST_RV_REF_END\
- && \
- //
-
- //!This macro expands to BOOST_RV_REF_BEG if BOOST_NO_CXX11_RVALUE_REFERENCES
- //!is not defined, empty otherwise
- #define BOOST_RV_REF_BEG_IF_CXX11 \
- BOOST_RV_REF_BEG \
- //
-
- //!This macro expands to BOOST_RV_REF_END if BOOST_NO_CXX11_RVALUE_REFERENCES
- //!is not defined, empty otherwise
- #define BOOST_RV_REF_END_IF_CXX11 \
- BOOST_RV_REF_END \
- //
-
- //!This macro is used to achieve portable syntax in copy
- //!assignment for classes marked as BOOST_COPYABLE_AND_MOVABLE.
- #define BOOST_COPY_ASSIGN_REF(TYPE)\
- const TYPE & \
- //
-
- //! This macro is used to implement portable perfect forwarding
- //! as explained in the documentation.
- #define BOOST_FWD_REF(TYPE)\
- TYPE && \
- //
-
- #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- #define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- TYPE<ARG1, ARG2> && \
- //
-
- #define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- TYPE<ARG1, ARG2, ARG3> && \
- //
-
- #define BOOST_COPY_ASSIGN_REF_BEG \
- const \
- //
-
- #define BOOST_COPY_ASSIGN_REF_END \
- & \
- //
-
- #define BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- const TYPE<ARG1, ARG2> & \
- //
-
- #define BOOST_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- const TYPE<ARG1, ARG2, ARG3>& \
- //
-
- #define BOOST_CATCH_CONST_RLVALUE(TYPE)\
- const TYPE & \
- //
-
- #endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- #if !defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- //!This macro is used to achieve portable move return semantics.
- //!The C++11 Standard allows implicit move returns when the object to be returned
- //!is designated by a lvalue and:
- //! - The criteria for elision of a copy operation are met OR
- //! - The criteria would be met save for the fact that the source object is a function parameter
- //!
- //!For C++11 conforming compilers this macros only yields to REF:
- //! <code>return BOOST_MOVE_RET(RET_TYPE, REF);</code> -> <code>return REF;</code>
- //!
- //!For compilers without rvalue references
- //!this macro does an explicit move if the move emulation is activated
- //!and the return type (RET_TYPE) is not a reference.
- //!
- //!For non-conforming compilers with rvalue references like Visual 2010 & 2012,
- //!an explicit move is performed if RET_TYPE is not a reference.
- //!
- //! <b>Caution</b>: When using this macro in non-conforming or C++03
- //!compilers, a move will be performed even if the C++11 standard does not allow it
- //!(e.g. returning a static variable). The user is responsible for using this macro
- //!only to return local objects that met C++11 criteria.
- #define BOOST_MOVE_RET(RET_TYPE, REF)\
- REF
- //
-
- #else //!defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- #include <boost/move/detail/meta_utils.hpp>
-
- namespace boost {
- namespace move_detail {
-
- template <class Ret, class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < ::boost::move_detail::is_lvalue_reference<Ret>::value
- , T&>::type
- move_return(T& x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- template <class Ret, class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < !::boost::move_detail::is_lvalue_reference<Ret>::value
- , Ret && >::type
- move_return(T&& t) BOOST_NOEXCEPT
- {
- return static_cast< Ret&& >(t);
- }
-
- } //namespace move_detail {
- } //namespace boost {
-
- #define BOOST_MOVE_RET(RET_TYPE, REF)\
- boost::move_detail::move_return< RET_TYPE >(REF)
- //
-
- #endif //!defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- //!This macro is used to achieve portable optimal move constructors.
- //!
- //!When implementing the move constructor, in C++03 compilers the moved-from argument must be
- //!cast to the base type before calling `::boost::move()` due to rvalue reference limitations.
- //!
- //!In C++11 compilers the cast from a rvalue reference of a derived type to a rvalue reference of
- //!a base type is implicit.
- #define BOOST_MOVE_BASE(BASE_TYPE, ARG) \
- ::boost::move((BASE_TYPE&)(ARG))
- //
-
- namespace boost {
- namespace move_detail {
-
- template< class T> struct forward_type { typedef T type; };
-
- }}
-
-#endif //BOOST_NO_CXX11_RVALUE_REFERENCES
-
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_CORE_HPP
+////////////////////////////////////////////////////////////////////////////// +// +// (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 +//! This header implements macros to define movable classes and +//! move-aware functions + +#ifndef BOOST_MOVE_CORE_HPP +#define BOOST_MOVE_CORE_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> + +// @cond + +//boost_move_no_copy_constructor_or_assign typedef +//used to detect noncopyable types for other Boost libraries. +#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + #define BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE) \ + private:\ + TYPE(TYPE &);\ + TYPE& operator=(TYPE &);\ + public:\ + typedef int boost_move_no_copy_constructor_or_assign; \ + private:\ + // +#else + #define BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE) \ + public:\ + TYPE(TYPE const &) = delete;\ + TYPE& operator=(TYPE const &) = delete;\ + public:\ + typedef int boost_move_no_copy_constructor_or_assign; \ + private:\ + // +#endif //BOOST_NO_CXX11_DELETED_FUNCTIONS + +// @endcond + +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #include <boost/move/detail/type_traits.hpp> + + #if defined(BOOST_MOVE_ADDRESS_SANITIZER_ON) + #define BOOST_MOVE_TO_RV_CAST(RV_TYPE, ARG) reinterpret_cast<RV_TYPE>(ARG) + #else + #define BOOST_MOVE_TO_RV_CAST(RV_TYPE, ARG) static_cast<RV_TYPE>(ARG) + #endif + + //Move emulation rv breaks standard aliasing rules so add workarounds for some compilers + #if defined(__GNUC__) && (__GNUC__ >= 4) && \ + (\ + defined(BOOST_GCC) || \ + (defined(BOOST_INTEL) && (BOOST_INTEL_CXX_VERSION >= 1300)) \ + ) + #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__)) + #else + #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS + #endif + + namespace boost { + + ////////////////////////////////////////////////////////////////////////////// + // + // struct rv + // + ////////////////////////////////////////////////////////////////////////////// + template <class T> + class rv + : public ::boost::move_detail::if_c + < ::boost::move_detail::is_class<T>::value + , T + , ::boost::move_detail::nat + >::type + { + rv(); + ~rv() throw(); + rv(rv const&); + void operator=(rv const&); + } BOOST_MOVE_ATTRIBUTE_MAY_ALIAS; + + + ////////////////////////////////////////////////////////////////////////////// + // + // is_rv + // + ////////////////////////////////////////////////////////////////////////////// + + namespace move_detail { + + template <class T> + struct is_rv + //Derive from integral constant because some Boost code assummes it has + //a "type" internal typedef + : integral_constant<bool, ::boost::move_detail::is_rv_impl<T>::value > + {}; + + template <class T> + struct is_not_rv + { + static const bool value = !is_rv<T>::value; + }; + + } //namespace move_detail { + + ////////////////////////////////////////////////////////////////////////////// + // + // has_move_emulation_enabled + // + ////////////////////////////////////////////////////////////////////////////// + template<class T> + struct has_move_emulation_enabled + : ::boost::move_detail::has_move_emulation_enabled_impl<T> + {}; + + template<class T> + struct has_move_emulation_disabled + { + static const bool value = !::boost::move_detail::has_move_emulation_enabled_impl<T>::value; + }; + + } //namespace boost { + + #define BOOST_RV_REF(TYPE)\ + ::boost::rv< TYPE >& \ + // + + #define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\ + ::boost::rv< TYPE<ARG1, ARG2> >& \ + // + + #define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\ + ::boost::rv< TYPE<ARG1, ARG2, ARG3> >& \ + // + + #define BOOST_RV_REF_BEG\ + ::boost::rv< \ + // + + #define BOOST_RV_REF_END\ + >& \ + // + + #define BOOST_RV_REF_BEG_IF_CXX11 \ + \ + // + + #define BOOST_RV_REF_END_IF_CXX11 \ + \ + // + + #define BOOST_FWD_REF(TYPE)\ + const TYPE & \ + // + + #define BOOST_COPY_ASSIGN_REF(TYPE)\ + const ::boost::rv< TYPE >& \ + // + + #define BOOST_COPY_ASSIGN_REF_BEG \ + const ::boost::rv< \ + // + + #define BOOST_COPY_ASSIGN_REF_END \ + >& \ + // + + #define BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\ + const ::boost::rv< TYPE<ARG1, ARG2> >& \ + // + + #define BOOST_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\ + const ::boost::rv< TYPE<ARG1, ARG2, ARG3> >& \ + // + + #define BOOST_CATCH_CONST_RLVALUE(TYPE)\ + const ::boost::rv< TYPE >& \ + // + + namespace boost { + namespace move_detail { + + template <class Ret, class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < ::boost::move_detail::is_lvalue_reference<Ret>::value || + !::boost::has_move_emulation_enabled<T>::value + , T&>::type + move_return(T& x) BOOST_NOEXCEPT + { + return x; + } + + template <class Ret, class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_lvalue_reference<Ret>::value && + ::boost::has_move_emulation_enabled<T>::value + , ::boost::rv<T>&>::type + move_return(T& x) BOOST_NOEXCEPT + { + return *BOOST_MOVE_TO_RV_CAST(::boost::rv<T>*, ::boost::move_detail::addressof(x)); + } + + template <class Ret, class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_lvalue_reference<Ret>::value && + ::boost::has_move_emulation_enabled<T>::value + , ::boost::rv<T>&>::type + move_return(::boost::rv<T>& x) BOOST_NOEXCEPT + { + return x; + } + + } //namespace move_detail { + } //namespace boost { + + #define BOOST_MOVE_RET(RET_TYPE, REF)\ + boost::move_detail::move_return< RET_TYPE >(REF) + // + + #define BOOST_MOVE_BASE(BASE_TYPE, ARG) \ + ::boost::move((BASE_TYPE&)(ARG)) + // + + ////////////////////////////////////////////////////////////////////////////// + // + // BOOST_MOVABLE_BUT_NOT_COPYABLE + // + ////////////////////////////////////////////////////////////////////////////// + #define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)\ + BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE)\ + public:\ + BOOST_MOVE_FORCEINLINE operator ::boost::rv<TYPE>&() \ + { return *BOOST_MOVE_TO_RV_CAST(::boost::rv<TYPE>*, this); }\ + BOOST_MOVE_FORCEINLINE operator const ::boost::rv<TYPE>&() const \ + { return *BOOST_MOVE_TO_RV_CAST(const ::boost::rv<TYPE>*, this); }\ + private:\ + // + + ////////////////////////////////////////////////////////////////////////////// + // + // BOOST_COPYABLE_AND_MOVABLE + // + ////////////////////////////////////////////////////////////////////////////// + + #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\ + public:\ + TYPE& operator=(TYPE &t)\ + { this->operator=(const_cast<const TYPE &>(t)); return *this;}\ + public:\ + BOOST_MOVE_FORCEINLINE operator ::boost::rv<TYPE>&() \ + { return *BOOST_MOVE_TO_RV_CAST(::boost::rv<TYPE>*, this); }\ + BOOST_MOVE_FORCEINLINE operator const ::boost::rv<TYPE>&() const \ + { return *BOOST_MOVE_TO_RV_CAST(const ::boost::rv<TYPE>*, this); }\ + private:\ + // + + #define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE)\ + public:\ + BOOST_MOVE_FORCEINLINE operator ::boost::rv<TYPE>&() \ + { return *BOOST_MOVE_TO_RV_CAST(::boost::rv<TYPE>*, this); }\ + BOOST_MOVE_FORCEINLINE operator const ::boost::rv<TYPE>&() const \ + { return *BOOST_MOVE_TO_RV_CAST(const ::boost::rv<TYPE>*, this); }\ + private:\ + // + + namespace boost{ + namespace move_detail{ + + template< class T> + struct forward_type + { typedef const T &type; }; + + template< class T> + struct forward_type< boost::rv<T> > + { typedef T type; }; + + }} + +#else //BOOST_NO_CXX11_RVALUE_REFERENCES + + //! This macro marks a type as movable but not copyable, disabling copy construction + //! and assignment. The user will need to write a move constructor/assignment as explained + //! in the documentation to fully write a movable but not copyable class. + #define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)\ + BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE)\ + public:\ + typedef int boost_move_emulation_t;\ + private:\ + // + + //! This macro marks a type as copyable and movable. + //! The user will need to write a move constructor/assignment and a copy assignment + //! as explained in the documentation to fully write a copyable and movable class. + #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\ + // + + #if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + #define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE)\ + // + #endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + namespace boost { + + //!This trait yields to a compile-time true boolean if T was marked as + //!BOOST_MOVABLE_BUT_NOT_COPYABLE or BOOST_COPYABLE_AND_MOVABLE and + //!rvalue references are not available on the platform. False otherwise. + template<class T> + struct has_move_emulation_enabled + { + static const bool value = false; + }; + + template<class T> + struct has_move_emulation_disabled + { + static const bool value = true; + }; + + } //namespace boost{ + + //!This macro is used to achieve portable syntax in move + //!constructors and assignments for classes marked as + //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE + #define BOOST_RV_REF(TYPE)\ + TYPE && \ + // + + //!This macro is used to achieve portable syntax in move + //!constructors and assignments for template classes marked as + //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE. + //!As macros have problems with comma-separated template arguments, + //!the template argument must be preceded with BOOST_RV_REF_BEG + //!and ended with BOOST_RV_REF_END + #define BOOST_RV_REF_BEG\ + \ + // + + //!This macro is used to achieve portable syntax in move + //!constructors and assignments for template classes marked as + //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE. + //!As macros have problems with comma-separated template arguments, + //!the template argument must be preceded with BOOST_RV_REF_BEG + //!and ended with BOOST_RV_REF_END + #define BOOST_RV_REF_END\ + && \ + // + + //!This macro expands to BOOST_RV_REF_BEG if BOOST_NO_CXX11_RVALUE_REFERENCES + //!is not defined, empty otherwise + #define BOOST_RV_REF_BEG_IF_CXX11 \ + BOOST_RV_REF_BEG \ + // + + //!This macro expands to BOOST_RV_REF_END if BOOST_NO_CXX11_RVALUE_REFERENCES + //!is not defined, empty otherwise + #define BOOST_RV_REF_END_IF_CXX11 \ + BOOST_RV_REF_END \ + // + + //!This macro is used to achieve portable syntax in copy + //!assignment for classes marked as BOOST_COPYABLE_AND_MOVABLE. + #define BOOST_COPY_ASSIGN_REF(TYPE)\ + const TYPE & \ + // + + //! This macro is used to implement portable perfect forwarding + //! as explained in the documentation. + #define BOOST_FWD_REF(TYPE)\ + TYPE && \ + // + + #if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\ + TYPE<ARG1, ARG2> && \ + // + + #define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\ + TYPE<ARG1, ARG2, ARG3> && \ + // + + #define BOOST_COPY_ASSIGN_REF_BEG \ + const \ + // + + #define BOOST_COPY_ASSIGN_REF_END \ + & \ + // + + #define BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\ + const TYPE<ARG1, ARG2> & \ + // + + #define BOOST_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\ + const TYPE<ARG1, ARG2, ARG3>& \ + // + + #define BOOST_CATCH_CONST_RLVALUE(TYPE)\ + const TYPE & \ + // + + #endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #if !defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + + //!This macro is used to achieve portable move return semantics. + //!The C++11 Standard allows implicit move returns when the object to be returned + //!is designated by a lvalue and: + //! - The criteria for elision of a copy operation are met OR + //! - The criteria would be met save for the fact that the source object is a function parameter + //! + //!For C++11 conforming compilers this macros only yields to REF: + //! <code>return BOOST_MOVE_RET(RET_TYPE, REF);</code> -> <code>return REF;</code> + //! + //!For compilers without rvalue references + //!this macro does an explicit move if the move emulation is activated + //!and the return type (RET_TYPE) is not a reference. + //! + //!For non-conforming compilers with rvalue references like Visual 2010 & 2012, + //!an explicit move is performed if RET_TYPE is not a reference. + //! + //! <b>Caution</b>: When using this macro in non-conforming or C++03 + //!compilers, a move will be performed even if the C++11 standard does not allow it + //!(e.g. returning a static variable). The user is responsible for using this macro + //!only to return local objects that met C++11 criteria. + #define BOOST_MOVE_RET(RET_TYPE, REF)\ + REF + // + + #else //!defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #include <boost/move/detail/meta_utils.hpp> + + namespace boost { + namespace move_detail { + + template <class Ret, class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < ::boost::move_detail::is_lvalue_reference<Ret>::value + , T&>::type + move_return(T& x) BOOST_NOEXCEPT + { + return x; + } + + template <class Ret, class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_lvalue_reference<Ret>::value + , Ret && >::type + move_return(T&& t) BOOST_NOEXCEPT + { + return static_cast< Ret&& >(t); + } + + } //namespace move_detail { + } //namespace boost { + + #define BOOST_MOVE_RET(RET_TYPE, REF)\ + boost::move_detail::move_return< RET_TYPE >(REF) + // + + #endif //!defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + + //!This macro is used to achieve portable optimal move constructors. + //! + //!When implementing the move constructor, in C++03 compilers the moved-from argument must be + //!cast to the base type before calling `::boost::move()` due to rvalue reference limitations. + //! + //!In C++11 compilers the cast from a rvalue reference of a derived type to a rvalue reference of + //!a base type is implicit. + #define BOOST_MOVE_BASE(BASE_TYPE, ARG) \ + ::boost::move((BASE_TYPE&)(ARG)) + // + + namespace boost { + namespace move_detail { + + template< class T> struct forward_type { typedef T type; }; + + }} + +#endif //BOOST_NO_CXX11_RVALUE_REFERENCES + +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_CORE_HPP diff --git a/contrib/src/boost/move/default_delete.hpp b/contrib/src/boost/move/default_delete.hpp new file mode 100644 index 0000000..1c26ed9 --- /dev/null +++ b/contrib/src/boost/move/default_delete.hpp @@ -0,0 +1,201 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (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. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_MOVE_DEFAULT_DELETE_HPP_INCLUDED +#define BOOST_MOVE_DEFAULT_DELETE_HPP_INCLUDED + +#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> +#include <boost/move/detail/unique_ptr_meta_utils.hpp> +#include <boost/move/utility_core.hpp> +#include <boost/static_assert.hpp> + +#include <cstddef> //For std::size_t,std::nullptr_t + +//!\file +//! Describes the default deleter (destruction policy) of <tt>unique_ptr</tt>: <tt>default_delete</tt>. + +namespace boost{ +// @cond +namespace move_upd { + +namespace bmupmu = ::boost::move_upmu; + +//////////////////////////////////////// +//// enable_def_del +//////////////////////////////////////// + +//compatible with a pointer type T*: +//When either Y* is convertible to T* +//Y is U[N] and T is U cv [] +template<class U, class T> +struct def_del_compatible_cond + : bmupmu::is_convertible<U*, T*> +{}; + +template<class U, class T, std::size_t N> +struct def_del_compatible_cond<U[N], T[]> + : def_del_compatible_cond<U[], T[]> +{}; + +template<class U, class T, class Type = bmupmu::nat> +struct enable_def_del + : bmupmu::enable_if_c<def_del_compatible_cond<U, T>::value, Type> +{}; + +//////////////////////////////////////// +//// enable_defdel_call +//////////////////////////////////////// + +//When 2nd is T[N], 1st(*)[N] shall be convertible to T(*)[N]; +//When 2nd is T[], 1st(*)[] shall be convertible to T(*)[]; +//Otherwise, 1st* shall be convertible to 2nd*. + +template<class U, class T, class Type = bmupmu::nat> +struct enable_defdel_call + : public enable_def_del<U, T, Type> +{}; + +template<class U, class T, class Type> +struct enable_defdel_call<U, T[], Type> + : public enable_def_del<U[], T[], Type> +{}; + +template<class U, class T, class Type, std::size_t N> +struct enable_defdel_call<U, T[N], Type> + : public enable_def_del<U[N], T[N], Type> +{}; + +//////////////////////////////////////// +//// Some bool literal zero conversion utilities +//////////////////////////////////////// + +struct bool_conversion {int for_bool; int for_arg(); }; +typedef int bool_conversion::* explicit_bool_arg; + +#if !defined(BOOST_NO_CXX11_NULLPTR) && !defined(BOOST_NO_CXX11_DECLTYPE) + typedef decltype(nullptr) nullptr_type; +#elif !defined(BOOST_NO_CXX11_NULLPTR) + typedef std::nullptr_t nullptr_type; +#else + typedef int (bool_conversion::*nullptr_type)(); +#endif + +} //namespace move_upd { +// @endcond + +namespace movelib { + +namespace bmupd = boost::move_upd; +namespace bmupmu = ::boost::move_upmu; + +//!The class template <tt>default_delete</tt> serves as the default deleter +//!(destruction policy) for the class template <tt>unique_ptr</tt>. +//! +//! \tparam T The type to be deleted. It may be an incomplete type +template <class T> +struct default_delete +{ + //! Default constructor. + //! + BOOST_CONSTEXPR default_delete() + //Avoid "defaulted on its first declaration must not have an exception-specification" error for GCC 4.6 + #if !defined(BOOST_GCC) || (BOOST_GCC < 40600 && BOOST_GCC >= 40700) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + BOOST_NOEXCEPT + #endif + #if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + = default; + #else + {}; + #endif + + #if defined(BOOST_MOVE_DOXYGEN_INVOKED) + //! Trivial copy constructor + //! + default_delete(const default_delete&) BOOST_NOEXCEPT = default; + //! Trivial assignment + //! + default_delete &operator=(const default_delete&) BOOST_NOEXCEPT = default; + #else + typedef typename bmupmu::remove_extent<T>::type element_type; + #endif + + //! <b>Effects</b>: Constructs a default_delete object from another <tt>default_delete<U></tt> object. + //! + //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless: + //! - If T is not an array type and U* is implicitly convertible to T*. + //! - If T is an array type and U* is a more CV qualified pointer to remove_extent<T>::type. + template <class U> + default_delete(const default_delete<U>& + BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_def_del<U BOOST_MOVE_I T>::type* =0) + ) BOOST_NOEXCEPT + { + //If T is not an array type, U derives from T + //and T has no virtual destructor, then you have a problem + BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value )); + } + + //! <b>Effects</b>: Constructs a default_delete object from another <tt>default_delete<U></tt> object. + //! + //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless: + //! - If T is not an array type and U* is implicitly convertible to T*. + //! - If T is an array type and U* is a more CV qualified pointer to remove_extent<T>::type. + template <class U> + BOOST_MOVE_DOC1ST(default_delete&, + typename bmupd::enable_def_del<U BOOST_MOVE_I T BOOST_MOVE_I default_delete &>::type) + operator=(const default_delete<U>&) BOOST_NOEXCEPT + { + //If T is not an array type, U derives from T + //and T has no virtual destructor, then you have a problem + BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value )); + return *this; + } + + //! <b>Effects</b>: if T is not an array type, calls <tt>delete</tt> on static_cast<T*>(ptr), + //! otherwise calls <tt>delete[]</tt> on static_cast<remove_extent<T>::type*>(ptr). + //! + //! <b>Remarks</b>: If U is an incomplete type, the program is ill-formed. + //! This operator shall not participate in overload resolution unless: + //! - T is not an array type and U* is convertible to T*, OR + //! - T is an array type, and remove_cv<U>::type is the same type as + //! remove_cv<remove_extent<T>::type>::type and U* is convertible to remove_extent<T>::type*. + template <class U> + BOOST_MOVE_DOC1ST(void, typename bmupd::enable_defdel_call<U BOOST_MOVE_I T BOOST_MOVE_I void>::type) + operator()(U* ptr) const BOOST_NOEXCEPT + { + //U must be a complete type + BOOST_STATIC_ASSERT(sizeof(U) > 0); + //If T is not an array type, U derives from T + //and T has no virtual destructor, then you have a problem + BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value )); + element_type * const p = static_cast<element_type*>(ptr); + bmupmu::is_array<T>::value ? delete [] p : delete p; + } + + //! <b>Effects</b>: Same as <tt>(*this)(static_cast<element_type*>(nullptr))</tt>. + //! + void operator()(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) const BOOST_NOEXCEPT + { BOOST_STATIC_ASSERT(sizeof(element_type) > 0); } +}; + +} //namespace movelib { +} //namespace boost{ + +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_DEFAULT_DELETE_HPP_INCLUDED 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 diff --git a/contrib/src/boost/move/iterator.hpp b/contrib/src/boost/move/iterator.hpp index 5f7d495..f36df23 100644 --- a/contrib/src/boost/move/iterator.hpp +++ b/contrib/src/boost/move/iterator.hpp @@ -1,311 +1,311 @@ -//////////////////////////////////////////////////////////////////////////////
-//
-// (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_ITERATOR_HPP
-#define BOOST_MOVE_ITERATOR_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> //forceinline
-#include <boost/move/detail/iterator_traits.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost {
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// move_iterator
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! Class template move_iterator is an iterator adaptor with the same behavior
-//! as the underlying iterator except that its dereference operator implicitly
-//! converts the value returned by the underlying iterator's dereference operator
-//! to an rvalue reference. Some generic algorithms can be called with move
-//! iterators to replace copying with moving.
-template <class It>
-class move_iterator
-{
- public:
- typedef It iterator_type;
- typedef typename boost::movelib::iterator_traits<iterator_type>::value_type value_type;
- #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
- typedef value_type && reference;
- #else
- typedef typename ::boost::move_detail::if_
- < ::boost::has_move_emulation_enabled<value_type>
- , ::boost::rv<value_type>&
- , value_type & >::type reference;
- #endif
- typedef It pointer;
- typedef typename boost::movelib::iterator_traits<iterator_type>::difference_type difference_type;
- typedef typename boost::movelib::iterator_traits<iterator_type>::iterator_category iterator_category;
-
- BOOST_MOVE_FORCEINLINE move_iterator()
- : m_it()
- {}
-
- BOOST_MOVE_FORCEINLINE explicit move_iterator(const It &i)
- : m_it(i)
- {}
-
- template <class U>
- BOOST_MOVE_FORCEINLINE move_iterator(const move_iterator<U>& u)
- : m_it(u.m_it)
- {}
-
- BOOST_MOVE_FORCEINLINE reference operator*() const
- {
- #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
- return *m_it;
- #else
- return ::boost::move(*m_it);
- #endif
- }
-
- BOOST_MOVE_FORCEINLINE pointer operator->() const
- { return m_it; }
-
- BOOST_MOVE_FORCEINLINE move_iterator& operator++()
- { ++m_it; return *this; }
-
- BOOST_MOVE_FORCEINLINE move_iterator<iterator_type> operator++(int)
- { move_iterator<iterator_type> tmp(*this); ++(*this); return tmp; }
-
- BOOST_MOVE_FORCEINLINE move_iterator& operator--()
- { --m_it; return *this; }
-
- BOOST_MOVE_FORCEINLINE move_iterator<iterator_type> operator--(int)
- { move_iterator<iterator_type> tmp(*this); --(*this); return tmp; }
-
- move_iterator<iterator_type> operator+ (difference_type n) const
- { return move_iterator<iterator_type>(m_it + n); }
-
- BOOST_MOVE_FORCEINLINE move_iterator& operator+=(difference_type n)
- { m_it += n; return *this; }
-
- BOOST_MOVE_FORCEINLINE move_iterator<iterator_type> operator- (difference_type n) const
- { return move_iterator<iterator_type>(m_it - n); }
-
- BOOST_MOVE_FORCEINLINE move_iterator& operator-=(difference_type n)
- { m_it -= n; return *this; }
-
- BOOST_MOVE_FORCEINLINE reference operator[](difference_type n) const
- {
- #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
- return m_it[n];
- #else
- return ::boost::move(m_it[n]);
- #endif
- }
-
- BOOST_MOVE_FORCEINLINE friend bool operator==(const move_iterator& x, const move_iterator& y)
- { return x.m_it == y.m_it; }
-
- BOOST_MOVE_FORCEINLINE friend bool operator!=(const move_iterator& x, const move_iterator& y)
- { return x.m_it != y.m_it; }
-
- BOOST_MOVE_FORCEINLINE friend bool operator< (const move_iterator& x, const move_iterator& y)
- { return x.m_it < y.m_it; }
-
- BOOST_MOVE_FORCEINLINE friend bool operator<=(const move_iterator& x, const move_iterator& y)
- { return x.m_it <= y.m_it; }
-
- BOOST_MOVE_FORCEINLINE friend bool operator> (const move_iterator& x, const move_iterator& y)
- { return x.m_it > y.m_it; }
-
- BOOST_MOVE_FORCEINLINE friend bool operator>=(const move_iterator& x, const move_iterator& y)
- { return x.m_it >= y.m_it; }
-
- BOOST_MOVE_FORCEINLINE friend difference_type operator-(const move_iterator& x, const move_iterator& y)
- { return x.m_it - y.m_it; }
-
- BOOST_MOVE_FORCEINLINE friend move_iterator operator+(difference_type n, const move_iterator& x)
- { return move_iterator(x.m_it + n); }
-
- private:
- It m_it;
-};
-
-//is_move_iterator
-namespace move_detail {
-
-template <class I>
-struct is_move_iterator
-{
- static const bool value = false;
-};
-
-template <class I>
-struct is_move_iterator< ::boost::move_iterator<I> >
-{
- static const bool value = true;
-};
-
-} //namespace move_detail {
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// move_iterator
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//!
-//! <b>Returns</b>: move_iterator<It>(i).
-template<class It>
-inline move_iterator<It> make_move_iterator(const It &it)
-{ return move_iterator<It>(it); }
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// back_move_insert_iterator
-//
-//////////////////////////////////////////////////////////////////////////////
-
-
-//! A move insert iterator that move constructs elements at the
-//! back of a container
-template <typename C> // C models Container
-class back_move_insert_iterator
-{
- C* container_m;
-
- public:
- typedef C container_type;
- typedef typename C::value_type value_type;
- typedef typename C::reference reference;
- typedef typename C::pointer pointer;
- typedef typename C::difference_type difference_type;
- typedef std::output_iterator_tag iterator_category;
-
- explicit back_move_insert_iterator(C& x) : container_m(&x) { }
-
- back_move_insert_iterator& operator=(reference x)
- { container_m->push_back(boost::move(x)); return *this; }
-
- back_move_insert_iterator& operator=(BOOST_RV_REF(value_type) x)
- { reference rx = x; return this->operator=(rx); }
-
- back_move_insert_iterator& operator*() { return *this; }
- back_move_insert_iterator& operator++() { return *this; }
- back_move_insert_iterator& operator++(int) { return *this; }
-};
-
-//!
-//! <b>Returns</b>: back_move_insert_iterator<C>(x).
-template <typename C> // C models Container
-inline back_move_insert_iterator<C> back_move_inserter(C& x)
-{
- return back_move_insert_iterator<C>(x);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// front_move_insert_iterator
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! A move insert iterator that move constructs elements int the
-//! front of a container
-template <typename C> // C models Container
-class front_move_insert_iterator
-{
- C* container_m;
-
-public:
- typedef C container_type;
- typedef typename C::value_type value_type;
- typedef typename C::reference reference;
- typedef typename C::pointer pointer;
- typedef typename C::difference_type difference_type;
- typedef std::output_iterator_tag iterator_category;
-
- explicit front_move_insert_iterator(C& x) : container_m(&x) { }
-
- front_move_insert_iterator& operator=(reference x)
- { container_m->push_front(boost::move(x)); return *this; }
-
- front_move_insert_iterator& operator=(BOOST_RV_REF(value_type) x)
- { reference rx = x; return this->operator=(rx); }
-
- front_move_insert_iterator& operator*() { return *this; }
- front_move_insert_iterator& operator++() { return *this; }
- front_move_insert_iterator& operator++(int) { return *this; }
-};
-
-//!
-//! <b>Returns</b>: front_move_insert_iterator<C>(x).
-template <typename C> // C models Container
-inline front_move_insert_iterator<C> front_move_inserter(C& x)
-{
- return front_move_insert_iterator<C>(x);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// insert_move_iterator
-//
-//////////////////////////////////////////////////////////////////////////////
-template <typename C> // C models Container
-class move_insert_iterator
-{
- C* container_m;
- typename C::iterator pos_;
-
- public:
- typedef C container_type;
- typedef typename C::value_type value_type;
- typedef typename C::reference reference;
- typedef typename C::pointer pointer;
- typedef typename C::difference_type difference_type;
- typedef std::output_iterator_tag iterator_category;
-
- explicit move_insert_iterator(C& x, typename C::iterator pos)
- : container_m(&x), pos_(pos)
- {}
-
- move_insert_iterator& operator=(reference x)
- {
- pos_ = container_m->insert(pos_, ::boost::move(x));
- ++pos_;
- return *this;
- }
-
- move_insert_iterator& operator=(BOOST_RV_REF(value_type) x)
- { reference rx = x; return this->operator=(rx); }
-
- move_insert_iterator& operator*() { return *this; }
- move_insert_iterator& operator++() { return *this; }
- move_insert_iterator& operator++(int) { return *this; }
-};
-
-//!
-//! <b>Returns</b>: move_insert_iterator<C>(x, it).
-template <typename C> // C models Container
-inline move_insert_iterator<C> move_inserter(C& x, typename C::iterator it)
-{
- return move_insert_iterator<C>(x, it);
-}
-
-} //namespace boost {
-
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_ITERATOR_HPP
+////////////////////////////////////////////////////////////////////////////// +// +// (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_ITERATOR_HPP +#define BOOST_MOVE_ITERATOR_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> //forceinline +#include <boost/move/detail/iterator_traits.hpp> +#include <boost/move/utility_core.hpp> + +namespace boost { + +////////////////////////////////////////////////////////////////////////////// +// +// move_iterator +// +////////////////////////////////////////////////////////////////////////////// + +//! Class template move_iterator is an iterator adaptor with the same behavior +//! as the underlying iterator except that its dereference operator implicitly +//! converts the value returned by the underlying iterator's dereference operator +//! to an rvalue reference. Some generic algorithms can be called with move +//! iterators to replace copying with moving. +template <class It> +class move_iterator +{ + public: + typedef It iterator_type; + typedef typename boost::movelib::iterator_traits<iterator_type>::value_type value_type; + #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + typedef value_type && reference; + #else + typedef typename ::boost::move_detail::if_ + < ::boost::has_move_emulation_enabled<value_type> + , ::boost::rv<value_type>& + , value_type & >::type reference; + #endif + typedef It pointer; + typedef typename boost::movelib::iterator_traits<iterator_type>::difference_type difference_type; + typedef typename boost::movelib::iterator_traits<iterator_type>::iterator_category iterator_category; + + BOOST_MOVE_FORCEINLINE move_iterator() + : m_it() + {} + + BOOST_MOVE_FORCEINLINE explicit move_iterator(const It &i) + : m_it(i) + {} + + template <class U> + BOOST_MOVE_FORCEINLINE move_iterator(const move_iterator<U>& u) + : m_it(u.m_it) + {} + + BOOST_MOVE_FORCEINLINE reference operator*() const + { + #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES) + return *m_it; + #else + return ::boost::move(*m_it); + #endif + } + + BOOST_MOVE_FORCEINLINE pointer operator->() const + { return m_it; } + + BOOST_MOVE_FORCEINLINE move_iterator& operator++() + { ++m_it; return *this; } + + BOOST_MOVE_FORCEINLINE move_iterator<iterator_type> operator++(int) + { move_iterator<iterator_type> tmp(*this); ++(*this); return tmp; } + + BOOST_MOVE_FORCEINLINE move_iterator& operator--() + { --m_it; return *this; } + + BOOST_MOVE_FORCEINLINE move_iterator<iterator_type> operator--(int) + { move_iterator<iterator_type> tmp(*this); --(*this); return tmp; } + + move_iterator<iterator_type> operator+ (difference_type n) const + { return move_iterator<iterator_type>(m_it + n); } + + BOOST_MOVE_FORCEINLINE move_iterator& operator+=(difference_type n) + { m_it += n; return *this; } + + BOOST_MOVE_FORCEINLINE move_iterator<iterator_type> operator- (difference_type n) const + { return move_iterator<iterator_type>(m_it - n); } + + BOOST_MOVE_FORCEINLINE move_iterator& operator-=(difference_type n) + { m_it -= n; return *this; } + + BOOST_MOVE_FORCEINLINE reference operator[](difference_type n) const + { + #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES) + return m_it[n]; + #else + return ::boost::move(m_it[n]); + #endif + } + + BOOST_MOVE_FORCEINLINE friend bool operator==(const move_iterator& x, const move_iterator& y) + { return x.m_it == y.m_it; } + + BOOST_MOVE_FORCEINLINE friend bool operator!=(const move_iterator& x, const move_iterator& y) + { return x.m_it != y.m_it; } + + BOOST_MOVE_FORCEINLINE friend bool operator< (const move_iterator& x, const move_iterator& y) + { return x.m_it < y.m_it; } + + BOOST_MOVE_FORCEINLINE friend bool operator<=(const move_iterator& x, const move_iterator& y) + { return x.m_it <= y.m_it; } + + BOOST_MOVE_FORCEINLINE friend bool operator> (const move_iterator& x, const move_iterator& y) + { return x.m_it > y.m_it; } + + BOOST_MOVE_FORCEINLINE friend bool operator>=(const move_iterator& x, const move_iterator& y) + { return x.m_it >= y.m_it; } + + BOOST_MOVE_FORCEINLINE friend difference_type operator-(const move_iterator& x, const move_iterator& y) + { return x.m_it - y.m_it; } + + BOOST_MOVE_FORCEINLINE friend move_iterator operator+(difference_type n, const move_iterator& x) + { return move_iterator(x.m_it + n); } + + private: + It m_it; +}; + +//is_move_iterator +namespace move_detail { + +template <class I> +struct is_move_iterator +{ + static const bool value = false; +}; + +template <class I> +struct is_move_iterator< ::boost::move_iterator<I> > +{ + static const bool value = true; +}; + +} //namespace move_detail { + +////////////////////////////////////////////////////////////////////////////// +// +// move_iterator +// +////////////////////////////////////////////////////////////////////////////// + +//! +//! <b>Returns</b>: move_iterator<It>(i). +template<class It> +inline move_iterator<It> make_move_iterator(const It &it) +{ return move_iterator<It>(it); } + +////////////////////////////////////////////////////////////////////////////// +// +// back_move_insert_iterator +// +////////////////////////////////////////////////////////////////////////////// + + +//! A move insert iterator that move constructs elements at the +//! back of a container +template <typename C> // C models Container +class back_move_insert_iterator +{ + C* container_m; + + public: + typedef C container_type; + typedef typename C::value_type value_type; + typedef typename C::reference reference; + typedef typename C::pointer pointer; + typedef typename C::difference_type difference_type; + typedef std::output_iterator_tag iterator_category; + + explicit back_move_insert_iterator(C& x) : container_m(&x) { } + + back_move_insert_iterator& operator=(reference x) + { container_m->push_back(boost::move(x)); return *this; } + + back_move_insert_iterator& operator=(BOOST_RV_REF(value_type) x) + { reference rx = x; return this->operator=(rx); } + + back_move_insert_iterator& operator*() { return *this; } + back_move_insert_iterator& operator++() { return *this; } + back_move_insert_iterator& operator++(int) { return *this; } +}; + +//! +//! <b>Returns</b>: back_move_insert_iterator<C>(x). +template <typename C> // C models Container +inline back_move_insert_iterator<C> back_move_inserter(C& x) +{ + return back_move_insert_iterator<C>(x); +} + +////////////////////////////////////////////////////////////////////////////// +// +// front_move_insert_iterator +// +////////////////////////////////////////////////////////////////////////////// + +//! A move insert iterator that move constructs elements int the +//! front of a container +template <typename C> // C models Container +class front_move_insert_iterator +{ + C* container_m; + +public: + typedef C container_type; + typedef typename C::value_type value_type; + typedef typename C::reference reference; + typedef typename C::pointer pointer; + typedef typename C::difference_type difference_type; + typedef std::output_iterator_tag iterator_category; + + explicit front_move_insert_iterator(C& x) : container_m(&x) { } + + front_move_insert_iterator& operator=(reference x) + { container_m->push_front(boost::move(x)); return *this; } + + front_move_insert_iterator& operator=(BOOST_RV_REF(value_type) x) + { reference rx = x; return this->operator=(rx); } + + front_move_insert_iterator& operator*() { return *this; } + front_move_insert_iterator& operator++() { return *this; } + front_move_insert_iterator& operator++(int) { return *this; } +}; + +//! +//! <b>Returns</b>: front_move_insert_iterator<C>(x). +template <typename C> // C models Container +inline front_move_insert_iterator<C> front_move_inserter(C& x) +{ + return front_move_insert_iterator<C>(x); +} + +////////////////////////////////////////////////////////////////////////////// +// +// insert_move_iterator +// +////////////////////////////////////////////////////////////////////////////// +template <typename C> // C models Container +class move_insert_iterator +{ + C* container_m; + typename C::iterator pos_; + + public: + typedef C container_type; + typedef typename C::value_type value_type; + typedef typename C::reference reference; + typedef typename C::pointer pointer; + typedef typename C::difference_type difference_type; + typedef std::output_iterator_tag iterator_category; + + explicit move_insert_iterator(C& x, typename C::iterator pos) + : container_m(&x), pos_(pos) + {} + + move_insert_iterator& operator=(reference x) + { + pos_ = container_m->insert(pos_, ::boost::move(x)); + ++pos_; + return *this; + } + + move_insert_iterator& operator=(BOOST_RV_REF(value_type) x) + { reference rx = x; return this->operator=(rx); } + + move_insert_iterator& operator*() { return *this; } + move_insert_iterator& operator++() { return *this; } + move_insert_iterator& operator++(int) { return *this; } +}; + +//! +//! <b>Returns</b>: move_insert_iterator<C>(x, it). +template <typename C> // C models Container +inline move_insert_iterator<C> move_inserter(C& x, typename C::iterator it) +{ + return move_insert_iterator<C>(x, it); +} + +} //namespace boost { + +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_ITERATOR_HPP diff --git a/contrib/src/boost/move/make_unique.hpp b/contrib/src/boost/move/make_unique.hpp new file mode 100644 index 0000000..bb59ab6 --- /dev/null +++ b/contrib/src/boost/move/make_unique.hpp @@ -0,0 +1,237 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2006-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. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_MOVE_MAKE_UNIQUE_HPP_INCLUDED +#define BOOST_MOVE_MAKE_UNIQUE_HPP_INCLUDED + +#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> +#include <boost/move/utility_core.hpp> +#include <boost/move/unique_ptr.hpp> +#include <cstddef> //for std::size_t +#include <boost/move/detail/unique_ptr_meta_utils.hpp> +#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES +# include <boost/move/detail/fwd_macros.hpp> +#endif + +//!\file +//! Defines "make_unique" functions, which are factories to create instances +//! of unique_ptr depending on the passed arguments. +//! +//! This header can be a bit heavyweight in C++03 compilers due to the use of the +//! preprocessor library, that's why it's a a separate header from <tt>unique_ptr.hpp</tt> + +#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + +namespace std { //no namespace versioning in clang+libc++ + +struct nothrow_t; + +} //namespace std { + +namespace boost{ +namespace move_upmu { + +//Compile time switch between +//single element, unknown bound array +//and known bound array +template<class T> +struct unique_ptr_if +{ + typedef ::boost::movelib::unique_ptr<T> t_is_not_array; +}; + +template<class T> +struct unique_ptr_if<T[]> +{ + typedef ::boost::movelib::unique_ptr<T[]> t_is_array_of_unknown_bound; +}; + +template<class T, std::size_t N> +struct unique_ptr_if<T[N]> +{ + typedef void t_is_array_of_known_bound; +}; + +template <int Dummy = 0> +struct nothrow_holder +{ + static std::nothrow_t *pnothrow; +}; + +template <int Dummy> +std::nothrow_t *nothrow_holder<Dummy>::pnothrow; + +} //namespace move_upmu { +} //namespace boost{ + +#endif //!defined(BOOST_MOVE_DOXYGEN_INVOKED) + +namespace boost{ +namespace movelib { + +#if defined(BOOST_MOVE_DOXYGEN_INVOKED) || !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is not an array. +//! +//! <b>Returns</b>: <tt>unique_ptr<T>(new T(std::forward<Args>(args)...))</tt>. +template<class T, class... Args> +inline BOOST_MOVE_DOC1ST(unique_ptr<T>, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array) + make_unique(BOOST_FWD_REF(Args)... args) +{ return unique_ptr<T>(new T(::boost::forward<Args>(args)...)); } + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is not an array. +//! +//! <b>Returns</b>: <tt>unique_ptr<T>(new T(std::nothrow)(std::forward<Args>(args)...))</tt>. +template<class T, class... Args> +inline BOOST_MOVE_DOC1ST(unique_ptr<T>, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array) + make_unique_nothrow(BOOST_FWD_REF(Args)... args) +{ return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow)T(::boost::forward<Args>(args)...)); } + +#else + #define BOOST_MOVE_MAKE_UNIQUE_CODE(N)\ + template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\ + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array\ + make_unique( BOOST_MOVE_UREF##N)\ + { return unique_ptr<T>( new T( BOOST_MOVE_FWD##N ) ); }\ + \ + template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\ + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array\ + make_unique_nothrow( BOOST_MOVE_UREF##N)\ + { return unique_ptr<T>( new (*boost::move_upmu::nothrow_holder<>::pnothrow)T ( BOOST_MOVE_FWD##N ) ); }\ + // + BOOST_MOVE_ITERATE_0TO9(BOOST_MOVE_MAKE_UNIQUE_CODE) + #undef BOOST_MOVE_MAKE_UNIQUE_CODE + +#endif + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is not an array. +//! +//! <b>Returns</b>: <tt>unique_ptr<T>(new T)</tt> (default initialization) +template<class T> +inline BOOST_MOVE_DOC1ST(unique_ptr<T>, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array) + make_unique_definit() +{ + return unique_ptr<T>(new T); +} + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is not an array. +//! +//! <b>Returns</b>: <tt>unique_ptr<T>(new T(std::nothrow)</tt> (default initialization) +template<class T> +inline BOOST_MOVE_DOC1ST(unique_ptr<T>, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array) + make_unique_nothrow_definit() +{ + return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow)T); +} + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is an array of +//! unknown bound. +//! +//! <b>Returns</b>: <tt>unique_ptr<T>(new remove_extent_t<T>[n]())</tt> (value initialization) +template<class T> +inline BOOST_MOVE_DOC1ST(unique_ptr<T>, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound) + make_unique(std::size_t n) +{ + typedef typename ::boost::move_upmu::remove_extent<T>::type U; + return unique_ptr<T>(new U[n]()); +} + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is an array of +//! unknown bound. +//! +//! <b>Returns</b>: <tt>unique_ptr<T>(new (std::nothrow)remove_extent_t<T>[n]())</tt> (value initialization) +template<class T> +inline BOOST_MOVE_DOC1ST(unique_ptr<T>, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound) + make_unique_nothrow(std::size_t n) +{ + typedef typename ::boost::move_upmu::remove_extent<T>::type U; + return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow)U[n]()); +} + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is an array of +//! unknown bound. +//! +//! <b>Returns</b>: <tt>unique_ptr<T>(new remove_extent_t<T>[n])</tt> (default initialization) +template<class T> +inline BOOST_MOVE_DOC1ST(unique_ptr<T>, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound) + make_unique_definit(std::size_t n) +{ + typedef typename ::boost::move_upmu::remove_extent<T>::type U; + return unique_ptr<T>(new U[n]); +} + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is an array of +//! unknown bound. +//! +//! <b>Returns</b>: <tt>unique_ptr<T>(new (std::nothrow)remove_extent_t<T>[n])</tt> (default initialization) +template<class T> +inline BOOST_MOVE_DOC1ST(unique_ptr<T>, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound) + make_unique_nothrow_definit(std::size_t n) +{ + typedef typename ::boost::move_upmu::remove_extent<T>::type U; + return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow) U[n]); +} + +#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is +//! an array of known bound. +template<class T, class... Args> +inline BOOST_MOVE_DOC1ST(unspecified, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound) + make_unique(BOOST_FWD_REF(Args) ...) = delete; + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is +//! an array of known bound. +template<class T, class... Args> +inline BOOST_MOVE_DOC1ST(unspecified, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound) + make_unique_definit(BOOST_FWD_REF(Args) ...) = delete; + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is +//! an array of known bound. +template<class T, class... Args> +inline BOOST_MOVE_DOC1ST(unspecified, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound) + make_unique_nothrow(BOOST_FWD_REF(Args) ...) = delete; + +//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is +//! an array of known bound. +template<class T, class... Args> +inline BOOST_MOVE_DOC1ST(unspecified, + typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound) + make_unique_nothrow_definit(BOOST_FWD_REF(Args) ...) = delete; + +#endif + +} //namespace movelib { + +} //namespace boost{ + +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_MAKE_UNIQUE_HPP_INCLUDED diff --git a/contrib/src/boost/move/move.hpp b/contrib/src/boost/move/move.hpp index c93347e..62dddbc 100644 --- a/contrib/src/boost/move/move.hpp +++ b/contrib/src/boost/move/move.hpp @@ -1,35 +1,35 @@ -//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright David Abrahams, Vicente Botet 2009.
-// (C) Copyright Ion Gaztanaga 2009-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
-//! A general library header that includes
-//! the rest of top-level headers.
-
-#ifndef BOOST_MOVE_MOVE_HPP
-#define BOOST_MOVE_MOVE_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/utility.hpp>
-#include <boost/move/iterator.hpp>
-#include <boost/move/traits.hpp>
-#include <boost/move/algorithm.hpp>
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_MOVE_HPP
+////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright David Abrahams, Vicente Botet 2009. +// (C) Copyright Ion Gaztanaga 2009-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 +//! A general library header that includes +//! the rest of top-level headers. + +#ifndef BOOST_MOVE_MOVE_HPP +#define BOOST_MOVE_MOVE_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/utility.hpp> +#include <boost/move/iterator.hpp> +#include <boost/move/traits.hpp> +#include <boost/move/algorithm.hpp> +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_MOVE_HPP diff --git a/contrib/src/boost/move/traits.hpp b/contrib/src/boost/move/traits.hpp index c16fdcc..b48b8f6 100644 --- a/contrib/src/boost/move/traits.hpp +++ b/contrib/src/boost/move/traits.hpp @@ -1,77 +1,77 @@ -//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2009-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_TRAITS_HPP
-#define BOOST_MOVE_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>
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-#include <boost/move/core.hpp>
-#endif
-#include <boost/move/detail/meta_utils.hpp>
-#include <boost/move/detail/type_traits.hpp>
-
-namespace boost {
-
-//! If this trait yields to true
-//! (<i>has_trivial_destructor_after_move <T>::value == true</i>)
-//! means that if T is used as argument of a move construction/assignment,
-//! there is no need to call T's destructor.
-//! This optimization tipically is used to improve containers' performance.
-//!
-//! By default this trait is true if the type has trivial destructor,
-//! every class should specialize this trait if it wants to improve performance
-//! when inserted in containers.
-template <class T>
-struct has_trivial_destructor_after_move
- : ::boost::move_detail::is_trivially_destructible<T>
-{};
-
-//! By default this traits returns
-//! <pre>boost::is_nothrow_move_constructible<T>::value && boost::is_nothrow_move_assignable<T>::value </pre>.
-//! Classes with non-throwing move constructor
-//! and assignment can specialize this trait to obtain some performance improvements.
-template <class T>
-struct has_nothrow_move
-{
- static const bool value = boost::move_detail::is_nothrow_move_constructible<T>::value &&
- boost::move_detail::is_nothrow_move_assignable<T>::value;
-};
-
-namespace move_detail {
-
-template <class T>
-struct is_nothrow_move_constructible_or_uncopyable
-{
- //The standard requires is_nothrow_move_constructible for move_if_noexcept
- //but a user (usually in C++03) might specialize has_nothrow_move which includes it
- static const bool value = is_nothrow_move_constructible<T>::value ||
- has_nothrow_move<T>::value ||
- !is_copy_constructible<T>::value;
-};
-
-} //move_detail {
-} //namespace boost {
-
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_TRAITS_HPP
+////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2009-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_TRAITS_HPP +#define BOOST_MOVE_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> + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +#include <boost/move/core.hpp> +#endif +#include <boost/move/detail/meta_utils.hpp> +#include <boost/move/detail/type_traits.hpp> + +namespace boost { + +//! If this trait yields to true +//! (<i>has_trivial_destructor_after_move <T>::value == true</i>) +//! means that if T is used as argument of a move construction/assignment, +//! there is no need to call T's destructor. +//! This optimization tipically is used to improve containers' performance. +//! +//! By default this trait is true if the type has trivial destructor, +//! every class should specialize this trait if it wants to improve performance +//! when inserted in containers. +template <class T> +struct has_trivial_destructor_after_move + : ::boost::move_detail::is_trivially_destructible<T> +{}; + +//! By default this traits returns +//! <pre>boost::is_nothrow_move_constructible<T>::value && boost::is_nothrow_move_assignable<T>::value </pre>. +//! Classes with non-throwing move constructor +//! and assignment can specialize this trait to obtain some performance improvements. +template <class T> +struct has_nothrow_move +{ + static const bool value = boost::move_detail::is_nothrow_move_constructible<T>::value && + boost::move_detail::is_nothrow_move_assignable<T>::value; +}; + +namespace move_detail { + +template <class T> +struct is_nothrow_move_constructible_or_uncopyable +{ + //The standard requires is_nothrow_move_constructible for move_if_noexcept + //but a user (usually in C++03) might specialize has_nothrow_move which includes it + static const bool value = is_nothrow_move_constructible<T>::value || + has_nothrow_move<T>::value || + !is_copy_constructible<T>::value; +}; + +} //move_detail { +} //namespace boost { + +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_TRAITS_HPP diff --git a/contrib/src/boost/move/unique_ptr.hpp b/contrib/src/boost/move/unique_ptr.hpp new file mode 100644 index 0000000..2d794e8 --- /dev/null +++ b/contrib/src/boost/move/unique_ptr.hpp @@ -0,0 +1,871 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (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. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_MOVE_UNIQUE_PTR_HPP_INCLUDED +#define BOOST_MOVE_UNIQUE_PTR_HPP_INCLUDED + +#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> //forceinline +#include <boost/move/detail/unique_ptr_meta_utils.hpp> +#include <boost/move/default_delete.hpp> +#include <boost/move/utility_core.hpp> +#include <boost/move/adl_move_swap.hpp> +#include <boost/static_assert.hpp> +#include <boost/assert.hpp> + +#include <cstddef> //For std::nullptr_t and std::size_t + +//!\file +//! Describes the smart pointer unique_ptr, a drop-in replacement for std::unique_ptr, +//! usable also from C++03 compilers. +//! +//! Main differences from std::unique_ptr to avoid heavy dependencies, +//! specially in C++03 compilers: +//! - <tt>operator < </tt> uses pointer <tt>operator < </tt>instead of <tt>std::less<common_type></tt>. +//! This avoids dependencies on <tt>std::common_type</tt> and <tt>std::less</tt> +//! (<tt><type_traits>/<functional></tt> headers). In C++03 this avoid pulling Boost.Typeof and other +//! cascading dependencies. As in all Boost platforms <tt>operator <</tt> on raw pointers and +//! other smart pointers provides strict weak ordering in practice this should not be a problem for users. +//! - assignable from literal 0 for compilers without nullptr +//! - <tt>unique_ptr<T[]></tt> is constructible and assignable from <tt>unique_ptr<U[]></tt> if +//! cv-less T and cv-less U are the same type and T is more CV qualified than U. + +namespace boost{ +// @cond +namespace move_upd { + +//////////////////////////////////////////// +// deleter types +//////////////////////////////////////////// +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +template <class T> +class is_noncopyable +{ + typedef char true_t; + class false_t { char dummy[2]; }; + template<class U> static false_t dispatch(...); + template<class U> static true_t dispatch(typename U::boost_move_no_copy_constructor_or_assign*); + public: + static const bool value = sizeof(dispatch<T>(0)) == sizeof(true_t); +}; +#endif //defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + +template <class D> +struct deleter_types +{ + typedef typename bmupmu::add_lvalue_reference<D>::type del_ref; + typedef typename bmupmu::add_const_lvalue_reference<D>::type del_cref; + #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + typedef typename bmupmu::if_c + < bmupmu::is_lvalue_reference<D>::value, D, del_cref >::type deleter_arg_type1; + typedef typename bmupmu::remove_reference<D>::type && deleter_arg_type2; + #else + typedef typename bmupmu::if_c + < is_noncopyable<D>::value, bmupmu::nat, del_cref>::type non_ref_deleter_arg1; + typedef typename bmupmu::if_c< bmupmu::is_lvalue_reference<D>::value + , D, non_ref_deleter_arg1 >::type deleter_arg_type1; + typedef ::boost::rv<D> & deleter_arg_type2; + #endif +}; + +//////////////////////////////////////////// +// unique_ptr_data +//////////////////////////////////////////// +template <class P, class D, bool = bmupmu::is_unary_function<D>::value || bmupmu::is_reference<D>::value > +struct unique_ptr_data +{ + typedef typename deleter_types<D>::deleter_arg_type1 deleter_arg_type1; + typedef typename deleter_types<D>::del_ref del_ref; + typedef typename deleter_types<D>::del_cref del_cref; + + BOOST_MOVE_FORCEINLINE unique_ptr_data() BOOST_NOEXCEPT + : m_p(), d() + {} + + BOOST_MOVE_FORCEINLINE explicit unique_ptr_data(P p) BOOST_NOEXCEPT + : m_p(p), d() + {} + + BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, deleter_arg_type1 d1) BOOST_NOEXCEPT + : m_p(p), d(d1) + {} + + template <class U> + BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, BOOST_FWD_REF(U) d1) BOOST_NOEXCEPT + : m_p(p), d(::boost::forward<U>(d1)) + {} + + BOOST_MOVE_FORCEINLINE del_ref deleter() { return d; } + BOOST_MOVE_FORCEINLINE del_cref deleter() const{ return d; } + + P m_p; + D d; + + private: + unique_ptr_data& operator=(const unique_ptr_data&); + unique_ptr_data(const unique_ptr_data&); +}; + +template <class P, class D> +struct unique_ptr_data<P, D, false> + : private D +{ + typedef typename deleter_types<D>::deleter_arg_type1 deleter_arg_type1; + typedef typename deleter_types<D>::del_ref del_ref; + typedef typename deleter_types<D>::del_cref del_cref; + + BOOST_MOVE_FORCEINLINE unique_ptr_data() BOOST_NOEXCEPT + : D(), m_p() + {} + + BOOST_MOVE_FORCEINLINE explicit unique_ptr_data(P p) BOOST_NOEXCEPT + : D(), m_p(p) + {} + + BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, deleter_arg_type1 d1) BOOST_NOEXCEPT + : D(d1), m_p(p) + {} + + template <class U> + BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, BOOST_FWD_REF(U) d) BOOST_NOEXCEPT + : D(::boost::forward<U>(d)), m_p(p) + {} + + BOOST_MOVE_FORCEINLINE del_ref deleter() BOOST_NOEXCEPT { return static_cast<del_ref>(*this); } + BOOST_MOVE_FORCEINLINE del_cref deleter() const BOOST_NOEXCEPT { return static_cast<del_cref>(*this); } + + P m_p; + + private: + unique_ptr_data& operator=(const unique_ptr_data&); + unique_ptr_data(const unique_ptr_data&); +}; + +//////////////////////////////////////////// +// is_unique_ptr_convertible +//////////////////////////////////////////// + +//Although non-standard, we avoid using pointer_traits +//to avoid heavy dependencies +template <typename T> +struct get_element_type +{ + struct DefaultWrap { typedef bmupmu::natify<T> element_type; }; + template <typename X> static char test(int, typename X::element_type*); + template <typename X> static int test(...); + static const bool value = (1 == sizeof(test<T>(0, 0))); + typedef typename bmupmu::if_c<value, T, DefaultWrap>::type::element_type type; +}; + +template<class T> +struct get_element_type<T*> +{ + typedef T type; +}; + +template<class T> +struct get_cvelement + : bmupmu::remove_cv<typename get_element_type<T>::type> +{}; + +template <class P1, class P2> +struct is_same_cvelement_and_convertible +{ + typedef typename bmupmu::remove_reference<P1>::type arg1; + typedef typename bmupmu::remove_reference<P2>::type arg2; + static const bool same_cvless = + bmupmu::is_same<typename get_cvelement<arg1>::type,typename get_cvelement<arg2>::type>::value; + static const bool value = same_cvless && bmupmu::is_convertible<arg1, arg2>::value; +}; + +template<bool IsArray, class FromPointer, class ThisPointer> +struct is_unique_ptr_convertible + : is_same_cvelement_and_convertible<FromPointer, ThisPointer> +{}; + +template<class FromPointer, class ThisPointer> +struct is_unique_ptr_convertible<false, FromPointer, ThisPointer> + : bmupmu::is_convertible<FromPointer, ThisPointer> +{}; + +//////////////////////////////////////// +//// enable_up_moveconv_assign +//////////////////////////////////////// + +template<class T, class FromPointer, class ThisPointer, class Type = bmupmu::nat> +struct enable_up_ptr + : bmupmu::enable_if_c< is_unique_ptr_convertible + < bmupmu::is_array<T>::value, FromPointer, ThisPointer>::value, Type> +{}; + +//////////////////////////////////////// +//// enable_up_moveconv_assign +//////////////////////////////////////// + +template<class T, class D, class U, class E> +struct unique_moveconvert_assignable +{ + static const bool t_is_array = bmupmu::is_array<T>::value; + static const bool value = + t_is_array == bmupmu::is_array<U>::value && + bmupmu::extent<T>::value == bmupmu::extent<U>::value && + is_unique_ptr_convertible + < t_is_array + , typename bmupmu::pointer_type<U, E>::type, typename bmupmu::pointer_type<T, D>::type + >::value; +}; + +template<class T, class D, class U, class E, std::size_t N> +struct unique_moveconvert_assignable<T[], D, U[N], E> + : unique_moveconvert_assignable<T[], D, U[], E> +{}; + +template<class T, class D, class U, class E, class Type = bmupmu::nat> +struct enable_up_moveconv_assign + : bmupmu::enable_if_c<unique_moveconvert_assignable<T, D, U, E>::value, Type> +{}; + +//////////////////////////////////////// +//// enable_up_moveconv_constr +//////////////////////////////////////// + +template<class D, class E, bool IsReference = bmupmu::is_reference<D>::value> +struct unique_deleter_is_initializable + : bmupmu::is_same<D, E> +{}; + +template <class T, class U> +class is_rvalue_convertible +{ + #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + typedef typename bmupmu::remove_reference<T>::type&& t_from; + #else + typedef typename bmupmu::if_c + < ::boost::has_move_emulation_enabled<T>::value && !bmupmu::is_reference<T>::value + , ::boost::rv<T>& + , typename bmupmu::add_lvalue_reference<T>::type + >::type t_from; + #endif + + typedef char true_t; + class false_t { char dummy[2]; }; + static false_t dispatch(...); + static true_t dispatch(U); + static t_from trigger(); + public: + static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t); +}; + +template<class D, class E> +struct unique_deleter_is_initializable<D, E, false> +{ + #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + //Clang has some problems with is_rvalue_convertible with non-copyable types + //so use intrinsic if available + #if defined(BOOST_CLANG) + #if __has_feature(is_convertible_to) + static const bool value = __is_convertible_to(E, D); + #else + static const bool value = is_rvalue_convertible<E, D>::value; + #endif + #else + static const bool value = is_rvalue_convertible<E, D>::value; + #endif + + #else //!defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + //No hope for compilers with move emulation for now. In several compilers is_convertible + // leads to errors, so just move the Deleter and see if the conversion works + static const bool value = true; /*is_rvalue_convertible<E, D>::value*/ + #endif +}; + +template<class T, class D, class U, class E, class Type = bmupmu::nat> +struct enable_up_moveconv_constr + : bmupmu::enable_if_c + < unique_moveconvert_assignable<T, D, U, E>::value && unique_deleter_is_initializable<D, E>::value + , Type> +{}; + +} //namespace move_upd { +// @endcond + +namespace movelib { + +//! A unique pointer is an object that owns another object and +//! manages that other object through a pointer. +//! +//! More precisely, a unique pointer is an object u that stores a pointer to a second object p and will dispose +//! of p when u is itself destroyed (e.g., when leaving block scope). In this context, u is said to own p. +//! +//! The mechanism by which u disposes of p is known as p's associated deleter, a function object whose correct +//! invocation results in p's appropriate disposition (typically its deletion). +//! +//! Let the notation u.p denote the pointer stored by u, and let u.d denote the associated deleter. Upon request, +//! u can reset (replace) u.p and u.d with another pointer and deleter, but must properly dispose of its owned +//! object via the associated deleter before such replacement is considered completed. +//! +//! Additionally, u can, upon request, transfer ownership to another unique pointer u2. Upon completion of +//! such a transfer, the following postconditions hold: +//! - u2.p is equal to the pre-transfer u.p, +//! - u.p is equal to nullptr, and +//! - if the pre-transfer u.d maintained state, such state has been transferred to u2.d. +//! +//! As in the case of a reset, u2 must properly dispose of its pre-transfer owned object via the pre-transfer +//! associated deleter before the ownership transfer is considered complete. +//! +//! Each object of a type U instantiated from the unique_ptr template specified in this subclause has the strict +//! ownership semantics, specified above, of a unique pointer. In partial satisfaction of these semantics, each +//! such U is MoveConstructible and MoveAssignable, but is not CopyConstructible nor CopyAssignable. +//! The template parameter T of unique_ptr may be an incomplete type. +//! +//! The uses of unique_ptr include providing exception safety for dynamically allocated memory, passing +//! ownership of dynamically allocated memory to a function, and returning dynamically allocated memory from +//! a function. +//! +//! If T is an array type (e.g. unique_ptr<MyType[]>) the interface is slightly altered: +//! - Pointers to types derived from T are rejected by the constructors, and by reset. +//! - The observers <tt>operator*</tt> and <tt>operator-></tt> are not provided. +//! - The indexing observer <tt>operator[]</tt> is provided. +//! +//! \tparam T Provides the type of the stored pointer. +//! \tparam D The deleter type: +//! - The default type for the template parameter D is default_delete. A client-supplied template argument +//! D shall be a function object type, lvalue-reference to function, or lvalue-reference to function object type +//! for which, given a value d of type D and a value ptr of type unique_ptr<T, D>::pointer, the expression +//! d(ptr) is valid and has the effect of disposing of the pointer as appropriate for that deleter. +//! - If the deleter's type D is not a reference type, D shall satisfy the requirements of Destructible. +//! - If the type <tt>remove_reference<D>::type::pointer</tt> exists, it shall satisfy the requirements of NullablePointer. +template <class T, class D = default_delete<T> > +class unique_ptr +{ + #if defined(BOOST_MOVE_DOXYGEN_INVOKED) + public: + unique_ptr(const unique_ptr&) = delete; + unique_ptr& operator=(const unique_ptr&) = delete; + private: + #else + BOOST_MOVABLE_BUT_NOT_COPYABLE(unique_ptr) + + typedef bmupmu::pointer_type<T, D > pointer_type_obtainer; + typedef bmupd::unique_ptr_data + <typename pointer_type_obtainer::type, D> data_type; + typedef typename bmupd::deleter_types<D>::deleter_arg_type1 deleter_arg_type1; + typedef typename bmupd::deleter_types<D>::deleter_arg_type2 deleter_arg_type2; + data_type m_data; + #endif + + public: + //! If the type <tt>remove_reference<D>::type::pointer</tt> exists, then it shall be a + //! synonym for <tt>remove_reference<D>::type::pointer</tt>. Otherwise it shall be a + //! synonym for T*. + typedef typename BOOST_MOVE_SEEDOC(pointer_type_obtainer::type) pointer; + //! If T is an array type, then element_type is equal to T. Otherwise, if T is a type + //! in the form U[], element_type is equal to U. + typedef typename BOOST_MOVE_SEEDOC(bmupmu::remove_extent<T>::type) element_type; + typedef D deleter_type; + + //! <b>Requires</b>: D shall satisfy the requirements of DefaultConstructible, and + //! that construction shall not throw an exception. + //! + //! <b>Effects</b>: Constructs a unique_ptr object that owns nothing, value-initializing the + //! stored pointer and the stored deleter. + //! + //! <b>Postconditions</b>: <tt>get() == nullptr</tt>. <tt>get_deleter()</tt> returns a reference to the stored deleter. + //! + //! <b>Remarks</b>: If this constructor is instantiated with a pointer type or reference type + //! for the template argument D, the program is ill-formed. + BOOST_MOVE_FORCEINLINE BOOST_CONSTEXPR unique_ptr() BOOST_NOEXCEPT + : m_data() + { + //If this constructor is instantiated with a pointer type or reference type + //for the template argument D, the program is ill-formed. + BOOST_STATIC_ASSERT(!bmupmu::is_pointer<D>::value); + BOOST_STATIC_ASSERT(!bmupmu::is_reference<D>::value); + } + + //! <b>Effects</b>: Same as <tt>unique_ptr()</tt> (default constructor). + //! + BOOST_MOVE_FORCEINLINE BOOST_CONSTEXPR unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT + : m_data() + { + //If this constructor is instantiated with a pointer type or reference type + //for the template argument D, the program is ill-formed. + BOOST_STATIC_ASSERT(!bmupmu::is_pointer<D>::value); + BOOST_STATIC_ASSERT(!bmupmu::is_reference<D>::value); + } + + //! <b>Requires</b>: D shall satisfy the requirements of DefaultConstructible, and + //! that construction shall not throw an exception. + //! + //! <b>Effects</b>: Constructs a unique_ptr which owns p, initializing the stored pointer + //! with p and value initializing the stored deleter. + //! + //! <b>Postconditions</b>: <tt>get() == p</tt>. <tt>get_deleter()</tt> returns a reference to the stored deleter. + //! + //! <b>Remarks</b>: If this constructor is instantiated with a pointer type or reference type + //! for the template argument D, the program is ill-formed. + //! This constructor shall not participate in overload resolution unless: + //! - If T is not an array type and Pointer is implicitly convertible to pointer. + //! - If T is an array type and Pointer is a more CV qualified pointer to element_type. + template<class Pointer> + BOOST_MOVE_FORCEINLINE explicit unique_ptr(Pointer p + BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0) + ) BOOST_NOEXCEPT + : m_data(p) + { + //If T is not an array type, element_type_t<Pointer> derives from T + //it uses the default deleter and T has no virtual destructor, then you have a problem + BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor + <D, typename bmupd::get_element_type<Pointer>::type>::value )); + //If this constructor is instantiated with a pointer type or reference type + //for the template argument D, the program is ill-formed. + BOOST_STATIC_ASSERT(!bmupmu::is_pointer<D>::value); + BOOST_STATIC_ASSERT(!bmupmu::is_reference<D>::value); + } + + //!The signature of this constructor depends upon whether D is a reference type. + //! - If D is non-reference type A, then the signature is <tt>unique_ptr(pointer p, const A& d)</tt>. + //! - If D is an lvalue-reference type A&, then the signature is <tt>unique_ptr(pointer p, A& d)</tt>. + //! - If D is an lvalue-reference type const A&, then the signature is <tt>unique_ptr(pointer p, const A& d)</tt>. + //! + //! + //! <b>Requires</b>: Either + //! - D is not an lvalue-reference type and d is an lvalue or const rvalue. + //! D shall satisfy the requirements of CopyConstructible, and the copy constructor of D + //! shall not throw an exception. This unique_ptr will hold a copy of d. + //! - D is an lvalue-reference type and d is an lvalue. the type which D references need not be CopyConstructible nor + //! MoveConstructible. This unique_ptr will hold a D which refers to the lvalue d. + //! + //! <b>Effects</b>: Constructs a unique_ptr object which owns p, initializing the stored pointer with p and + //! initializing the deleter as described above. + //! + //! <b>Postconditions</b>: <tt>get() == p</tt>. <tt>get_deleter()</tt> returns a reference to the stored deleter. If D is a + //! reference type then <tt>get_deleter()</tt> returns a reference to the lvalue d. + //! + //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless: + //! - If T is not an array type and Pointer is implicitly convertible to pointer. + //! - If T is an array type and Pointer is a more CV qualified pointer to element_type. + template<class Pointer> + BOOST_MOVE_FORCEINLINE unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type1) d1 + BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0) + ) BOOST_NOEXCEPT + : m_data(p, d1) + { + //If T is not an array type, element_type_t<Pointer> derives from T + //it uses the default deleter and T has no virtual destructor, then you have a problem + BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor + <D, typename bmupd::get_element_type<Pointer>::type>::value )); + } + + //! <b>Effects</b>: Same effects as <tt>template<class Pointer> unique_ptr(Pointer p, deleter_arg_type1 d1)</tt> + //! and additionally <tt>get() == nullptr</tt> + BOOST_MOVE_FORCEINLINE unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type1) d1) BOOST_NOEXCEPT + : m_data(pointer(), d1) + {} + + //! The signature of this constructor depends upon whether D is a reference type. + //! - If D is non-reference type A, then the signature is <tt>unique_ptr(pointer p, A&& d)</tt>. + //! - If D is an lvalue-reference type A&, then the signature is <tt>unique_ptr(pointer p, A&& d)</tt>. + //! - If D is an lvalue-reference type const A&, then the signature is <tt>unique_ptr(pointer p, const A&& d)</tt>. + //! + //! <b>Requires</b>: Either + //! - D is not an lvalue-reference type and d is a non-const rvalue. D + //! shall satisfy the requirements of MoveConstructible, and the move constructor + //! of D shall not throw an exception. This unique_ptr will hold a value move constructed from d. + //! - D is an lvalue-reference type and d is an rvalue, the program is ill-formed. + //! + //! <b>Effects</b>: Constructs a unique_ptr object which owns p, initializing the stored pointer with p and + //! initializing the deleter as described above. + //! + //! <b>Postconditions</b>: <tt>get() == p</tt>. <tt>get_deleter()</tt> returns a reference to the stored deleter. If D is a + //! reference type then <tt>get_deleter()</tt> returns a reference to the lvalue d. + //! + //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless: + //! - If T is not an array type and Pointer is implicitly convertible to pointer. + //! - If T is an array type and Pointer is a more CV qualified pointer to element_type. + template<class Pointer> + BOOST_MOVE_FORCEINLINE unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type2) d2 + BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0) + ) BOOST_NOEXCEPT + : m_data(p, ::boost::move(d2)) + { + //If T is not an array type, element_type_t<Pointer> derives from T + //it uses the default deleter and T has no virtual destructor, then you have a problem + BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor + <D, typename bmupd::get_element_type<Pointer>::type>::value )); + } + + //! <b>Effects</b>: Same effects as <tt>template<class Pointer> unique_ptr(Pointer p, deleter_arg_type2 d2)</tt> + //! and additionally <tt>get() == nullptr</tt> + BOOST_MOVE_FORCEINLINE unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type2) d2) BOOST_NOEXCEPT + : m_data(pointer(), ::boost::move(d2)) + {} + + //! <b>Requires</b>: If D is not a reference type, D shall satisfy the requirements of MoveConstructible. + //! Construction of the deleter from an rvalue of type D shall not throw an exception. + //! + //! <b>Effects</b>: Constructs a unique_ptr by transferring ownership from u to *this. If D is a reference type, + //! this deleter is copy constructed from u's deleter; otherwise, this deleter is move constructed from u's + //! deleter. + //! + //! <b>Postconditions</b>: <tt>get()</tt> yields the value u.get() yielded before the construction. <tt>get_deleter()</tt> + //! returns a reference to the stored deleter that was constructed from u.get_deleter(). If D is a + //! reference type then <tt>get_deleter()</tt> and <tt>u.get_deleter()</tt> both reference the same lvalue deleter. + BOOST_MOVE_FORCEINLINE unique_ptr(BOOST_RV_REF(unique_ptr) u) BOOST_NOEXCEPT + : m_data(u.release(), ::boost::move_if_not_lvalue_reference<D>(u.get_deleter())) + {} + + //! <b>Requires</b>: If E is not a reference type, construction of the deleter from an rvalue of type E shall be + //! well formed and shall not throw an exception. Otherwise, E is a reference type and construction of the + //! deleter from an lvalue of type E shall be well formed and shall not throw an exception. + //! + //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless: + //! - <tt>unique_ptr<U, E>::pointer</tt> is implicitly convertible to pointer, + //! - U is not an array type, and + //! - either D is a reference type and E is the same type as D, or D is not a reference type and E is + //! implicitly convertible to D. + //! + //! <b>Effects</b>: Constructs a unique_ptr by transferring ownership from u to *this. If E is a reference type, + //! this deleter is copy constructed from u's deleter; otherwise, this deleter is move constructed from u's deleter. + //! + //! <b>Postconditions</b>: <tt>get()</tt> yields the value <tt>u.get()</tt> yielded before the construction. <tt>get_deleter()</tt> + //! returns a reference to the stored deleter that was constructed from <tt>u.get_deleter()</tt>. + template <class U, class E> + BOOST_MOVE_FORCEINLINE unique_ptr( BOOST_RV_REF_BEG_IF_CXX11 unique_ptr<U, E> BOOST_RV_REF_END_IF_CXX11 u + BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_moveconv_constr<T BOOST_MOVE_I D BOOST_MOVE_I U BOOST_MOVE_I E>::type* =0) + ) BOOST_NOEXCEPT + : m_data(u.release(), ::boost::move_if_not_lvalue_reference<E>(u.get_deleter())) + { + //If T is not an array type, U derives from T + //it uses the default deleter and T has no virtual destructor, then you have a problem + BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor + <D, typename unique_ptr<U, E>::pointer>::value )); + } + + //! <b>Requires</b>: The expression <tt>get_deleter()(get())</tt> shall be well formed, shall have well-defined behavior, + //! and shall not throw exceptions. + //! + //! <b>Effects</b>: If <tt>get() == nullpt1r</tt> there are no effects. Otherwise <tt>get_deleter()(get())</tt>. + //! + //! <b>Note</b>: The use of default_delete requires T to be a complete type + ~unique_ptr() + { if(m_data.m_p) m_data.deleter()(m_data.m_p); } + + //! <b>Requires</b>: If D is not a reference type, D shall satisfy the requirements of MoveAssignable + //! and assignment of the deleter from an rvalue of type D shall not throw an exception. Otherwise, D + //! is a reference type; <tt>remove_reference<D>::type</tt> shall satisfy the CopyAssignable requirements and + //! assignment of the deleter from an lvalue of type D shall not throw an exception. + //! + //! <b>Effects</b>: Transfers ownership from u to *this as if by calling <tt>reset(u.release())</tt> followed + //! by <tt>get_deleter() = std::forward<D>(u.get_deleter())</tt>. + //! + //! <b>Returns</b>: *this. + unique_ptr& operator=(BOOST_RV_REF(unique_ptr) u) BOOST_NOEXCEPT + { + this->reset(u.release()); + m_data.deleter() = ::boost::move_if_not_lvalue_reference<D>(u.get_deleter()); + return *this; + } + + //! <b>Requires</b>: If E is not a reference type, assignment of the deleter from an rvalue of type E shall be + //! well-formed and shall not throw an exception. Otherwise, E is a reference type and assignment of the + //! deleter from an lvalue of type E shall be well-formed and shall not throw an exception. + //! + //! <b>Remarks</b>: This operator shall not participate in overload resolution unless: + //! - <tt>unique_ptr<U, E>::pointer</tt> is implicitly convertible to pointer and + //! - U is not an array type. + //! + //! <b>Effects</b>: Transfers ownership from u to *this as if by calling <tt>reset(u.release())</tt> followed by + //! <tt>get_deleter() = std::forward<E>(u.get_deleter())</tt>. + //! + //! <b>Returns</b>: *this. + template <class U, class E> + BOOST_MOVE_DOC1ST(unique_ptr&, typename bmupd::enable_up_moveconv_assign + <T BOOST_MOVE_I D BOOST_MOVE_I U BOOST_MOVE_I E BOOST_MOVE_I unique_ptr &>::type) + operator=(BOOST_RV_REF_BEG unique_ptr<U, E> BOOST_RV_REF_END u) BOOST_NOEXCEPT + { + this->reset(u.release()); + m_data.deleter() = ::boost::move_if_not_lvalue_reference<E>(u.get_deleter()); + return *this; + } + + //! <b>Effects</b>: <tt>reset()</tt>. + //! + //! <b>Postcondition</b>: <tt>get() == nullptr</tt> + //! + //! <b>Returns</b>: *this. + unique_ptr& operator=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT + { this->reset(); return *this; } + + //! <b>Requires</b>: <tt>get() != nullptr</tt>. + //! + //! <b>Returns</b>: <tt>*get()</tt>. + //! + //! <b>Remarks</b: If T is an array type, the program is ill-formed. + BOOST_MOVE_DOC1ST(element_type&, typename bmupmu::add_lvalue_reference<element_type>::type) + operator*() const BOOST_NOEXCEPT + { + BOOST_STATIC_ASSERT((!bmupmu::is_array<T>::value)); + return *m_data.m_p; + } + + //! <b>Requires</b>: i < the number of elements in the array to which the stored pointer points. + //! + //! <b>Returns</b>: <tt>get()[i]</tt>. + //! + //! <b>Remarks</b: If T is not an array type, the program is ill-formed. + BOOST_MOVE_FORCEINLINE BOOST_MOVE_DOC1ST(element_type&, typename bmupmu::add_lvalue_reference<element_type>::type) + operator[](std::size_t i) const BOOST_NOEXCEPT + { + BOOST_ASSERT( bmupmu::extent<T>::value == 0 || i < bmupmu::extent<T>::value ); + BOOST_ASSERT(m_data.m_p); + return m_data.m_p[i]; + } + + //! <b>Requires</b>: <tt>get() != nullptr</tt>. + //! + //! <b>Returns</b>: <tt>get()</tt>. + //! + //! <b>Note</b>: use typically requires that T be a complete type. + //! + //! <b>Remarks</b: If T is an array type, the program is ill-formed. + BOOST_MOVE_FORCEINLINE pointer operator->() const BOOST_NOEXCEPT + { + BOOST_STATIC_ASSERT((!bmupmu::is_array<T>::value)); + BOOST_ASSERT(m_data.m_p); + return m_data.m_p; + } + + //! <b>Returns</b>: The stored pointer. + //! + BOOST_MOVE_FORCEINLINE pointer get() const BOOST_NOEXCEPT + { return m_data.m_p; } + + //! <b>Returns</b>: A reference to the stored deleter. + //! + BOOST_MOVE_FORCEINLINE BOOST_MOVE_DOC1ST(D&, typename bmupmu::add_lvalue_reference<D>::type) + get_deleter() BOOST_NOEXCEPT + { return m_data.deleter(); } + + //! <b>Returns</b>: A reference to the stored deleter. + //! + BOOST_MOVE_FORCEINLINE BOOST_MOVE_DOC1ST(const D&, typename bmupmu::add_const_lvalue_reference<D>::type) + get_deleter() const BOOST_NOEXCEPT + { return m_data.deleter(); } + + #ifdef BOOST_MOVE_DOXYGEN_INVOKED + //! <b>Returns</b>: Returns: get() != nullptr. + //! + BOOST_MOVE_FORCEINLINE explicit operator bool + #else + BOOST_MOVE_FORCEINLINE operator bmupd::explicit_bool_arg + #endif + ()const BOOST_NOEXCEPT + { + return m_data.m_p + ? &bmupd::bool_conversion::for_bool + : bmupd::explicit_bool_arg(0); + } + + //! <b>Postcondition</b>: <tt>get() == nullptr</tt>. + //! + //! <b>Returns</b>: The value <tt>get()</tt> had at the start of the call to release. + BOOST_MOVE_FORCEINLINE pointer release() BOOST_NOEXCEPT + { + const pointer tmp = m_data.m_p; + m_data.m_p = pointer(); + return tmp; + } + + //! <b>Requires</b>: The expression <tt>get_deleter()(get())</tt> shall be well formed, shall have well-defined behavior, + //! and shall not throw exceptions. + //! + //! <b>Effects</b>: assigns p to the stored pointer, and then if the old value of the stored pointer, old_p, was not + //! equal to nullptr, calls <tt>get_deleter()(old_p)</tt>. Note: The order of these operations is significant + //! because the call to <tt>get_deleter()</tt> may destroy *this. + //! + //! <b>Postconditions</b>: <tt>get() == p</tt>. Note: The postcondition does not hold if the call to <tt>get_deleter()</tt> + //! destroys *this since <tt>this->get()</tt> is no longer a valid expression. + //! + //! <b>Remarks</b>: This constructor shall not participate in overload resolution unless: + //! - If T is not an array type and Pointer is implicitly convertible to pointer. + //! - If T is an array type and Pointer is a more CV qualified pointer to element_type. + template<class Pointer> + BOOST_MOVE_DOC1ST(void, typename bmupd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer BOOST_MOVE_I void>::type) + reset(Pointer p) BOOST_NOEXCEPT + { + //If T is not an array type, element_type_t<Pointer> derives from T + //it uses the default deleter and T has no virtual destructor, then you have a problem + BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor + <D, typename bmupd::get_element_type<Pointer>::type>::value )); + pointer tmp = m_data.m_p; + m_data.m_p = p; + if(tmp) m_data.deleter()(tmp); + } + + //! <b>Requires</b>: The expression <tt>get_deleter()(get())</tt> shall be well formed, shall have well-defined behavior, + //! and shall not throw exceptions. + //! + //! <b>Effects</b>: assigns nullptr to the stored pointer, and then if the old value of the stored pointer, old_p, was not + //! equal to nullptr, calls <tt>get_deleter()(old_p)</tt>. Note: The order of these operations is significant + //! because the call to <tt>get_deleter()</tt> may destroy *this. + //! + //! <b>Postconditions</b>: <tt>get() == p</tt>. Note: The postcondition does not hold if the call to <tt>get_deleter()</tt> + //! destroys *this since <tt>this->get()</tt> is no longer a valid expression. + void reset() BOOST_NOEXCEPT + { this->reset(pointer()); } + + //! <b>Effects</b>: Same as <tt>reset()</tt> + //! + void reset(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT + { this->reset(); } + + //! <b>Requires</b>: <tt>get_deleter()</tt> shall be swappable and shall not throw an exception under swap. + //! + //! <b>Effects</b>: Invokes swap on the stored pointers and on the stored deleters of *this and u. + void swap(unique_ptr& u) BOOST_NOEXCEPT + { + ::boost::adl_move_swap(m_data.m_p, u.m_data.m_p); + ::boost::adl_move_swap(m_data.deleter(), u.m_data.deleter()); + } +}; + +//! <b>Effects</b>: Calls <tt>x.swap(y)</tt>. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE void swap(unique_ptr<T, D> &x, unique_ptr<T, D> &y) BOOST_NOEXCEPT +{ x.swap(y); } + +//! <b>Returns</b>: <tt>x.get() == y.get()</tt>. +//! +template <class T1, class D1, class T2, class D2> +BOOST_MOVE_FORCEINLINE bool operator==(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y) +{ return x.get() == y.get(); } + +//! <b>Returns</b>: <tt>x.get() != y.get()</tt>. +//! +template <class T1, class D1, class T2, class D2> +BOOST_MOVE_FORCEINLINE bool operator!=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y) +{ return x.get() != y.get(); } + +//! <b>Returns</b>: x.get() < y.get(). +//! +//! <b>Remarks</b>: This comparison shall induce a +//! strict weak ordering betwen pointers. +template <class T1, class D1, class T2, class D2> +BOOST_MOVE_FORCEINLINE bool operator<(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y) +{ return x.get() < y.get(); } + +//! <b>Returns</b>: !(y < x). +//! +template <class T1, class D1, class T2, class D2> +BOOST_MOVE_FORCEINLINE bool operator<=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y) +{ return !(y < x); } + +//! <b>Returns</b>: y < x. +//! +template <class T1, class D1, class T2, class D2> +BOOST_MOVE_FORCEINLINE bool operator>(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y) +{ return y < x; } + +//! <b>Returns</b>:!(x < y). +//! +template <class T1, class D1, class T2, class D2> +BOOST_MOVE_FORCEINLINE bool operator>=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y) +{ return !(x < y); } + +//! <b>Returns</b>:!x. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator==(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT +{ return !x; } + +//! <b>Returns</b>:!x. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator==(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) BOOST_NOEXCEPT +{ return !x; } + +//! <b>Returns</b>: (bool)x. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator!=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT +{ return !!x; } + +//! <b>Returns</b>: (bool)x. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator!=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) BOOST_NOEXCEPT +{ return !!x; } + +//! <b>Requires</b>: <tt>operator </tt> shall induce a strict weak ordering on unique_ptr<T, D>::pointer values. +//! +//! <b>Returns</b>: Returns <tt>x.get() < pointer()</tt>. +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator<(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) +{ return x.get() < typename unique_ptr<T, D>::pointer(); } + +//! <b>Requires</b>: <tt>operator </tt> shall induce a strict weak ordering on unique_ptr<T, D>::pointer values. +//! +//! <b>Returns</b>: Returns <tt>pointer() < x.get()</tt>. +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator<(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) +{ return typename unique_ptr<T, D>::pointer() < x.get(); } + +//! <b>Returns</b>: <tt>nullptr < x</tt>. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator>(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) +{ return x.get() > typename unique_ptr<T, D>::pointer(); } + +//! <b>Returns</b>: <tt>x < nullptr</tt>. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator>(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) +{ return typename unique_ptr<T, D>::pointer() > x.get(); } + +//! <b>Returns</b>: <tt>!(nullptr < x)</tt>. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator<=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) +{ return !(bmupd::nullptr_type() < x); } + +//! <b>Returns</b>: <tt>!(x < nullptr)</tt>. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator<=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) +{ return !(x < bmupd::nullptr_type()); } + +//! <b>Returns</b>: <tt>!(x < nullptr)</tt>. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator>=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) +{ return !(x < bmupd::nullptr_type()); } + +//! <b>Returns</b>: <tt>!(nullptr < x)</tt>. +//! +template <class T, class D> +BOOST_MOVE_FORCEINLINE bool operator>=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) +{ return !(bmupd::nullptr_type() < x); } + +} //namespace movelib { +} //namespace boost{ + +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_UNIQUE_PTR_HPP_INCLUDED diff --git a/contrib/src/boost/move/utility.hpp b/contrib/src/boost/move/utility.hpp index e7d6605..28de793 100644 --- a/contrib/src/boost/move/utility.hpp +++ b/contrib/src/boost/move/utility.hpp @@ -1,150 +1,150 @@ -//////////////////////////////////////////////////////////////////////////////
-//
-// (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
-//! This header includes core utilities from <tt><boost/move/utility_core.hpp></tt> and defines
-//! some more advanced utilities such as:
-
-#ifndef BOOST_MOVE_MOVE_UTILITY_HPP
-#define BOOST_MOVE_MOVE_UTILITY_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> //forceinline
-#include <boost/move/utility_core.hpp>
-#include <boost/move/traits.hpp>
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- namespace boost {
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // move_if_noexcept()
- //
- //////////////////////////////////////////////////////////////////////////////
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < enable_move_utility_emulation<T>::value && !has_move_emulation_enabled<T>::value
- , typename ::boost::move_detail::add_const<T>::type &
- >::type
- move_if_noexcept(T& x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
- && ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, rv<T>&>::type
- move_if_noexcept(T& x) BOOST_NOEXCEPT
- {
- return *static_cast<rv<T>* >(::boost::move_detail::addressof(x));
- }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
- && ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value
- , rv<T>&
- >::type
- move_if_noexcept(rv<T>& x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
- && !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value
- , typename ::boost::move_detail::add_const<T>::type &
- >::type
- move_if_noexcept(T& x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
- && !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value
- , typename ::boost::move_detail::add_const<T>::type &
- >::type
- move_if_noexcept(rv<T>& x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- } //namespace boost
-
-#else //#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- #if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
- #include <utility>
-
- namespace boost{
-
- using ::std::move_if_noexcept;
-
- } //namespace boost
-
- #else //!BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE
-
- namespace boost {
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // move_if_noexcept()
- //
- //////////////////////////////////////////////////////////////////////////////
- #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
- //! This function provides a way to convert a reference into a rvalue reference
- //! in compilers with rvalue references. For other compilers converts T & into
- //! <i>::boost::rv<T> &</i> so that move emulation is activated. Reference
- //! would be converted to rvalue reference only if input type is nothrow move
- //! constructible or if it has no copy constructor. In all other cases const
- //! reference would be returned
- template <class T>
- rvalue_reference_or_const_lvalue_reference move_if_noexcept(input_reference) noexcept;
-
- #else //BOOST_MOVE_DOXYGEN_INVOKED
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, T&&>::type
- move_if_noexcept(T& x) BOOST_NOEXCEPT
- { return ::boost::move(x); }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
- < !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, const T&>::type
- move_if_noexcept(T& x) BOOST_NOEXCEPT
- { return x; }
-
- #endif //BOOST_MOVE_DOXYGEN_INVOKED
-
- } //namespace boost {
-
- #endif //#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
-
-#endif //BOOST_NO_CXX11_RVALUE_REFERENCES
-
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_MOVE_UTILITY_HPP
+////////////////////////////////////////////////////////////////////////////// +// +// (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 +//! This header includes core utilities from <tt><boost/move/utility_core.hpp></tt> and defines +//! some more advanced utilities such as: + +#ifndef BOOST_MOVE_MOVE_UTILITY_HPP +#define BOOST_MOVE_MOVE_UTILITY_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> //forceinline +#include <boost/move/utility_core.hpp> +#include <boost/move/traits.hpp> + +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + namespace boost { + + ////////////////////////////////////////////////////////////////////////////// + // + // move_if_noexcept() + // + ////////////////////////////////////////////////////////////////////////////// + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation<T>::value && !has_move_emulation_enabled<T>::value + , typename ::boost::move_detail::add_const<T>::type & + >::type + move_if_noexcept(T& x) BOOST_NOEXCEPT + { + return x; + } + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value + && ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, rv<T>&>::type + move_if_noexcept(T& x) BOOST_NOEXCEPT + { + return *static_cast<rv<T>* >(::boost::move_detail::addressof(x)); + } + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value + && ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value + , rv<T>& + >::type + move_if_noexcept(rv<T>& x) BOOST_NOEXCEPT + { + return x; + } + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value + && !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value + , typename ::boost::move_detail::add_const<T>::type & + >::type + move_if_noexcept(T& x) BOOST_NOEXCEPT + { + return x; + } + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value + && !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value + , typename ::boost::move_detail::add_const<T>::type & + >::type + move_if_noexcept(rv<T>& x) BOOST_NOEXCEPT + { + return x; + } + + } //namespace boost + +#else //#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE) + #include <utility> + + namespace boost{ + + using ::std::move_if_noexcept; + + } //namespace boost + + #else //!BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE + + namespace boost { + + ////////////////////////////////////////////////////////////////////////////// + // + // move_if_noexcept() + // + ////////////////////////////////////////////////////////////////////////////// + #if defined(BOOST_MOVE_DOXYGEN_INVOKED) + //! This function provides a way to convert a reference into a rvalue reference + //! in compilers with rvalue references. For other compilers converts T & into + //! <i>::boost::rv<T> &</i> so that move emulation is activated. Reference + //! would be converted to rvalue reference only if input type is nothrow move + //! constructible or if it has no copy constructor. In all other cases const + //! reference would be returned + template <class T> + rvalue_reference_or_const_lvalue_reference move_if_noexcept(input_reference) noexcept; + + #else //BOOST_MOVE_DOXYGEN_INVOKED + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, T&&>::type + move_if_noexcept(T& x) BOOST_NOEXCEPT + { return ::boost::move(x); } + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, const T&>::type + move_if_noexcept(T& x) BOOST_NOEXCEPT + { return x; } + + #endif //BOOST_MOVE_DOXYGEN_INVOKED + + } //namespace boost { + + #endif //#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE) + +#endif //BOOST_NO_CXX11_RVALUE_REFERENCES + +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_MOVE_UTILITY_HPP diff --git a/contrib/src/boost/move/utility_core.hpp b/contrib/src/boost/move/utility_core.hpp index 821ad57..55042a9 100644 --- a/contrib/src/boost/move/utility_core.hpp +++ b/contrib/src/boost/move/utility_core.hpp @@ -1,318 +1,318 @@ -//////////////////////////////////////////////////////////////////////////////
-//
-// (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
-//! This header defines core utilities to ease the development
-//! of move-aware functions. This header minimizes dependencies
-//! from other libraries.
-
-#ifndef BOOST_MOVE_MOVE_UTILITY_CORE_HPP
-#define BOOST_MOVE_MOVE_UTILITY_CORE_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> //forceinline
-#include <boost/move/core.hpp>
-#include <boost/move/detail/meta_utils.hpp>
-#include <boost/static_assert.hpp>
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- namespace boost {
-
- template<class T>
- struct enable_move_utility_emulation
- {
- static const bool value = true;
- };
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // move()
- //
- //////////////////////////////////////////////////////////////////////////////
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and
- < T &
- , enable_move_utility_emulation<T>
- , has_move_emulation_disabled<T>
- >::type
- move(T& x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and
- < rv<T>&
- , enable_move_utility_emulation<T>
- , has_move_emulation_enabled<T>
- >::type
- move(T& x) BOOST_NOEXCEPT
- {
- return *BOOST_MOVE_TO_RV_CAST(::boost::rv<T>*, ::boost::move_detail::addressof(x) );
- }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and
- < rv<T>&
- , enable_move_utility_emulation<T>
- , has_move_emulation_enabled<T>
- >::type
- move(rv<T>& x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // forward()
- //
- //////////////////////////////////////////////////////////////////////////////
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and
- < T &
- , enable_move_utility_emulation<T>
- , ::boost::move_detail::is_rv<T>
- >::type
- forward(const typename ::boost::move_detail::identity<T>::type &x) BOOST_NOEXCEPT
- {
- return const_cast<T&>(x);
- }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and
- < const T &
- , enable_move_utility_emulation<T>
- , ::boost::move_detail::is_not_rv<T>
- >::type
- forward(const typename ::boost::move_detail::identity<T>::type &x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // move_if_not_lvalue_reference()
- //
- //////////////////////////////////////////////////////////////////////////////
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and
- < T &
- , enable_move_utility_emulation<T>
- , ::boost::move_detail::is_rv<T>
- >::type
- move_if_not_lvalue_reference(const typename ::boost::move_detail::identity<T>::type &x) BOOST_NOEXCEPT
- {
- return const_cast<T&>(x);
- }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and
- < typename ::boost::move_detail::add_lvalue_reference<T>::type
- , enable_move_utility_emulation<T>
- , ::boost::move_detail::is_not_rv<T>
- , ::boost::move_detail::or_
- < ::boost::move_detail::is_lvalue_reference<T>
- , has_move_emulation_disabled<T>
- >
- >::type
- move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type &x) BOOST_NOEXCEPT
- {
- return x;
- }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and
- < rv<T>&
- , enable_move_utility_emulation<T>
- , ::boost::move_detail::is_not_rv<T>
- , ::boost::move_detail::and_
- < ::boost::move_detail::not_< ::boost::move_detail::is_lvalue_reference<T> >
- , has_move_emulation_enabled<T>
- >
- >::type
- move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type &x) BOOST_NOEXCEPT
- {
- return move(x);
- }
-
- } //namespace boost
-
-#else //#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
- #if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
- #include <utility>
-
- namespace boost{
-
- using ::std::move;
- using ::std::forward;
-
- } //namespace boost
-
- #else //!BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE
-
- namespace boost {
-
- //! This trait's internal boolean `value` is false in compilers with rvalue references
- //! and true in compilers without rvalue references.
- //!
- //! A user can specialize this trait for a type T to false to SFINAE out `move` and `forward`
- //! so that the user can define a different move emulation for that type in namespace boost
- //! (e.g. another Boost library for its types) and avoid any overload ambiguity.
- template<class T>
- struct enable_move_utility_emulation
- {
- static const bool value = false;
- };
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // move
- //
- //////////////////////////////////////////////////////////////////////////////
-
- #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
- //! This function provides a way to convert a reference into a rvalue reference
- //! in compilers with rvalue references. For other compilers if `T` is Boost.Move
- //! enabled type then it converts `T&` into <tt>::boost::rv<T> &</tt> so that
- //! move emulation is activated, else it returns `T &`.
- template <class T>
- rvalue_reference move(input_reference) noexcept;
-
- #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
-
- //Old move approach, lvalues could bind to rvalue references
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::remove_reference<T>::type && move(T&& t) BOOST_NOEXCEPT
- { return t; }
-
- #else //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
-
- template <class T>
- BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::remove_reference<T>::type && move(T&& t) BOOST_NOEXCEPT
- { return static_cast<typename ::boost::move_detail::remove_reference<T>::type &&>(t); }
-
- #endif //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // forward
- //
- //////////////////////////////////////////////////////////////////////////////
-
-
- #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
- //! This function provides limited form of forwarding that is usually enough for
- //! in-place construction and avoids the exponential overloading for
- //! achieve the limited forwarding in C++03.
- //!
- //! For compilers with rvalue references this function provides perfect forwarding.
- //!
- //! Otherwise:
- //! * If input_reference binds to const ::boost::rv<T> & then it output_reference is
- //! ::boost::rv<T> &
- //!
- //! * Else, output_reference is equal to input_reference.
- template <class T> output_reference forward(input_reference) noexcept;
- #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
-
- //Old move approach, lvalues could bind to rvalue references
-
- template <class T>
- BOOST_MOVE_FORCEINLINE T&& forward(typename ::boost::move_detail::identity<T>::type&& t) BOOST_NOEXCEPT
- { return t; }
-
- #else //Old move
-
- template <class T>
- BOOST_MOVE_FORCEINLINE T&& forward(typename ::boost::move_detail::remove_reference<T>::type& t) BOOST_NOEXCEPT
- { return static_cast<T&&>(t); }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE T&& forward(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT
- {
- //"boost::forward<T> error: 'T' is a lvalue reference, can't forward as rvalue.";
- BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value);
- return static_cast<T&&>(t);
- }
-
- #endif //BOOST_MOVE_DOXYGEN_INVOKED
-
- //////////////////////////////////////////////////////////////////////////////
- //
- // move_if_not_lvalue_reference
- //
- //////////////////////////////////////////////////////////////////////////////
-
-
- #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
- //! <b>Effects</b>: Calls `boost::move` if `input_reference` is not a lvalue reference.
- //! Otherwise returns the reference
- template <class T> output_reference move_if_not_lvalue_reference(input_reference) noexcept;
- #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
-
- //Old move approach, lvalues could bind to rvalue references
-
- template <class T>
- BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::identity<T>::type&& t) BOOST_NOEXCEPT
- { return t; }
-
- #else //Old move
-
- template <class T>
- BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type& t) BOOST_NOEXCEPT
- { return static_cast<T&&>(t); }
-
- template <class T>
- BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT
- {
- //"boost::forward<T> error: 'T' is a lvalue reference, can't forward as rvalue.";
- BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value);
- return static_cast<T&&>(t);
- }
-
- #endif //BOOST_MOVE_DOXYGEN_INVOKED
-
- } //namespace boost {
-
- #endif //#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
-
-#endif //BOOST_NO_CXX11_RVALUE_REFERENCES
-
-#if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
-namespace boost{
-namespace move_detail{
-
-template <typename T>
-typename boost::move_detail::add_rvalue_reference<T>::type declval();
-
-} //namespace move_detail{
-} //namespace boost{
-
-#endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
-
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_MOVE_UTILITY_CORE_HPP
+////////////////////////////////////////////////////////////////////////////// +// +// (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 +//! This header defines core utilities to ease the development +//! of move-aware functions. This header minimizes dependencies +//! from other libraries. + +#ifndef BOOST_MOVE_MOVE_UTILITY_CORE_HPP +#define BOOST_MOVE_MOVE_UTILITY_CORE_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> //forceinline +#include <boost/move/core.hpp> +#include <boost/move/detail/meta_utils.hpp> +#include <boost/static_assert.hpp> + +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + namespace boost { + + template<class T> + struct enable_move_utility_emulation + { + static const bool value = true; + }; + + ////////////////////////////////////////////////////////////////////////////// + // + // move() + // + ////////////////////////////////////////////////////////////////////////////// + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and + < T & + , enable_move_utility_emulation<T> + , has_move_emulation_disabled<T> + >::type + move(T& x) BOOST_NOEXCEPT + { + return x; + } + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and + < rv<T>& + , enable_move_utility_emulation<T> + , has_move_emulation_enabled<T> + >::type + move(T& x) BOOST_NOEXCEPT + { + return *BOOST_MOVE_TO_RV_CAST(::boost::rv<T>*, ::boost::move_detail::addressof(x) ); + } + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and + < rv<T>& + , enable_move_utility_emulation<T> + , has_move_emulation_enabled<T> + >::type + move(rv<T>& x) BOOST_NOEXCEPT + { + return x; + } + + ////////////////////////////////////////////////////////////////////////////// + // + // forward() + // + ////////////////////////////////////////////////////////////////////////////// + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and + < T & + , enable_move_utility_emulation<T> + , ::boost::move_detail::is_rv<T> + >::type + forward(const typename ::boost::move_detail::identity<T>::type &x) BOOST_NOEXCEPT + { + return const_cast<T&>(x); + } + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and + < const T & + , enable_move_utility_emulation<T> + , ::boost::move_detail::is_not_rv<T> + >::type + forward(const typename ::boost::move_detail::identity<T>::type &x) BOOST_NOEXCEPT + { + return x; + } + + ////////////////////////////////////////////////////////////////////////////// + // + // move_if_not_lvalue_reference() + // + ////////////////////////////////////////////////////////////////////////////// + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and + < T & + , enable_move_utility_emulation<T> + , ::boost::move_detail::is_rv<T> + >::type + move_if_not_lvalue_reference(const typename ::boost::move_detail::identity<T>::type &x) BOOST_NOEXCEPT + { + return const_cast<T&>(x); + } + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and + < typename ::boost::move_detail::add_lvalue_reference<T>::type + , enable_move_utility_emulation<T> + , ::boost::move_detail::is_not_rv<T> + , ::boost::move_detail::or_ + < ::boost::move_detail::is_lvalue_reference<T> + , has_move_emulation_disabled<T> + > + >::type + move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type &x) BOOST_NOEXCEPT + { + return x; + } + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_and + < rv<T>& + , enable_move_utility_emulation<T> + , ::boost::move_detail::is_not_rv<T> + , ::boost::move_detail::and_ + < ::boost::move_detail::not_< ::boost::move_detail::is_lvalue_reference<T> > + , has_move_emulation_enabled<T> + > + >::type + move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type &x) BOOST_NOEXCEPT + { + return move(x); + } + + } //namespace boost + +#else //#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE) + #include <utility> + + namespace boost{ + + using ::std::move; + using ::std::forward; + + } //namespace boost + + #else //!BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE + + namespace boost { + + //! This trait's internal boolean `value` is false in compilers with rvalue references + //! and true in compilers without rvalue references. + //! + //! A user can specialize this trait for a type T to false to SFINAE out `move` and `forward` + //! so that the user can define a different move emulation for that type in namespace boost + //! (e.g. another Boost library for its types) and avoid any overload ambiguity. + template<class T> + struct enable_move_utility_emulation + { + static const bool value = false; + }; + + ////////////////////////////////////////////////////////////////////////////// + // + // move + // + ////////////////////////////////////////////////////////////////////////////// + + #if defined(BOOST_MOVE_DOXYGEN_INVOKED) + //! This function provides a way to convert a reference into a rvalue reference + //! in compilers with rvalue references. For other compilers if `T` is Boost.Move + //! enabled type then it converts `T&` into <tt>::boost::rv<T> &</tt> so that + //! move emulation is activated, else it returns `T &`. + template <class T> + rvalue_reference move(input_reference) noexcept; + + #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES) + + //Old move approach, lvalues could bind to rvalue references + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::remove_reference<T>::type && move(T&& t) BOOST_NOEXCEPT + { return t; } + + #else //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES + + template <class T> + BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::remove_reference<T>::type && move(T&& t) BOOST_NOEXCEPT + { return static_cast<typename ::boost::move_detail::remove_reference<T>::type &&>(t); } + + #endif //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES + + ////////////////////////////////////////////////////////////////////////////// + // + // forward + // + ////////////////////////////////////////////////////////////////////////////// + + + #if defined(BOOST_MOVE_DOXYGEN_INVOKED) + //! This function provides limited form of forwarding that is usually enough for + //! in-place construction and avoids the exponential overloading for + //! achieve the limited forwarding in C++03. + //! + //! For compilers with rvalue references this function provides perfect forwarding. + //! + //! Otherwise: + //! * If input_reference binds to const ::boost::rv<T> & then it output_reference is + //! ::boost::rv<T> & + //! + //! * Else, output_reference is equal to input_reference. + template <class T> output_reference forward(input_reference) noexcept; + #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES) + + //Old move approach, lvalues could bind to rvalue references + + template <class T> + BOOST_MOVE_FORCEINLINE T&& forward(typename ::boost::move_detail::identity<T>::type&& t) BOOST_NOEXCEPT + { return t; } + + #else //Old move + + template <class T> + BOOST_MOVE_FORCEINLINE T&& forward(typename ::boost::move_detail::remove_reference<T>::type& t) BOOST_NOEXCEPT + { return static_cast<T&&>(t); } + + template <class T> + BOOST_MOVE_FORCEINLINE T&& forward(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT + { + //"boost::forward<T> error: 'T' is a lvalue reference, can't forward as rvalue."; + BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value); + return static_cast<T&&>(t); + } + + #endif //BOOST_MOVE_DOXYGEN_INVOKED + + ////////////////////////////////////////////////////////////////////////////// + // + // move_if_not_lvalue_reference + // + ////////////////////////////////////////////////////////////////////////////// + + + #if defined(BOOST_MOVE_DOXYGEN_INVOKED) + //! <b>Effects</b>: Calls `boost::move` if `input_reference` is not a lvalue reference. + //! Otherwise returns the reference + template <class T> output_reference move_if_not_lvalue_reference(input_reference) noexcept; + #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES) + + //Old move approach, lvalues could bind to rvalue references + + template <class T> + BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::identity<T>::type&& t) BOOST_NOEXCEPT + { return t; } + + #else //Old move + + template <class T> + BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type& t) BOOST_NOEXCEPT + { return static_cast<T&&>(t); } + + template <class T> + BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT + { + //"boost::forward<T> error: 'T' is a lvalue reference, can't forward as rvalue."; + BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value); + return static_cast<T&&>(t); + } + + #endif //BOOST_MOVE_DOXYGEN_INVOKED + + } //namespace boost { + + #endif //#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE) + +#endif //BOOST_NO_CXX11_RVALUE_REFERENCES + +#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + +namespace boost{ +namespace move_detail{ + +template <typename T> +typename boost::move_detail::add_rvalue_reference<T>::type declval(); + +} //namespace move_detail{ +} //namespace boost{ + +#endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + +#include <boost/move/detail/config_end.hpp> + +#endif //#ifndef BOOST_MOVE_MOVE_UTILITY_CORE_HPP |