mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2024-12-13 19:24:21 +00:00
57b08b0944
to reflect the new license. These used slightly different spellings that defeated my regular expressions. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351648
684 lines
25 KiB
C++
684 lines
25 KiB
C++
// -*- C++ -*-
|
|
//===-------------------------- scoped_allocator --------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP_SCOPED_ALLOCATOR
|
|
#define _LIBCPP_SCOPED_ALLOCATOR
|
|
|
|
/*
|
|
scoped_allocator synopsis
|
|
|
|
namespace std
|
|
{
|
|
|
|
template <class OuterAlloc, class... InnerAllocs>
|
|
class scoped_allocator_adaptor : public OuterAlloc
|
|
{
|
|
typedef allocator_traits<OuterAlloc> OuterTraits; // exposition only
|
|
scoped_allocator_adaptor<InnerAllocs...> inner; // exposition only
|
|
public:
|
|
|
|
typedef OuterAlloc outer_allocator_type;
|
|
typedef see below inner_allocator_type;
|
|
|
|
typedef typename OuterTraits::value_type value_type;
|
|
typedef typename OuterTraits::size_type size_type;
|
|
typedef typename OuterTraits::difference_type difference_type;
|
|
typedef typename OuterTraits::pointer pointer;
|
|
typedef typename OuterTraits::const_pointer const_pointer;
|
|
typedef typename OuterTraits::void_pointer void_pointer;
|
|
typedef typename OuterTraits::const_void_pointer const_void_pointer;
|
|
|
|
typedef see below propagate_on_container_copy_assignment;
|
|
typedef see below propagate_on_container_move_assignment;
|
|
typedef see below propagate_on_container_swap;
|
|
typedef see below is_always_equal;
|
|
|
|
template <class Tp>
|
|
struct rebind
|
|
{
|
|
typedef scoped_allocator_adaptor<
|
|
OuterTraits::template rebind_alloc<Tp>, InnerAllocs...> other;
|
|
};
|
|
|
|
scoped_allocator_adaptor();
|
|
template <class OuterA2>
|
|
scoped_allocator_adaptor(OuterA2&& outerAlloc,
|
|
const InnerAllocs&... innerAllocs) noexcept;
|
|
scoped_allocator_adaptor(const scoped_allocator_adaptor& other) noexcept;
|
|
scoped_allocator_adaptor(scoped_allocator_adaptor&& other) noexcept;
|
|
template <class OuterA2>
|
|
scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other) noexcept;
|
|
template <class OuterA2>
|
|
scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other) noexcept;
|
|
|
|
scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default;
|
|
scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default;
|
|
~scoped_allocator_adaptor();
|
|
|
|
inner_allocator_type& inner_allocator() noexcept;
|
|
const inner_allocator_type& inner_allocator() const noexcept;
|
|
|
|
outer_allocator_type& outer_allocator() noexcept;
|
|
const outer_allocator_type& outer_allocator() const noexcept;
|
|
|
|
pointer allocate(size_type n); // [[nodiscard]] in C++20
|
|
pointer allocate(size_type n, const_void_pointer hint); // [[nodiscard]] in C++20
|
|
void deallocate(pointer p, size_type n) noexcept;
|
|
|
|
size_type max_size() const;
|
|
template <class T, class... Args> void construct(T* p, Args&& args);
|
|
template <class T1, class T2, class... Args1, class... Args2>
|
|
void construct(pair<T1, T2>* p, piecewise_construct t, tuple<Args1...> x,
|
|
tuple<Args2...> y);
|
|
template <class T1, class T2>
|
|
void construct(pair<T1, T2>* p);
|
|
template <class T1, class T2, class U, class V>
|
|
void construct(pair<T1, T2>* p, U&& x, V&& y);
|
|
template <class T1, class T2, class U, class V>
|
|
void construct(pair<T1, T2>* p, const pair<U, V>& x);
|
|
template <class T1, class T2, class U, class V>
|
|
void construct(pair<T1, T2>* p, pair<U, V>&& x);
|
|
template <class T> void destroy(T* p);
|
|
|
|
template <class T> void destroy(T* p) noexcept;
|
|
|
|
scoped_allocator_adaptor select_on_container_copy_construction() const noexcept;
|
|
};
|
|
|
|
template <class OuterA1, class OuterA2, class... InnerAllocs>
|
|
bool
|
|
operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
|
|
const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
|
|
|
|
template <class OuterA1, class OuterA2, class... InnerAllocs>
|
|
bool
|
|
operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
|
|
const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
|
|
|
|
} // std
|
|
|
|
*/
|
|
|
|
#include <__config>
|
|
#include <memory>
|
|
#include <version>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
#if !defined(_LIBCPP_CXX03_LANG)
|
|
|
|
// scoped_allocator_adaptor
|
|
|
|
template <class ..._Allocs>
|
|
class scoped_allocator_adaptor;
|
|
|
|
template <class ..._Allocs> struct __get_poc_copy_assignment;
|
|
|
|
template <class _A0>
|
|
struct __get_poc_copy_assignment<_A0>
|
|
{
|
|
static const bool value = allocator_traits<_A0>::
|
|
propagate_on_container_copy_assignment::value;
|
|
};
|
|
|
|
template <class _A0, class ..._Allocs>
|
|
struct __get_poc_copy_assignment<_A0, _Allocs...>
|
|
{
|
|
static const bool value =
|
|
allocator_traits<_A0>::propagate_on_container_copy_assignment::value ||
|
|
__get_poc_copy_assignment<_Allocs...>::value;
|
|
};
|
|
|
|
template <class ..._Allocs> struct __get_poc_move_assignment;
|
|
|
|
template <class _A0>
|
|
struct __get_poc_move_assignment<_A0>
|
|
{
|
|
static const bool value = allocator_traits<_A0>::
|
|
propagate_on_container_move_assignment::value;
|
|
};
|
|
|
|
template <class _A0, class ..._Allocs>
|
|
struct __get_poc_move_assignment<_A0, _Allocs...>
|
|
{
|
|
static const bool value =
|
|
allocator_traits<_A0>::propagate_on_container_move_assignment::value ||
|
|
__get_poc_move_assignment<_Allocs...>::value;
|
|
};
|
|
|
|
template <class ..._Allocs> struct __get_poc_swap;
|
|
|
|
template <class _A0>
|
|
struct __get_poc_swap<_A0>
|
|
{
|
|
static const bool value = allocator_traits<_A0>::
|
|
propagate_on_container_swap::value;
|
|
};
|
|
|
|
template <class _A0, class ..._Allocs>
|
|
struct __get_poc_swap<_A0, _Allocs...>
|
|
{
|
|
static const bool value =
|
|
allocator_traits<_A0>::propagate_on_container_swap::value ||
|
|
__get_poc_swap<_Allocs...>::value;
|
|
};
|
|
|
|
template <class ..._Allocs> struct __get_is_always_equal;
|
|
|
|
template <class _A0>
|
|
struct __get_is_always_equal<_A0>
|
|
{
|
|
static const bool value = allocator_traits<_A0>::is_always_equal::value;
|
|
};
|
|
|
|
template <class _A0, class ..._Allocs>
|
|
struct __get_is_always_equal<_A0, _Allocs...>
|
|
{
|
|
static const bool value =
|
|
allocator_traits<_A0>::is_always_equal::value &&
|
|
__get_is_always_equal<_Allocs...>::value;
|
|
};
|
|
|
|
template <class ..._Allocs>
|
|
class __scoped_allocator_storage;
|
|
|
|
template <class _OuterAlloc, class... _InnerAllocs>
|
|
class __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
|
|
: public _OuterAlloc
|
|
{
|
|
typedef _OuterAlloc outer_allocator_type;
|
|
protected:
|
|
typedef scoped_allocator_adaptor<_InnerAllocs...> inner_allocator_type;
|
|
|
|
private:
|
|
inner_allocator_type __inner_;
|
|
|
|
protected:
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__scoped_allocator_storage() _NOEXCEPT {}
|
|
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, _OuterA2>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__scoped_allocator_storage(_OuterA2&& __outerAlloc,
|
|
const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
|
|
: outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)),
|
|
__inner_(__innerAllocs...) {}
|
|
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, const _OuterA2&>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__scoped_allocator_storage(
|
|
const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
|
|
: outer_allocator_type(__other.outer_allocator()),
|
|
__inner_(__other.inner_allocator()) {}
|
|
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, _OuterA2>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__scoped_allocator_storage(
|
|
__scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
|
|
: outer_allocator_type(_VSTD::move(__other.outer_allocator())),
|
|
__inner_(_VSTD::move(__other.inner_allocator())) {}
|
|
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, _OuterA2>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__scoped_allocator_storage(_OuterA2&& __o,
|
|
const inner_allocator_type& __i) _NOEXCEPT
|
|
: outer_allocator_type(_VSTD::forward<_OuterA2>(__o)),
|
|
__inner_(__i)
|
|
{
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
inner_allocator_type& inner_allocator() _NOEXCEPT {return __inner_;}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const inner_allocator_type& inner_allocator() const _NOEXCEPT {return __inner_;}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
outer_allocator_type& outer_allocator() _NOEXCEPT
|
|
{return static_cast<outer_allocator_type&>(*this);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const outer_allocator_type& outer_allocator() const _NOEXCEPT
|
|
{return static_cast<const outer_allocator_type&>(*this);}
|
|
|
|
scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
select_on_container_copy_construction() const _NOEXCEPT
|
|
{
|
|
return scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
|
|
(
|
|
allocator_traits<outer_allocator_type>::
|
|
select_on_container_copy_construction(outer_allocator()),
|
|
allocator_traits<inner_allocator_type>::
|
|
select_on_container_copy_construction(inner_allocator())
|
|
);
|
|
}
|
|
|
|
template <class...> friend class __scoped_allocator_storage;
|
|
};
|
|
|
|
template <class _OuterAlloc>
|
|
class __scoped_allocator_storage<_OuterAlloc>
|
|
: public _OuterAlloc
|
|
{
|
|
typedef _OuterAlloc outer_allocator_type;
|
|
protected:
|
|
typedef scoped_allocator_adaptor<_OuterAlloc> inner_allocator_type;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__scoped_allocator_storage() _NOEXCEPT {}
|
|
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, _OuterA2>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__scoped_allocator_storage(_OuterA2&& __outerAlloc) _NOEXCEPT
|
|
: outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)) {}
|
|
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, const _OuterA2&>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__scoped_allocator_storage(
|
|
const __scoped_allocator_storage<_OuterA2>& __other) _NOEXCEPT
|
|
: outer_allocator_type(__other.outer_allocator()) {}
|
|
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, _OuterA2>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__scoped_allocator_storage(
|
|
__scoped_allocator_storage<_OuterA2>&& __other) _NOEXCEPT
|
|
: outer_allocator_type(_VSTD::move(__other.outer_allocator())) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
inner_allocator_type& inner_allocator() _NOEXCEPT
|
|
{return static_cast<inner_allocator_type&>(*this);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const inner_allocator_type& inner_allocator() const _NOEXCEPT
|
|
{return static_cast<const inner_allocator_type&>(*this);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
outer_allocator_type& outer_allocator() _NOEXCEPT
|
|
{return static_cast<outer_allocator_type&>(*this);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const outer_allocator_type& outer_allocator() const _NOEXCEPT
|
|
{return static_cast<const outer_allocator_type&>(*this);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
scoped_allocator_adaptor<outer_allocator_type>
|
|
select_on_container_copy_construction() const _NOEXCEPT
|
|
{return scoped_allocator_adaptor<outer_allocator_type>(
|
|
allocator_traits<outer_allocator_type>::
|
|
select_on_container_copy_construction(outer_allocator())
|
|
);}
|
|
|
|
__scoped_allocator_storage(const outer_allocator_type& __o,
|
|
const inner_allocator_type& __i) _NOEXCEPT;
|
|
|
|
template <class...> friend class __scoped_allocator_storage;
|
|
};
|
|
|
|
// __outermost
|
|
|
|
template <class _Alloc>
|
|
decltype(declval<_Alloc>().outer_allocator(), true_type())
|
|
__has_outer_allocator_test(_Alloc&& __a);
|
|
|
|
template <class _Alloc>
|
|
false_type
|
|
__has_outer_allocator_test(const volatile _Alloc& __a);
|
|
|
|
template <class _Alloc>
|
|
struct __has_outer_allocator
|
|
: public common_type
|
|
<
|
|
decltype(__has_outer_allocator_test(declval<_Alloc&>()))
|
|
>::type
|
|
{
|
|
};
|
|
|
|
template <class _Alloc, bool = __has_outer_allocator<_Alloc>::value>
|
|
struct __outermost
|
|
{
|
|
typedef _Alloc type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
type& operator()(type& __a) const _NOEXCEPT {return __a;}
|
|
};
|
|
|
|
template <class _Alloc>
|
|
struct __outermost<_Alloc, true>
|
|
{
|
|
typedef typename remove_reference
|
|
<
|
|
decltype(_VSTD::declval<_Alloc>().outer_allocator())
|
|
>::type _OuterAlloc;
|
|
typedef typename __outermost<_OuterAlloc>::type type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
type& operator()(_Alloc& __a) const _NOEXCEPT
|
|
{return __outermost<_OuterAlloc>()(__a.outer_allocator());}
|
|
};
|
|
|
|
template <class _OuterAlloc, class... _InnerAllocs>
|
|
class _LIBCPP_TEMPLATE_VIS scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
|
|
: public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
|
|
{
|
|
typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base;
|
|
typedef allocator_traits<_OuterAlloc> _OuterTraits;
|
|
public:
|
|
typedef _OuterAlloc outer_allocator_type;
|
|
typedef typename base::inner_allocator_type inner_allocator_type;
|
|
typedef typename _OuterTraits::size_type size_type;
|
|
typedef typename _OuterTraits::difference_type difference_type;
|
|
typedef typename _OuterTraits::pointer pointer;
|
|
typedef typename _OuterTraits::const_pointer const_pointer;
|
|
typedef typename _OuterTraits::void_pointer void_pointer;
|
|
typedef typename _OuterTraits::const_void_pointer const_void_pointer;
|
|
|
|
typedef integral_constant
|
|
<
|
|
bool,
|
|
__get_poc_copy_assignment<outer_allocator_type,
|
|
_InnerAllocs...>::value
|
|
> propagate_on_container_copy_assignment;
|
|
typedef integral_constant
|
|
<
|
|
bool,
|
|
__get_poc_move_assignment<outer_allocator_type,
|
|
_InnerAllocs...>::value
|
|
> propagate_on_container_move_assignment;
|
|
typedef integral_constant
|
|
<
|
|
bool,
|
|
__get_poc_swap<outer_allocator_type, _InnerAllocs...>::value
|
|
> propagate_on_container_swap;
|
|
typedef integral_constant
|
|
<
|
|
bool,
|
|
__get_is_always_equal<outer_allocator_type, _InnerAllocs...>::value
|
|
> is_always_equal;
|
|
|
|
template <class _Tp>
|
|
struct rebind
|
|
{
|
|
typedef scoped_allocator_adaptor
|
|
<
|
|
typename _OuterTraits::template rebind_alloc<_Tp>, _InnerAllocs...
|
|
> other;
|
|
};
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
scoped_allocator_adaptor() _NOEXCEPT {}
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, _OuterA2>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
scoped_allocator_adaptor(_OuterA2&& __outerAlloc,
|
|
const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
|
|
: base(_VSTD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
|
|
// scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, const _OuterA2&>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
scoped_allocator_adaptor(
|
|
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
|
|
: base(__other) {}
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, _OuterA2>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
scoped_allocator_adaptor(
|
|
scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
|
|
: base(_VSTD::move(__other)) {}
|
|
|
|
// scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default;
|
|
// scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default;
|
|
// ~scoped_allocator_adaptor() = default;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
inner_allocator_type& inner_allocator() _NOEXCEPT
|
|
{return base::inner_allocator();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const inner_allocator_type& inner_allocator() const _NOEXCEPT
|
|
{return base::inner_allocator();}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
outer_allocator_type& outer_allocator() _NOEXCEPT
|
|
{return base::outer_allocator();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const outer_allocator_type& outer_allocator() const _NOEXCEPT
|
|
{return base::outer_allocator();}
|
|
|
|
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
|
|
pointer allocate(size_type __n)
|
|
{return allocator_traits<outer_allocator_type>::
|
|
allocate(outer_allocator(), __n);}
|
|
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
|
|
pointer allocate(size_type __n, const_void_pointer __hint)
|
|
{return allocator_traits<outer_allocator_type>::
|
|
allocate(outer_allocator(), __n, __hint);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void deallocate(pointer __p, size_type __n) _NOEXCEPT
|
|
{allocator_traits<outer_allocator_type>::
|
|
deallocate(outer_allocator(), __p, __n);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_type max_size() const
|
|
{return allocator_traits<outer_allocator_type>::max_size(outer_allocator());}
|
|
|
|
template <class _Tp, class... _Args>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void construct(_Tp* __p, _Args&& ...__args)
|
|
{__construct(__uses_alloc_ctor<_Tp, inner_allocator_type&, _Args...>(),
|
|
__p, _VSTD::forward<_Args>(__args)...);}
|
|
|
|
template <class _T1, class _T2, class... _Args1, class... _Args2>
|
|
void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
|
|
tuple<_Args1...> __x, tuple<_Args2...> __y)
|
|
{
|
|
typedef __outermost<outer_allocator_type> _OM;
|
|
allocator_traits<typename _OM::type>::construct(
|
|
_OM()(outer_allocator()), __p, piecewise_construct
|
|
, __transform_tuple(
|
|
typename __uses_alloc_ctor<
|
|
_T1, inner_allocator_type&, _Args1...
|
|
>::type()
|
|
, _VSTD::move(__x)
|
|
, typename __make_tuple_indices<sizeof...(_Args1)>::type{}
|
|
)
|
|
, __transform_tuple(
|
|
typename __uses_alloc_ctor<
|
|
_T2, inner_allocator_type&, _Args2...
|
|
>::type()
|
|
, _VSTD::move(__y)
|
|
, typename __make_tuple_indices<sizeof...(_Args2)>::type{}
|
|
)
|
|
);
|
|
}
|
|
|
|
template <class _T1, class _T2>
|
|
void construct(pair<_T1, _T2>* __p)
|
|
{ construct(__p, piecewise_construct, tuple<>{}, tuple<>{}); }
|
|
|
|
template <class _T1, class _T2, class _Up, class _Vp>
|
|
void construct(pair<_T1, _T2>* __p, _Up&& __x, _Vp&& __y) {
|
|
construct(__p, piecewise_construct,
|
|
_VSTD::forward_as_tuple(_VSTD::forward<_Up>(__x)),
|
|
_VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__y)));
|
|
}
|
|
|
|
template <class _T1, class _T2, class _Up, class _Vp>
|
|
void construct(pair<_T1, _T2>* __p, const pair<_Up, _Vp>& __x) {
|
|
construct(__p, piecewise_construct,
|
|
_VSTD::forward_as_tuple(__x.first),
|
|
_VSTD::forward_as_tuple(__x.second));
|
|
}
|
|
|
|
template <class _T1, class _T2, class _Up, class _Vp>
|
|
void construct(pair<_T1, _T2>* __p, pair<_Up, _Vp>&& __x) {
|
|
construct(__p, piecewise_construct,
|
|
_VSTD::forward_as_tuple(_VSTD::forward<_Up>(__x.first)),
|
|
_VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__x.second)));
|
|
}
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void destroy(_Tp* __p)
|
|
{
|
|
typedef __outermost<outer_allocator_type> _OM;
|
|
allocator_traits<typename _OM::type>::
|
|
destroy(_OM()(outer_allocator()), __p);
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
scoped_allocator_adaptor select_on_container_copy_construction() const _NOEXCEPT
|
|
{return base::select_on_container_copy_construction();}
|
|
|
|
private:
|
|
|
|
|
|
template <class _OuterA2,
|
|
class = typename enable_if<
|
|
is_constructible<outer_allocator_type, _OuterA2>::value
|
|
>::type>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
scoped_allocator_adaptor(_OuterA2&& __o,
|
|
const inner_allocator_type& __i) _NOEXCEPT
|
|
: base(_VSTD::forward<_OuterA2>(__o), __i) {}
|
|
|
|
template <class _Tp, class... _Args>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __construct(integral_constant<int, 0>, _Tp* __p, _Args&& ...__args)
|
|
{
|
|
typedef __outermost<outer_allocator_type> _OM;
|
|
allocator_traits<typename _OM::type>::construct
|
|
(
|
|
_OM()(outer_allocator()),
|
|
__p,
|
|
_VSTD::forward<_Args>(__args)...
|
|
);
|
|
}
|
|
|
|
template <class _Tp, class... _Args>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __construct(integral_constant<int, 1>, _Tp* __p, _Args&& ...__args)
|
|
{
|
|
typedef __outermost<outer_allocator_type> _OM;
|
|
allocator_traits<typename _OM::type>::construct
|
|
(
|
|
_OM()(outer_allocator()),
|
|
__p, allocator_arg, inner_allocator(),
|
|
_VSTD::forward<_Args>(__args)...
|
|
);
|
|
}
|
|
|
|
template <class _Tp, class... _Args>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __construct(integral_constant<int, 2>, _Tp* __p, _Args&& ...__args)
|
|
{
|
|
typedef __outermost<outer_allocator_type> _OM;
|
|
allocator_traits<typename _OM::type>::construct
|
|
(
|
|
_OM()(outer_allocator()),
|
|
__p,
|
|
_VSTD::forward<_Args>(__args)...,
|
|
inner_allocator()
|
|
);
|
|
}
|
|
|
|
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, inner_allocator_type&, _Args&&...>
|
|
__transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
|
|
__tuple_indices<_Idx...>)
|
|
{
|
|
using _Tup = tuple<allocator_arg_t, inner_allocator_type&, _Args&&...>;
|
|
return _Tup(allocator_arg, inner_allocator(),
|
|
_VSTD::get<_Idx>(_VSTD::move(__t))...);
|
|
}
|
|
|
|
template <class ..._Args, size_t ..._Idx>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
tuple<_Args&&..., inner_allocator_type&>
|
|
__transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
|
|
__tuple_indices<_Idx...>)
|
|
{
|
|
using _Tup = tuple<_Args&&..., inner_allocator_type&>;
|
|
return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., inner_allocator());
|
|
}
|
|
|
|
template <class...> friend class __scoped_allocator_storage;
|
|
};
|
|
|
|
template <class _OuterA1, class _OuterA2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator==(const scoped_allocator_adaptor<_OuterA1>& __a,
|
|
const scoped_allocator_adaptor<_OuterA2>& __b) _NOEXCEPT
|
|
{
|
|
return __a.outer_allocator() == __b.outer_allocator();
|
|
}
|
|
|
|
template <class _OuterA1, class _OuterA2, class _InnerA0, class... _InnerAllocs>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator==(const scoped_allocator_adaptor<_OuterA1, _InnerA0, _InnerAllocs...>& __a,
|
|
const scoped_allocator_adaptor<_OuterA2, _InnerA0, _InnerAllocs...>& __b) _NOEXCEPT
|
|
{
|
|
return __a.outer_allocator() == __b.outer_allocator() &&
|
|
__a.inner_allocator() == __b.inner_allocator();
|
|
}
|
|
|
|
template <class _OuterA1, class _OuterA2, class... _InnerAllocs>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
|
|
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b) _NOEXCEPT
|
|
{
|
|
return !(__a == __b);
|
|
}
|
|
|
|
#endif // !defined(_LIBCPP_CXX03_LANG)
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
#endif // _LIBCPP_SCOPED_ALLOCATOR
|