diff options
Diffstat (limited to 'src/third_party/boost-1.60.0/boost/move/default_delete.hpp')
| -rw-r--r-- | src/third_party/boost-1.60.0/boost/move/default_delete.hpp | 201 |
1 files changed, 201 insertions, 0 deletions
diff --git a/src/third_party/boost-1.60.0/boost/move/default_delete.hpp b/src/third_party/boost-1.60.0/boost/move/default_delete.hpp new file mode 100644 index 00000000000..1c26ed924b2 --- /dev/null +++ b/src/third_party/boost-1.60.0/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 |