Differential D47360 Diff 219818 include/__memory_resource_base

Changeset View

Standalone View

include/__memory_resource_base

This file was added.

				// -- C++ --
				//===------------------------ memory_resource -----------------------------===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#ifndef _LIBCPP___MEMORY_RESOURCE_BASE
				#define _LIBCPP___MEMORY_RESOURCE_BASE

				#ifndef _LIBCPP_CXX03_LANG

				/**
				memory_resource synopsis

				// C++17

				namespace std {
				namespace pmr {

				class memory_resource;

				bool operator==(const memory_resource& a,
				const memory_resource& b) noexcept;
				bool operator!=(const memory_resource& a,
				const memory_resource& b) noexcept;

				template <class Tp> class polymorphic_allocator;

				template <class T1, class T2>
				bool operator==(const polymorphic_allocator<T1>& a,
				const polymorphic_allocator<T2>& b) noexcept;
				template <class T1, class T2>
				bool operator!=(const polymorphic_allocator<T1>& a,
				const polymorphic_allocator<T2>& b) noexcept;

				// Global memory resources
				memory_resource* set_default_resource(memory_resource* r) noexcept;
				memory_resource* get_default_resource() noexcept;

				} // namespace pmr
				} // namespace std

				*/

				#include <__config>
				#include <__functional_base>
				#include <limits>
				#include <memory>
				#include <new>
				#include <stdexcept>
				QuuxplusoneAuthorUnsubmitted Done Reply Inline Actions This should be `#include <__tuple>` Quuxplusone: This should be `#include <__tuple>`
				#include <tuple>
				#include <type_traits>
				#include <utility>
				#include <cstddef>
				#include <cstdlib>
				#include <__debug>

				#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
				#pragma GCC system_header
				#endif

				_LIBCPP_PUSH_MACROS
				#include <__undef_macros>

				_LIBCPP_BEGIN_NAMESPACE_STD

				namespace pmr
				{

				// 23.12.2, mem.res.class
				class _LIBCPP_TYPE_VIS memory_resource
				{
				static const size_t __max_align = alignof(max_align_t);

				// 23.12.2.1, mem.res.public
				public:
				virtual ~memory_resource() = default;

				_LIBCPP_INLINE_VISIBILITY
				void* allocate(size_t __bytes, size_t __align = __max_align)
				{ return do_allocate(__bytes, __align); }

				_LIBCPP_INLINE_VISIBILITY
				void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
				{ do_deallocate(__p, __bytes, __align); }

				_LIBCPP_INLINE_VISIBILITY
				bool is_equal(memory_resource const & __other) const _NOEXCEPT
				{ return do_is_equal(__other); }

				// 23.12.2.2, mem.res.private
				private:
				virtual void* do_allocate(size_t, size_t) = 0;
				virtual void do_deallocate(void*, size_t, size_t) = 0;
				virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
				};

				// 23.12.2.3, mem.res.eq
				inline _LIBCPP_INLINE_VISIBILITY
				bool operator==(memory_resource const & __lhs,
				memory_resource const & __rhs) _NOEXCEPT
				{
				return &__lhs == &__rhs \|\| __lhs.is_equal(__rhs);
				}

				inline _LIBCPP_INLINE_VISIBILITY
				bool operator!=(memory_resource const & __lhs,
				memory_resource const & __rhs) _NOEXCEPT
				{
				return !(__lhs == __rhs);
				}

				// 23.12.4, mem.res.global

				_LIBCPP_FUNC_VIS
				memory_resource * get_default_resource() _NOEXCEPT;

				_LIBCPP_FUNC_VIS
				memory_resource * set_default_resource(memory_resource *) _NOEXCEPT;

				// 23.12.3, mem.poly.allocator.class
				template <class _ValueType>
				class _LIBCPP_TEMPLATE_VIS polymorphic_allocator
				{
				public:
				typedef _ValueType value_type;

				// 23.12.3.1, mem.poly.allocator.ctor
				_LIBCPP_INLINE_VISIBILITY
				polymorphic_allocator() _NOEXCEPT
				: __res_(_VSTD::pmr::get_default_resource())
				{}

				_LIBCPP_INLINE_VISIBILITY
				polymorphic_allocator(memory_resource * __r) _NOEXCEPT
				: __res_(__r)
				{}

				polymorphic_allocator(polymorphic_allocator const &) = default;

				template <class _Tp>
				_LIBCPP_INLINE_VISIBILITY
				polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT
				: __res_(__other.resource())
				{}

				polymorphic_allocator &
				operator=(polymorphic_allocator const &) = delete;

				// 23.12.3.2, mem.poly.allocator.mem
				_LIBCPP_INLINE_VISIBILITY
				_ValueType* allocate(size_t __n) {
				if (__n > __max_size()) {
				__throw_length_error(
				"std::pmr::polymorphic_allocator<T>::allocate(size_t n)"
				" 'n' exceeds maximum supported size");
				}
				return static_cast<_ValueType*>(
				__res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType))
				);
				}

				_LIBCPP_INLINE_VISIBILITY
				void deallocate(_ValueType * __p, size_t __n) {
				_LIBCPP_ASSERT(__n <= __max_size(),
				"deallocate called for size which exceeds max_size()");
				__res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
				}

				template <class _Tp, class ..._Ts>
				_LIBCPP_INLINE_VISIBILITY
				void construct(_Tp* __p, _Ts &&... __args)
				{
				_VSTD::__user_alloc_construct_impl(
				typename __uses_alloc_ctor<_Tp, polymorphic_allocator&, _Ts...>::type(),
				__p, *this, _VSTD::forward<_Ts>(__args)...
				);
				}

				template <class _T1, class _T2, class ..._Args1, class ..._Args2>
				_LIBCPP_INLINE_VISIBILITY
				void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
				tuple<_Args1...> __x, tuple<_Args2...> __y)
				{
				::new ((void*)__p) pair<_T1, _T2>(piecewise_construct
				, __transform_tuple(
				typename __uses_alloc_ctor<
				_T1, polymorphic_allocator&, _Args1...
				>::type()
				, _VSTD::move(__x)
				, typename __make_tuple_indices<sizeof...(_Args1)>::type{}
				)
				, __transform_tuple(
				typename __uses_alloc_ctor<
				_T2, polymorphic_allocator&, _Args2...
				>::type()
				, _VSTD::move(__y)
				, typename __make_tuple_indices<sizeof...(_Args2)>::type{}
				)
				);
				}

				template <class _T1, class _T2>
				_LIBCPP_INLINE_VISIBILITY
				void construct(pair<_T1, _T2>* __p) {
				construct(__p, piecewise_construct, tuple<>(), tuple<>());
				}

				template <class _T1, class _T2, class _Up, class _Vp>
				_LIBCPP_INLINE_VISIBILITY
				void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) {
				construct(__p, piecewise_construct
				, _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u))
				, _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v)));
				}

				template <class _T1, class _T2, class _U1, class _U2>
				_LIBCPP_INLINE_VISIBILITY
				void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) {
				construct(__p, piecewise_construct
				, _VSTD::forward_as_tuple(__pr.first)
				, _VSTD::forward_as_tuple(__pr.second));
				}

				template <class _T1, class _T2, class _U1, class _U2>
				_LIBCPP_INLINE_VISIBILITY
				void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){
				construct(__p, piecewise_construct
				, _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first))
				, _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second)));
				}

				template <class _Tp>
				_LIBCPP_INLINE_VISIBILITY
				void destroy(_Tp * __p)
				{ __p->~_Tp(); }

				_LIBCPP_INLINE_VISIBILITY
				polymorphic_allocator
				select_on_container_copy_construction() const _NOEXCEPT
				{ return polymorphic_allocator(); }

				_LIBCPP_INLINE_VISIBILITY
				memory_resource * resource() const _NOEXCEPT
				{ return __res_; }

				private:
				template <class ..._Args, size_t ..._Idx>
				_LIBCPP_INLINE_VISIBILITY
				tuple<_Args&&...>
				__transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
				__tuple_indices<_Idx...>)
				{
				return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...);
				}

				template <class ..._Args, size_t ..._Idx>
				_LIBCPP_INLINE_VISIBILITY
				tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>
				__transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
				__tuple_indices<_Idx...>)
				{
				using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>;
				return _Tup(allocator_arg, *this,
				_VSTD::get<_Idx>(_VSTD::move(__t))...);
				}

				template <class ..._Args, size_t ..._Idx>
				_LIBCPP_INLINE_VISIBILITY
				tuple<_Args&&..., polymorphic_allocator&>
				__transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
				__tuple_indices<_Idx...>)
				{
				using _Tup = tuple<_Args&&..., polymorphic_allocator&>;
				return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this);
				}

				_LIBCPP_INLINE_VISIBILITY
				size_t __max_size() const _NOEXCEPT
				{ return numeric_limits<size_t>::max() / sizeof(value_type); }

				memory_resource * __res_;
				};

				// 23.12.3.3, mem.poly.allocator.eq

				template <class _Tp, class _Up>
				inline _LIBCPP_INLINE_VISIBILITY
				bool operator==(polymorphic_allocator<_Tp> const & __lhs,
				polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
				{
				return __lhs.resource() == __rhs.resource();
				}

				template <class _Tp, class _Up>
				inline _LIBCPP_INLINE_VISIBILITY
				bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
				polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
				{
				return !(__lhs == __rhs);
				}

				} // namespace pmr

				_LIBCPP_END_NAMESPACE_STD

				_LIBCPP_POP_MACROS

				#endif /* _LIBCPP_CXX03_LANG */

				#endif /* _LIBCPP___MEMORY_RESOURCE_BASE */