-
-
Save ot/b094d58bf049cee3db99 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Allocator traits -*- C++ -*- | |
// Copyright (C) 2011-2015 Free Software Foundation, Inc. | |
// | |
// This file is part of the GNU ISO C++ Library. This library is free | |
// software; you can redistribute it and/or modify it under the | |
// terms of the GNU General Public License as published by the | |
// Free Software Foundation; either version 3, or (at your option) | |
// any later version. | |
// This library is distributed in the hope that it will be useful, | |
// but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
// GNU General Public License for more details. | |
// Under Section 7 of GPL version 3, you are granted additional | |
// permissions described in the GCC Runtime Library Exception, version | |
// 3.1, as published by the Free Software Foundation. | |
// You should have received a copy of the GNU General Public License and | |
// a copy of the GCC Runtime Library Exception along with this program; | |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
// <http://www.gnu.org/licenses/>. | |
/** @file bits/alloc_traits.h | |
* This is an internal header file, included by other library headers. | |
* Do not attempt to use it directly. @headername{memory} | |
*/ | |
#ifndef _ALLOC_TRAITS_H | |
#define _ALLOC_TRAITS_H 1 | |
#if __cplusplus >= 201103L | |
#include <bits/memoryfwd.h> | |
#include <bits/ptr_traits.h> | |
#include <ext/numeric_traits.h> | |
namespace std _GLIBCXX_VISIBILITY(default) | |
{ | |
_GLIBCXX_BEGIN_NAMESPACE_VERSION | |
template< class... > struct __voider { using type = void; }; | |
template< class... _T0toN > using __void_t = typename __voider<_T0toN...>::type; | |
/// Implementation of the detection idiom (negative case). | |
template<typename _Default, typename _AlwaysVoid, | |
template<typename...> class _Op, typename... _Args> | |
struct __detector | |
{ | |
using type = _Default; | |
}; | |
/// Implementation of the detection idiom (positive case). | |
template<typename _Default, template<typename...> class _Op, | |
typename... _Args> | |
struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> | |
{ | |
using type = _Op<_Args...>; | |
}; | |
// Detect whether _Op<_Args...> is a valid type, use _Default if not. | |
template<typename _Default, template<typename...> class _Op, | |
typename... _Args> | |
using __detected_or = __detector<_Default, void, _Op, _Args...>; | |
// _Op<_Args...> if that is a valid type, otherwise _Default. | |
template<typename _Default, template<typename...> class _Op, | |
typename... _Args> | |
using __detected_or_t | |
= typename __detected_or<_Default, _Op, _Args...>::type; | |
// _Op<_Args...> if that is a valid type, otherwise _Default<_Args...>. | |
template<template<typename...> class _Default, | |
template<typename...> class _Op, typename... _Args> | |
using __detected_or_t_ = | |
__detected_or_t<_Default<_Args...>, _Op, _Args...>; | |
class __undefined; | |
// Given Template<T, ...> and U return Template<U, ...>, otherwise invalid. | |
template<typename _Tp, typename _Up> | |
struct __replace_first_arg | |
{ using type = __undefined; }; | |
template<template<typename, typename...> class _Template, typename _Up, | |
typename _Tp, typename... _Types> | |
struct __replace_first_arg<_Template<_Tp, _Types...>, _Up> | |
{ using type = _Template<_Up, _Types...>; }; | |
template<typename _Tp, typename _Up> | |
using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type; | |
struct __allocator_traits_base | |
{ | |
template<typename _Alloc, typename _Up> | |
using __rebind = typename _Alloc::template rebind<_Up>::other; | |
protected: | |
template<typename _Tp> | |
using __pointer = typename _Tp::pointer; | |
template<typename _Tp> | |
using __c_pointer = typename _Tp::const_pointer; | |
template<typename _Tp> | |
using __v_pointer = typename _Tp::void_pointer; | |
template<typename _Tp> | |
using __cv_pointer = typename _Tp::const_void_pointer; | |
template<typename _Tp> | |
using __diff_type = typename _Tp::difference_type; | |
template<typename _Tp> | |
using __size_type = typename _Tp::size_type; | |
template<typename _Tp> | |
using __pocca = typename _Tp::propagate_on_container_copy_assignment; | |
template<typename _Tp> | |
using __pocma = typename _Tp::propagate_on_container_move_assignment; | |
template<typename _Tp> | |
using __pocs = typename _Tp::propagate_on_container_swap; | |
template<typename _Tp> | |
using __equal = typename _Tp::is_always_equal; | |
}; | |
/// Convenience alias for rebinding pointers. | |
template<typename _Ptr, typename _Tp> | |
using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; | |
template<typename _Alloc, typename _Up> | |
using __alloc_rebind = __detected_or_t_<__replace_first_arg_t, | |
__allocator_traits_base::__rebind, | |
_Alloc, _Up>; | |
template<typename _Alloc, typename _Up> | |
struct __alloctr_rebind { | |
typedef __alloc_rebind<_Alloc, _Up> __type; | |
}; | |
/** | |
* @brief Uniform interface to all allocator types. | |
* @ingroup allocators | |
*/ | |
template<typename _Alloc> | |
struct allocator_traits : __allocator_traits_base | |
{ | |
/// The allocator type | |
typedef _Alloc allocator_type; | |
/// The allocated type | |
typedef typename _Alloc::value_type value_type; | |
/** | |
* @brief The allocator's pointer type. | |
* | |
* @c Alloc::pointer if that type exists, otherwise @c value_type* | |
*/ | |
using pointer = __detected_or_t<value_type*, __pointer, _Alloc>; | |
/** | |
* @brief The allocator's const pointer type. | |
* | |
* @c Alloc::const_pointer if that type exists, otherwise | |
* <tt> pointer_traits<pointer>::rebind<const value_type> </tt> | |
*/ | |
using const_pointer | |
= __detected_or_t<__ptr_rebind<pointer, const value_type>, | |
__c_pointer, _Alloc>; | |
/** | |
* @brief The allocator's void pointer type. | |
* | |
* @c Alloc::void_pointer if that type exists, otherwise | |
* <tt> pointer_traits<pointer>::rebind<void> </tt> | |
*/ | |
using void_pointer | |
= __detected_or_t<__ptr_rebind<pointer, void>, __v_pointer, _Alloc>; | |
/** | |
* @brief The allocator's const void pointer type. | |
* | |
* @c Alloc::const_void_pointer if that type exists, otherwise | |
* <tt> pointer_traits<pointer>::rebind<const void> </tt> | |
*/ | |
using const_void_pointer | |
= __detected_or_t<__ptr_rebind<pointer, const void>, __cv_pointer, | |
_Alloc>; | |
/** | |
* @brief The allocator's difference type | |
* | |
* @c Alloc::difference_type if that type exists, otherwise | |
* <tt> pointer_traits<pointer>::difference_type </tt> | |
*/ | |
using difference_type | |
= __detected_or_t<typename pointer_traits<pointer>::difference_type, | |
__diff_type, _Alloc>; | |
/** | |
* @brief The allocator's size type | |
* | |
* @c Alloc::size_type if that type exists, otherwise | |
* <tt> make_unsigned<difference_type>::type </tt> | |
*/ | |
using size_type | |
= __detected_or_t<typename make_unsigned<difference_type>::type, | |
__size_type, _Alloc>; | |
/** | |
* @brief How the allocator is propagated on copy assignment | |
* | |
* @c Alloc::propagate_on_container_copy_assignment if that type exists, | |
* otherwise @c false_type | |
*/ | |
using propagate_on_container_copy_assignment | |
= __detected_or_t<false_type, __pocca, _Alloc>; | |
/** | |
* @brief How the allocator is propagated on move assignment | |
* | |
* @c Alloc::propagate_on_container_move_assignment if that type exists, | |
* otherwise @c false_type | |
*/ | |
using propagate_on_container_move_assignment | |
= __detected_or_t<false_type, __pocma, _Alloc>; | |
/** | |
* @brief How the allocator is propagated on swap | |
* | |
* @c Alloc::propagate_on_container_swap if that type exists, | |
* otherwise @c false_type | |
*/ | |
using propagate_on_container_swap | |
= __detected_or_t<false_type, __pocs, _Alloc>; | |
/** | |
* @brief Whether all instances of the allocator type compare equal. | |
* | |
* @c Alloc::is_always_equal if that type exists, | |
* otherwise @c is_empty<Alloc>::type | |
*/ | |
using is_always_equal | |
= __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>; | |
template<typename _Tp> | |
using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; | |
template<typename _Tp> | |
using rebind_traits = allocator_traits<rebind_alloc<_Tp>>; | |
static_assert(!is_same<rebind_alloc<value_type>, __undefined>::value, | |
"allocator defines rebind or is like Alloc<T, Args>"); | |
private: | |
template<typename _Alloc2> | |
static auto | |
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) | |
-> decltype(__a.allocate(__n, __hint)) | |
{ return __a.allocate(__n, __hint); } | |
template<typename _Alloc2> | |
static pointer | |
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) | |
{ return __a.allocate(__n); } | |
template<typename _Tp, typename... _Args> | |
struct __construct_helper | |
{ | |
template<typename _Alloc2, | |
typename = decltype(std::declval<_Alloc2*>()->construct( | |
std::declval<_Tp*>(), std::declval<_Args>()...))> | |
static true_type __test(int); | |
template<typename> | |
static false_type __test(...); | |
using type = decltype(__test<_Alloc>(0)); | |
}; | |
template<typename _Tp, typename... _Args> | |
using __has_construct | |
= typename __construct_helper<_Tp, _Args...>::type; | |
template<typename _Tp, typename... _Args> | |
static _Require<__has_construct<_Tp, _Args...>> | |
_S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) | |
{ __a.construct(__p, std::forward<_Args>(__args)...); } | |
template<typename _Tp, typename... _Args> | |
static | |
_Require<__and_<__not_<__has_construct<_Tp, _Args...>>, | |
is_constructible<_Tp, _Args...>>> | |
_S_construct(_Alloc&, _Tp* __p, _Args&&... __args) | |
{ ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); } | |
template<typename _Alloc2, typename _Tp> | |
static auto | |
_S_destroy(_Alloc2& __a, _Tp* __p, int) | |
-> decltype(__a.destroy(__p)) | |
{ __a.destroy(__p); } | |
template<typename _Alloc2, typename _Tp> | |
static void | |
_S_destroy(_Alloc2&, _Tp* __p, ...) | |
{ __p->~_Tp(); } | |
template<typename _Alloc2> | |
static auto | |
_S_max_size(_Alloc2& __a, int) | |
-> decltype(__a.max_size()) | |
{ return __a.max_size(); } | |
template<typename _Alloc2> | |
static size_type | |
_S_max_size(_Alloc2&, ...) | |
{ | |
// _GLIBCXX_RESOLVE_LIB_DEFECTS | |
// 2466. allocator_traits::max_size() default behavior is incorrect | |
return __gnu_cxx::__numeric_traits<size_type>::__max | |
/ sizeof(value_type); | |
} | |
template<typename _Alloc2> | |
static auto | |
_S_select(_Alloc2& __a, int) | |
-> decltype(__a.select_on_container_copy_construction()) | |
{ return __a.select_on_container_copy_construction(); } | |
template<typename _Alloc2> | |
static _Alloc2 | |
_S_select(_Alloc2& __a, ...) | |
{ return __a; } | |
public: | |
/** | |
* @brief Allocate memory. | |
* @param __a An allocator. | |
* @param __n The number of objects to allocate space for. | |
* | |
* Calls @c a.allocate(n) | |
*/ | |
static pointer | |
allocate(_Alloc& __a, size_type __n) | |
{ return __a.allocate(__n); } | |
/** | |
* @brief Allocate memory. | |
* @param __a An allocator. | |
* @param __n The number of objects to allocate space for. | |
* @param __hint Aid to locality. | |
* @return Memory of suitable size and alignment for @a n objects | |
* of type @c value_type | |
* | |
* Returns <tt> a.allocate(n, hint) </tt> if that expression is | |
* well-formed, otherwise returns @c a.allocate(n) | |
*/ | |
static pointer | |
allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) | |
{ return _S_allocate(__a, __n, __hint, 0); } | |
/** | |
* @brief Deallocate memory. | |
* @param __a An allocator. | |
* @param __p Pointer to the memory to deallocate. | |
* @param __n The number of objects space was allocated for. | |
* | |
* Calls <tt> a.deallocate(p, n) </tt> | |
*/ | |
static void | |
deallocate(_Alloc& __a, pointer __p, size_type __n) | |
{ __a.deallocate(__p, __n); } | |
/** | |
* @brief Construct an object of type @a _Tp | |
* @param __a An allocator. | |
* @param __p Pointer to memory of suitable size and alignment for Tp | |
* @param __args Constructor arguments. | |
* | |
* Calls <tt> __a.construct(__p, std::forward<Args>(__args)...) </tt> | |
* if that expression is well-formed, otherwise uses placement-new | |
* to construct an object of type @a _Tp at location @a __p from the | |
* arguments @a __args... | |
*/ | |
template<typename _Tp, typename... _Args> | |
static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args) | |
-> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) | |
{ _S_construct(__a, __p, std::forward<_Args>(__args)...); } | |
/** | |
* @brief Destroy an object of type @a _Tp | |
* @param __a An allocator. | |
* @param __p Pointer to the object to destroy | |
* | |
* Calls @c __a.destroy(__p) if that expression is well-formed, | |
* otherwise calls @c __p->~_Tp() | |
*/ | |
template <class _Tp> | |
static void destroy(_Alloc& __a, _Tp* __p) | |
{ _S_destroy(__a, __p, 0); } | |
/** | |
* @brief The maximum supported allocation size | |
* @param __a An allocator. | |
* @return @c __a.max_size() or @c numeric_limits<size_type>::max() | |
* | |
* Returns @c __a.max_size() if that expression is well-formed, | |
* otherwise returns @c numeric_limits<size_type>::max() | |
*/ | |
static size_type max_size(const _Alloc& __a) noexcept | |
{ return _S_max_size(__a, 0); } | |
/** | |
* @brief Obtain an allocator to use when copying a container. | |
* @param __rhs An allocator. | |
* @return @c __rhs.select_on_container_copy_construction() or @a __rhs | |
* | |
* Returns @c __rhs.select_on_container_copy_construction() if that | |
* expression is well-formed, otherwise returns @a __rhs | |
*/ | |
static _Alloc | |
select_on_container_copy_construction(const _Alloc& __rhs) | |
{ return _S_select(__rhs, 0); } | |
}; | |
template<typename _Alloc> | |
inline void | |
__do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type) | |
{ __one = __two; } | |
template<typename _Alloc> | |
inline void | |
__do_alloc_on_copy(_Alloc&, const _Alloc&, false_type) | |
{ } | |
template<typename _Alloc> | |
inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two) | |
{ | |
typedef allocator_traits<_Alloc> __traits; | |
typedef typename __traits::propagate_on_container_copy_assignment __pocca; | |
__do_alloc_on_copy(__one, __two, __pocca()); | |
} | |
template<typename _Alloc> | |
inline _Alloc __alloc_on_copy(const _Alloc& __a) | |
{ | |
typedef allocator_traits<_Alloc> __traits; | |
return __traits::select_on_container_copy_construction(__a); | |
} | |
template<typename _Alloc> | |
inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type) | |
{ __one = std::move(__two); } | |
template<typename _Alloc> | |
inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type) | |
{ } | |
template<typename _Alloc> | |
inline void __alloc_on_move(_Alloc& __one, _Alloc& __two) | |
{ | |
typedef allocator_traits<_Alloc> __traits; | |
typedef typename __traits::propagate_on_container_move_assignment __pocma; | |
__do_alloc_on_move(__one, __two, __pocma()); | |
} | |
template<typename _Alloc> | |
inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type) | |
{ | |
using std::swap; | |
swap(__one, __two); | |
} | |
template<typename _Alloc> | |
inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type) | |
{ } | |
template<typename _Alloc> | |
inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two) | |
{ | |
typedef allocator_traits<_Alloc> __traits; | |
typedef typename __traits::propagate_on_container_swap __pocs; | |
__do_alloc_on_swap(__one, __two, __pocs()); | |
} | |
template<typename _Alloc> | |
class __is_copy_insertable_impl | |
{ | |
typedef allocator_traits<_Alloc> _Traits; | |
template<typename _Up, typename | |
= decltype(_Traits::construct(std::declval<_Alloc&>(), | |
std::declval<_Up*>(), | |
std::declval<const _Up&>()))> | |
static true_type | |
_M_select(int); | |
template<typename _Up> | |
static false_type | |
_M_select(...); | |
public: | |
typedef decltype(_M_select<typename _Alloc::value_type>(0)) type; | |
}; | |
// true if _Alloc::value_type is CopyInsertable into containers using _Alloc | |
template<typename _Alloc> | |
struct __is_copy_insertable | |
: __is_copy_insertable_impl<_Alloc>::type | |
{ }; | |
// std::allocator<_Tp> just requires CopyConstructible | |
template<typename _Tp> | |
struct __is_copy_insertable<allocator<_Tp>> | |
: is_copy_constructible<_Tp> | |
{ }; | |
_GLIBCXX_END_NAMESPACE_VERSION | |
} // namespace std | |
#endif | |
#endif |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Allocators -*- C++ -*- | |
// Copyright (C) 2001-2014 Free Software Foundation, Inc. | |
// | |
// This file is part of the GNU ISO C++ Library. This library is free | |
// software; you can redistribute it and/or modify it under the | |
// terms of the GNU General Public License as published by the | |
// Free Software Foundation; either version 3, or (at your option) | |
// any later version. | |
// This library is distributed in the hope that it will be useful, | |
// but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
// GNU General Public License for more details. | |
// Under Section 7 of GPL version 3, you are granted additional | |
// permissions described in the GCC Runtime Library Exception, version | |
// 3.1, as published by the Free Software Foundation. | |
// You should have received a copy of the GNU General Public License and | |
// a copy of the GCC Runtime Library Exception along with this program; | |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
// <http://www.gnu.org/licenses/>. | |
/* | |
* Copyright (c) 1996-1997 | |
* Silicon Graphics Computer Systems, Inc. | |
* | |
* Permission to use, copy, modify, distribute and sell this software | |
* and its documentation for any purpose is hereby granted without fee, | |
* provided that the above copyright notice appear in all copies and | |
* that both that copyright notice and this permission notice appear | |
* in supporting documentation. Silicon Graphics makes no | |
* representations about the suitability of this software for any | |
* purpose. It is provided "as is" without express or implied warranty. | |
*/ | |
/** @file bits/allocator.h | |
* This is an internal header file, included by other library headers. | |
* Do not attempt to use it directly. @headername{memory} | |
*/ | |
#ifndef _ALLOCATOR_H | |
#define _ALLOCATOR_H 1 | |
#include <bits/c++allocator.h> // Define the base class to std::allocator. | |
#include <bits/memoryfwd.h> | |
#if __cplusplus >= 201103L | |
#include <type_traits> | |
#include <bits/alloc_traits.h> | |
#endif | |
namespace std _GLIBCXX_VISIBILITY(default) | |
{ | |
_GLIBCXX_BEGIN_NAMESPACE_VERSION | |
/** | |
* @addtogroup allocators | |
* @{ | |
*/ | |
/// allocator<void> specialization. | |
template<> | |
class allocator<void> | |
{ | |
public: | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef void* pointer; | |
typedef const void* const_pointer; | |
typedef void value_type; | |
template<typename _Tp1> | |
struct rebind | |
{ typedef allocator<_Tp1> other; }; | |
#if __cplusplus >= 201103L | |
// _GLIBCXX_RESOLVE_LIB_DEFECTS | |
// 2103. std::allocator propagate_on_container_move_assignment | |
typedef true_type propagate_on_container_move_assignment; | |
#endif | |
}; | |
/** | |
* @brief The @a standard allocator, as per [20.4]. | |
* | |
* See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html | |
* for further details. | |
* | |
* @tparam _Tp Type of allocated object. | |
*/ | |
template<typename _Tp> | |
class allocator: public __allocator_base<_Tp> | |
{ | |
public: | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef _Tp* pointer; | |
typedef const _Tp* const_pointer; | |
typedef _Tp value_type; | |
typedef _Tp& reference; | |
typedef const _Tp& const_reference; | |
template<typename _Tp1> | |
struct rebind | |
{ typedef allocator<_Tp1> other; }; | |
#if __cplusplus >= 201103L | |
// _GLIBCXX_RESOLVE_LIB_DEFECTS | |
// 2103. std::allocator propagate_on_container_move_assignment | |
typedef true_type propagate_on_container_move_assignment; | |
#endif | |
allocator() throw() { } | |
allocator(const allocator& __a) throw() | |
: __allocator_base<_Tp>(__a) { } | |
template<typename _Tp1> | |
allocator(const allocator<_Tp1>&) throw() { } | |
~allocator() throw() { } | |
// Inherit everything else. | |
}; | |
template<typename _T1, typename _T2> | |
inline bool | |
operator==(const allocator<_T1>&, const allocator<_T2>&) | |
{ return true; } | |
template<typename _Tp> | |
inline bool | |
operator==(const allocator<_Tp>&, const allocator<_Tp>&) | |
{ return true; } | |
template<typename _T1, typename _T2> | |
inline bool | |
operator!=(const allocator<_T1>&, const allocator<_T2>&) | |
{ return false; } | |
template<typename _Tp> | |
inline bool | |
operator!=(const allocator<_Tp>&, const allocator<_Tp>&) | |
{ return false; } | |
/// @} group allocator | |
// Inhibit implicit instantiations for required instantiations, | |
// which are defined via explicit instantiations elsewhere. | |
#if _GLIBCXX_EXTERN_TEMPLATE | |
extern template class allocator<char>; | |
extern template class allocator<wchar_t>; | |
#endif | |
// Undefine. | |
#undef __allocator_base | |
// To implement Option 3 of DR 431. | |
template<typename _Alloc, bool = __is_empty(_Alloc)> | |
struct __alloc_swap | |
{ static void _S_do_it(_Alloc&, _Alloc&) _GLIBCXX_NOEXCEPT { } }; | |
template<typename _Alloc> | |
struct __alloc_swap<_Alloc, false> | |
{ | |
static void | |
_S_do_it(_Alloc& __one, _Alloc& __two) _GLIBCXX_NOEXCEPT | |
{ | |
// Precondition: swappable allocators. | |
if (__one != __two) | |
swap(__one, __two); | |
} | |
}; | |
// Optimize for stateless allocators. | |
template<typename _Alloc, bool = __is_empty(_Alloc)> | |
struct __alloc_neq | |
{ | |
static bool | |
_S_do_it(const _Alloc&, const _Alloc&) | |
{ return false; } | |
}; | |
template<typename _Alloc> | |
struct __alloc_neq<_Alloc, false> | |
{ | |
static bool | |
_S_do_it(const _Alloc& __one, const _Alloc& __two) | |
{ return __one != __two; } | |
}; | |
#if __cplusplus >= 201103L | |
template<typename _Tp, bool | |
= __or_<is_copy_constructible<typename _Tp::value_type>, | |
is_nothrow_move_constructible<typename _Tp::value_type>>::value> | |
struct __shrink_to_fit_aux | |
{ static bool _S_do_it(_Tp&) noexcept { return false; } }; | |
template<typename _Tp> | |
struct __shrink_to_fit_aux<_Tp, true> | |
{ | |
static bool | |
_S_do_it(_Tp& __c) noexcept | |
{ | |
__try | |
{ | |
_Tp(__make_move_if_noexcept_iterator(__c.begin()), | |
__make_move_if_noexcept_iterator(__c.end()), | |
__c.get_allocator()).swap(__c); | |
return true; | |
} | |
__catch(...) | |
{ return false; } | |
} | |
}; | |
#endif | |
#if __cplusplus >= 201103L | |
template<typename _Tp> | |
struct allocator_traits<allocator<_Tp>> { | |
typedef allocator<_Tp> allocator_type; | |
typedef typename allocator_type::size_type size_type; | |
typedef typename allocator_type::difference_type difference_type; | |
typedef typename allocator_type::value_type value_type; | |
typedef typename allocator_type::pointer pointer; | |
typedef typename allocator_type::const_pointer const_pointer; | |
typedef void* void_pointer; | |
typedef const void* const_void_pointer; | |
using propagate_on_container_copy_assignment = false_type; | |
using propagate_on_container_move_assignment = true_type; | |
using propagate_on_container_swap = false_type; | |
using is_always_equal = true_type; | |
template<typename _Tp1> | |
using rebind_alloc = typename allocator_type::template rebind<_Tp1>::other; | |
template<typename _Tp1> | |
using rebind_traits = allocator_traits<rebind_alloc<_Tp1>>; | |
static pointer | |
allocate(allocator_type& __a, size_type __n) | |
{ return __a.allocate(__n); } | |
static pointer | |
allocate(allocator_type& __a, size_type __n, const_void_pointer) | |
{ return __a.allocate(__n); } | |
static void | |
deallocate(allocator_type& __a, pointer __p, size_type __n) | |
{ __a.deallocate(__p, __n); } | |
template<typename _Tp1, typename... _Args> | |
static void construct(allocator_type& __a, _Tp1* __p, _Args&&... __args) | |
{ __a.construct(__p, std::forward<_Args>(__args)...); } | |
template <class _Tp1> | |
static void destroy(allocator_type& __a, _Tp1* __p) | |
{ __a.destroy(__p); } | |
static size_type max_size(const allocator_type& __a) noexcept | |
{ return __a.max_size(); } | |
static allocator_type | |
select_on_container_copy_construction(const allocator_type& __rhs) | |
{ return __rhs; } | |
}; | |
#endif | |
_GLIBCXX_END_NAMESPACE_VERSION | |
} // namespace std | |
#endif |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment