boost_mirror/core
1
0
Fork 0
mirror of https://github.com/boostorg/core.git synced 2025-05-09 23:03:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revise allocator_access implementation

Browse Source
This commit is contained in:
Glen Fernandes 2020-05-25 15:00:18 -04:00
parent 65901249d5
commit 376aa7aa31
22 changed files with 562 additions and 582 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
doc/allocator_access.qbk
View File

@ -21,9 +21,8 @@ templates to simplify allocator use. It provides the same functionality as the
C++ standard library `std::allocator_traits` but with individual templates for
each allocator feature.
This implementation supports C++03 and above. These facilities also simplify
existing libraries by avoiding having to check for `BOOST_NO_CXX11_ALLOCATOR`
and conditionally use `std::allocator_traits`.
These facilities also simplify existing libraries by avoiding having to check
for `BOOST_NO_CXX11_ALLOCATOR` and conditionally use `std::allocator_traits`.
[endsect]
@ -142,14 +141,14 @@ allocator_pointer_t<A> allocator_allocate(A& a, allocator_size_type_t<A> n);
template<class A>
allocator_pointer_t<A> allocator_allocate(A& a, allocator_size_type_t<A> n,
allocator_const_void_pointer_t<A> hint);
allocator_const_void_pointer_t<A> h);
template<class A>
void allocator_deallocate(A& a, allocator_pointer_t<A> p,
allocator_size_type_t<A> n);
template<class A, class T, class... Args>
void allocator_construct(A& a, T*p, Args&&... args);
void allocator_construct(A& a, T* p, Args&&... args);
template<class A, class T>
void allocator_destroy(A& a, T* p);

628
include/boost/core/allocator_access.hpp
View File

@ -8,40 +8,53 @@ Distributed under the Boost Software License, Version 1.0.
#ifndef BOOST_CORE_ALLOCATOR_ACCESS_HPP
#define BOOST_CORE_ALLOCATOR_ACCESS_HPP
#include <boost/config.hpp>
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
#include <boost/core/pointer_traits.hpp>
#if !defined(BOOST_MSVC)
#include <limits>
#if defined(BOOST_DINKUMWARE_STDLIB)
#else
#include <memory>
#endif
#include <new>
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
#include <type_traits>
#endif
#include <new>
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#include <utility>
#endif
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) || \
defined(BOOST_MSVC) && BOOST_MSVC == 1800
#define BOOST_CORE_ALLOCATOR_DETECTION
namespace boost {
namespace detail {
#if defined(BOOST_NO_CXX11_ALLOCATOR)
struct alloc_false {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#else
template<class>
struct alloc_void {
typedef void type;
};
#endif
namespace boost {
} /* detail */
template<class A>
struct allocator_value_type {
typedef typename A::value_type type;
};
namespace detail {
template<class>
struct alloc_void {
typedef void type;
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
struct allocator_pointer {
typedef typename A::pointer type;
};
} /* detail */
#elif defined(BOOST_MSVC)
template<class A>
struct allocator_pointer {
typedef typename std::allocator_traits<A>::pointer type;
};
#else
template<class A, class = void>
struct allocator_pointer {
typedef typename A::value_type* type;
@ -52,7 +65,19 @@ struct allocator_pointer<A,
typename detail::alloc_void<typename A::pointer>::type> {
typedef typename A::pointer type;
};
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
struct allocator_const_pointer {
typedef typename A::const_pointer type;
};
#elif defined(BOOST_MSVC)
template<class A>
struct allocator_const_pointer {
typedef typename std::allocator_traits<A>::const_pointer type;
};
#else
template<class A, class = void>
struct allocator_const_pointer {
typedef typename pointer_traits<typename
@ -65,7 +90,14 @@ struct allocator_const_pointer<A,
typename detail::alloc_void<typename A::const_pointer>::type> {
typedef typename A::const_pointer type;
};
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
struct allocator_void_pointer {
typedef typename A::template rebind<void>::other::pointer type;
};
#else
template<class A, class = void>
struct allocator_void_pointer {
typedef typename pointer_traits<typename
@ -78,7 +110,14 @@ struct allocator_void_pointer<A,
typename detail::alloc_void<typename A::void_pointer>::type> {
typedef typename A::void_pointer type;
};
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
struct allocator_const_void_pointer {
typedef typename A::template rebind<void>::other::const_pointer type;
};
#else
template<class A, class = void>
struct allocator_const_void_pointer {
typedef typename pointer_traits<typename
@ -91,7 +130,14 @@ struct allocator_const_void_pointer<A,
typename detail::alloc_void<typename A::const_void_pointer>::type> {
typedef typename A::const_void_pointer type;
};
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
struct allocator_difference_type {
typedef typename A::difference_type type;
};
#else
template<class A, class = void>
struct allocator_difference_type {
typedef typename pointer_traits<typename
@ -103,8 +149,14 @@ struct allocator_difference_type<A,
typename detail::alloc_void<typename A::difference_type>::type> {
typedef typename A::difference_type type;
};
#endif
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
struct allocator_size_type {
typedef typename A::size_type type;
};
#else
template<class A, class = void>
struct allocator_size_type {
typedef typename std::make_unsigned<typename
@ -116,28 +168,17 @@ struct allocator_size_type<A,
typename detail::alloc_void<typename A::size_type>::type> {
typedef typename A::size_type type;
};
#else
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
struct allocator_size_type {
typedef typename A::size_type type;
struct allocator_propagate_on_container_copy_assignment {
typedef detail::alloc_false type;
};
#endif
namespace detail {
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
typedef std::false_type alloc_false_type;
#else
struct alloc_false_type {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#endif
} /* detail */
template<class A, class = void>
struct allocator_propagate_on_container_copy_assignment {
typedef detail::alloc_false_type type;
typedef std::false_type type;
};
template<class A>
@ -146,10 +187,17 @@ struct allocator_propagate_on_container_copy_assignment<A,
A::propagate_on_container_copy_assignment>::type> {
typedef typename A::propagate_on_container_copy_assignment type;
};
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
struct allocator_propagate_on_container_move_assignment {
typedef detail::alloc_false type;
};
#else
template<class A, class = void>
struct allocator_propagate_on_container_move_assignment {
typedef detail::alloc_false_type type;
typedef std::false_type type;
};
template<class A>
@ -158,10 +206,17 @@ struct allocator_propagate_on_container_move_assignment<A,
A::propagate_on_container_move_assignment>::type> {
typedef typename A::propagate_on_container_move_assignment type;
};
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
struct allocator_propagate_on_container_swap {
typedef detail::alloc_false type;
};
#else
template<class A, class = void>
struct allocator_propagate_on_container_swap {
typedef detail::alloc_false_type type;
typedef std::false_type type;
};
template<class A>
@ -170,52 +225,46 @@ struct allocator_propagate_on_container_swap<A,
A::propagate_on_container_swap>::type> {
typedef typename A::propagate_on_container_swap type;
};
#endif
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
template<class A, class = void>
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
struct allocator_is_always_equal {
typedef typename std::is_empty<A>::type type;
typedef detail::alloc_false type;
};
#else
template<class A, class = void>
struct allocator_is_always_equal {
typedef typename detail::alloc_false_type type;
typedef typename std::is_empty<A>::type type;
};
#endif
template<class A>
struct allocator_is_always_equal<A,
typename detail::alloc_void<typename A::is_always_equal>::type> {
typedef typename A::is_always_equal type;
};
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A, class T>
struct allocator_rebind {
typedef typename A::template rebind<T>::other type;
};
#elif defined(BOOST_MSVC)
template<class A, class T>
struct allocator_rebind {
typedef typename std::allocator_traits<A>::template rebind_alloc<T> type;
};
#else
namespace detail {
template<class, class>
struct alloc_to { };
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<template<class, class...> class A, class T, class U, class... V>
struct alloc_to<A<U, V...>, T> {
typedef A<T, V...> type;
};
#else
template<template<class> class A, class T, class U>
struct alloc_to<A<U>, T> {
typedef A<T> type;
};
template<template<class, class> class A, class T, class U1, class U2>
struct alloc_to<A<U1, U2>, T> {
typedef A<T, U2> type;
};
template<template<class, class, class> class A, class T, class U1, class U2,
class U3>
struct alloc_to<A<U1, U2, U3>, T> {
typedef A<T, U2, U3> type;
};
#endif
} /* detail */
@ -229,6 +278,7 @@ struct allocator_rebind<A, T,
typename detail::alloc_void<typename A::template rebind<T>::other>::type> {
typedef typename A::template rebind<T>::other type;
};
#endif
template<class A>
inline typename allocator_pointer<A>::type
@ -237,98 +287,6 @@ allocator_allocate(A& a, typename allocator_size_type<A>::type n)
return a.allocate(n);
}
namespace detail {
template<bool, class = void>
struct alloc_if { };
template<class R>
struct alloc_if<true, R> {
typedef R type;
};
template<class>
struct alloc_enable {
BOOST_STATIC_CONSTEXPR bool value = true;
};
#if defined(BOOST_DINKUMWARE_STDLIB)
template<class T>
struct alloc_enable<std::allocator<T> > {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#endif
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
template<class T>
T alloc_declval() BOOST_NOEXCEPT;
#endif
#if defined(BOOST_MSVC) && BOOST_MSVC == 1800
template<class>
struct alloc_yes {
BOOST_STATIC_CONSTEXPR bool value = true;
};
struct alloc_no {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#endif
template<class, class, class, class = void>
struct alloc_has_allocate {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
template<class A, class N, class H>
struct alloc_has_allocate<A, N, H,
decltype(alloc_declval<A&>().allocate(alloc_declval<N>(),
alloc_declval<H>()), void())> {
BOOST_STATIC_CONSTEXPR bool value = true;
};
#elif defined(BOOST_MSVC) && BOOST_MSVC == 1800
template<class A, class N, class H>
struct alloc_has_allocate<A, N, H, void> {
private:
template<class U>
static auto call(int, U& a) ->
alloc_yes<decltype(a.allocate(alloc_declval<N>(),
alloc_declval<H>()))>;
template<class U>
static alloc_no call(long, U&);
public:
BOOST_STATIC_CONSTEXPR bool value = decltype(call(0,
alloc_declval<A&>()))::value;
};
#endif
} /* detail */
template<class A>
inline typename detail::alloc_if<detail::alloc_enable<A>::value &&
detail::alloc_has_allocate<A, typename allocator_size_type<A>::type,
typename allocator_const_void_pointer<A>::type>::value,
typename allocator_pointer<A>::type>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n,
typename allocator_const_void_pointer<A>::type h)
{
return a.allocate(n, h);
}
template<class A>
inline typename detail::alloc_if<!detail::alloc_enable<A>::value ||
!detail::alloc_has_allocate<A, typename allocator_size_type<A>::type,
typename allocator_const_void_pointer<A>::type>::value,
typename allocator_pointer<A>::type>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n,
typename allocator_const_void_pointer<A>::type)
{
return a.allocate(n);
}
template<class A>
inline void
allocator_deallocate(A& a, typename allocator_pointer<A>::type p,
@ -337,191 +295,158 @@ allocator_deallocate(A& a, typename allocator_pointer<A>::type p,
a.deallocate(p, n);
}
namespace detail {
template<class, class, class = void>
struct alloc_has_construct {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
template<class A, class T>
struct alloc_has_construct<A, T,
decltype(alloc_declval<A&>().construct(alloc_declval<T*>()), void())> {
BOOST_STATIC_CONSTEXPR bool value = true;
};
#elif defined(BOOST_MSVC) && BOOST_MSVC == 1800
template<class A, class T>
struct alloc_has_construct<A, T, void> {
private:
template<class U>
static auto call(int, U& a) ->
alloc_yes<decltype(a.construct(alloc_declval<T*>()))>;
template<class U>
static alloc_no call(long, U&);
public:
BOOST_STATIC_CONSTEXPR bool value = decltype(call(0,
alloc_declval<A&>()))::value;
};
#endif
} /* detail */
template<class A, class T>
inline typename detail::alloc_if<detail::alloc_enable<A>::value &&
detail::alloc_has_construct<A, T>::value>::type
allocator_construct(A& a, T* p)
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
inline typename allocator_pointer<A>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n,
typename allocator_const_void_pointer<A>::type h)
{
a.construct(p);
return a.allocate(n, h);
}
template<class A, class T>
inline typename detail::alloc_if<!detail::alloc_enable<A>::value ||
!detail::alloc_has_construct<A, T>::value>::type
allocator_construct(A&, T* p)
#elif defined(BOOST_MSVC)
template<class A>
inline typename allocator_pointer<A>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n,
typename allocator_const_void_pointer<A>::type h)
{
::new((void*)p) T();
}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
namespace detail {
template<class, class, class, class...>
struct alloc_has_construct_args {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
template<class A, class T, class... Args>
struct alloc_has_construct_args<decltype(alloc_declval<A
&>().construct(alloc_declval<T*>(), alloc_declval<Args&&>()...), void()),
A, T, Args...> {
BOOST_STATIC_CONSTEXPR bool value = true;
};
#elif defined(BOOST_MSVC) && BOOST_MSVC == 1800
template<class A, class T, class... Args>
struct alloc_has_construct_args<void, A, T, Args...> {
private:
template<class U>
static auto call(int, U& a) ->
alloc_yes<decltype(a.construct(alloc_declval<T*>(),
alloc_declval<Args&&>()...))>;
template<class U>
static alloc_no call(long, U&);
public:
BOOST_STATIC_CONSTEXPR bool value = decltype(call(0,
alloc_declval<A&>()))::value;
};
#endif
} /* detail */
template<class A, class T, class V, class... Args>
inline typename detail::alloc_if<detail::alloc_enable<A>::value &&
detail::alloc_has_construct_args<void, A, T, V, Args...>::value>::type
allocator_construct(A& a, T* p, V&& v, Args&&... args)
{
a.construct(p, std::forward<V>(v), std::forward<Args>(args)...);
}
template<class A, class T, class V, class... Args>
inline typename detail::alloc_if<!detail::alloc_enable<A>::value ||
!detail::alloc_has_construct_args<void, A, T, V, Args...>::value>::type
allocator_construct(A&, T* p, V&& v, Args&&... args)
{
::new((void*)p) T(std::forward<V>(v), std::forward<Args>(args)...);
return std::allocator_traits<A>::allocate(a, n, h);
}
#else
namespace detail {
template<class, class, class, class = void>
struct alloc_has_construct_arg {
struct alloc_has_allocate {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
template<class A, class T, class V>
struct alloc_has_construct_arg<A, T, V,
decltype(alloc_declval<A&>().construct(alloc_declval<T*>(),
alloc_declval<V>()), void())> {
template<class A, class N, class H>
struct alloc_has_allocate<A, N, H,
typename alloc_void<decltype(std::declval<A&>().allocate(std::declval<N>(),
std::declval<H>()))>::type> {
BOOST_STATIC_CONSTEXPR bool value = true;
};
#elif defined(BOOST_MSVC) && BOOST_MSVC == 1800
template<class A, class T, class V>
struct alloc_has_construct_arg<A, T, V, void> {
private:
template<class U>
static auto call(int, U& a) ->
alloc_yes<decltype(a.construct(alloc_declval<T*>(),
alloc_declval<V>()))>;
template<class U>
static alloc_no call(long, U&);
public:
BOOST_STATIC_CONSTEXPR bool value = decltype(call(0,
alloc_declval<A&>()))::value;
};
#endif
} /* detail */
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template<class A, class T, class V>
inline typename detail::alloc_if<detail::alloc_enable<A>::value &&
detail::alloc_has_construct_arg<A, T, V&&>::value>::type
allocator_construct(A& a, T* p, V&& v)
template<class A>
inline typename std::enable_if<detail::alloc_has_allocate<A,
typename allocator_size_type<A>::type,
typename allocator_const_void_pointer<A>::type>::value,
typename allocator_pointer<A>::type>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n,
typename allocator_const_void_pointer<A>::type h)
{
a.construct(p, std::forward<V>(v));
return a.allocate(n, h);
}
template<class A>
inline typename std::enable_if<!detail::alloc_has_allocate<A,
typename allocator_size_type<A>::type,
typename allocator_const_void_pointer<A>::type>::value,
typename allocator_pointer<A>::type>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n,
typename allocator_const_void_pointer<A>::type)
{
return a.allocate(n);
}
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A, class T>
inline void
allocator_construct(A&, T* p)
{
::new((void*)p) T();
}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<class A, class T, class V, class... Args>
inline void
allocator_construct(A&, T* p, V&& v, Args&&... args)
{
::new((void*)p) T(std::forward<V>(v), std::forward<Args>(args)...);
}
#else
template<class A, class T, class V>
inline typename detail::alloc_if<!detail::alloc_enable<A>::value ||
!detail::alloc_has_construct_arg<A, T, V&&>::value>::type
inline void
allocator_construct(A&, T* p, V&& v)
{
::new((void*)p) T(std::forward<V>(v));
}
#endif
#else
template<class A, class T, class V>
inline typename detail::alloc_if<detail::alloc_enable<A>::value &&
detail::alloc_has_construct_arg<A, T, const V&>::value>::type
allocator_construct(A& a, T* p, const V& v)
{
a.construct(p, v);
}
template<class A, class T, class V>
inline typename detail::alloc_if<!detail::alloc_enable<A>::value ||
!detail::alloc_has_construct_arg<A, T, const V&>::value>::type
inline void
allocator_construct(A&, T* p, const V& v)
{
::new((void*)p) T(v);
}
template<class A, class T, class V>
inline typename detail::alloc_if<detail::alloc_enable<A>::value &&
detail::alloc_has_construct_arg<A, T, V&>::value>::type
allocator_construct(A& a, T* p, V& v)
{
a.construct(p, v);
}
template<class A, class T, class V>
inline typename detail::alloc_if<!detail::alloc_enable<A>::value ||
!detail::alloc_has_construct_arg<A, T, V&>::value>::type
inline void
allocator_construct(A&, T* p, V& v)
{
::new((void*)p) T(v);
}
#endif
#elif defined(BOOST_MSVC)
template<class A, class T, class... Args>
inline void
allocator_construct(A& a, T* p, Args&&... args)
{
std::allocator_traits<A>::construct(a, p, std::forward<Args>(args)...);
}
#else
namespace detail {
template<class, class, class, class...>
struct alloc_has_construct {
BOOST_STATIC_CONSTEXPR bool value = false;
};
template<class A, class T, class... Args>
struct alloc_has_construct<typename alloc_void<decltype(std::declval<A
&>().construct(std::declval<T*>(), std::declval<Args&&>()...))>::type,
A, T, Args...> {
BOOST_STATIC_CONSTEXPR bool value = true;
};
} /* detail */
template<class A, class T, class... Args>
inline typename std::enable_if<detail::alloc_has_construct<void, A, T,
Args...>::value>::type
allocator_construct(A& a, T* p, Args&&... args)
{
a.construct(p, std::forward<Args>(args)...);
}
template<class A, class T, class... Args>
inline typename std::enable_if<!detail::alloc_has_construct<void, A, T,
Args...>::value>::type
allocator_construct(A&, T* p, Args&&... args)
{
::new((void*)p) T(std::forward<Args>(args)...);
}
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A, class T>
inline void
allocator_destroy(A&, T* p)
{
p->~T();
(void)p;
}
#elif defined(BOOST_MSVC)
template<class A, class T>
inline void
allocator_destroy(A& a, T* p)
{
std::allocator_traits<A>::destroy(a, p);
}
#else
namespace detail {
template<class, class, class = void>
@ -529,48 +454,46 @@ struct alloc_has_destroy {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
template<class A, class T>
struct alloc_has_destroy<A, T,
decltype(alloc_declval<A&>().destroy(alloc_declval<T*>()), void())> {
typename alloc_void<decltype(std::declval<A
&>().destroy(std::declval<T*>()))>::type> {
BOOST_STATIC_CONSTEXPR bool value = true;
};
#elif defined(BOOST_MSVC) && BOOST_MSVC == 1800
template<class A, class T>
struct alloc_has_destroy<A, T, void> {
private:
template<class U>
static auto call(int, U& a) ->
alloc_yes<decltype(a.destroy(alloc_declval<T*>()))>;
template<class U>
static alloc_no call(long, U&);
public:
BOOST_STATIC_CONSTEXPR bool value = decltype(call(0,
alloc_declval<A&>()))::value;
};
#endif
} /* detail */
template<class A, class T>
inline typename detail::alloc_if<detail::alloc_enable<A>::value &&
detail::alloc_has_destroy<A, T>::value>::type
inline typename std::enable_if<detail::alloc_has_destroy<A, T>::value>::type
allocator_destroy(A& a, T* p)
{
a.destroy(p);
}
template<class A, class T>
inline typename detail::alloc_if<!detail::alloc_enable<A>::value ||
!detail::alloc_has_destroy<A, T>::value>::type
inline typename std::enable_if<!detail::alloc_has_destroy<A, T>::value>::type
allocator_destroy(A&, T* p)
{
p->~T();
(void)p;
}
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
inline typename allocator_size_type<A>::type
allocator_max_size(const A& a)
{
return a.max_size();
}
#elif defined(BOOST_MSVC)
template<class A>
inline typename allocator_size_type<A>::type
allocator_max_size(const A& a)
{
return std::allocator_traits<A>::max_size(a);
}
#else
namespace detail {
template<class, class = void>
@ -578,33 +501,17 @@ struct alloc_has_max_size {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
template<class A>
struct alloc_has_max_size<A,
decltype(alloc_declval<const A&>().max_size(), void())> {
typename alloc_void<decltype(std::declval<const
A&>().max_size())>::type> {
BOOST_STATIC_CONSTEXPR bool value = true;
};
#elif defined(BOOST_MSVC) && BOOST_MSVC == 1800
template<class A>
struct alloc_has_max_size<A, void> {
private:
template<class U>
static auto call(int, const U& a) -> alloc_yes<decltype(a.max_size())>;
template<class U>
static alloc_no call(long, const U&);
public:
BOOST_STATIC_CONSTEXPR bool value = decltype(call(0,
alloc_declval<const A&>()))::value;
};
#endif
} /* detail */
template<class A>
inline typename detail::alloc_if<detail::alloc_enable<A>::value &&
detail::alloc_has_max_size<A>::value,
inline typename std::enable_if<detail::alloc_has_max_size<A>::value,
typename allocator_size_type<A>::type>::type
allocator_max_size(const A& a)
{
@ -612,15 +519,30 @@ allocator_max_size(const A& a)
}
template<class A>
inline typename detail::alloc_if<!detail::alloc_enable<A>::value ||
!detail::alloc_has_max_size<A>::value,
inline typename std::enable_if<!detail::alloc_has_max_size<A>::value,
typename allocator_size_type<A>::type>::type
allocator_max_size(const A&)
{
return (std::numeric_limits<typename
allocator_size_type<A>::type>::max)() / sizeof(typename A::value_type);
}
#endif
#if defined(BOOST_NO_CXX11_ALLOCATOR)
template<class A>
inline A
allocator_select_on_container_copy_construction(const A& a)
{
return a;
}
#elif defined(BOOST_MSVC)
template<class A>
inline A
allocator_select_on_container_copy_construction(const A& a)
{
return std::allocator_traits<A>::select_on_container_copy_construction(a);
}
#else
namespace detail {
template<class, class = void>
@ -628,47 +550,29 @@ struct alloc_has_soccc {
BOOST_STATIC_CONSTEXPR bool value = false;
};
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
template<class A>
struct alloc_has_soccc<A,
decltype(alloc_declval<const A&>().select_on_container_copy_construction(),
void())> {
typename alloc_void<decltype(std::declval<const
A&>().select_on_container_copy_construction())>::type> {
BOOST_STATIC_CONSTEXPR bool value = true;
};
#elif defined(BOOST_MSVC) && BOOST_MSVC == 1800
template<class A>
struct alloc_has_soccc<A, void> {
private:
template<class U>
static auto call(int, const U& a) ->
alloc_yes<decltype(a.select_on_container_copy_construction())>;
template<class U>
static alloc_no call(long, const U&);
public:
BOOST_STATIC_CONSTEXPR bool value = decltype(call(0,
alloc_declval<const A&>()))::value;
};
#endif
} /* detail */
template<class A>
inline typename detail::alloc_if<detail::alloc_enable<A>::value &&
detail::alloc_has_soccc<A>::value, A>::type
inline typename std::enable_if<detail::alloc_has_soccc<A>::value, A>::type
allocator_select_on_container_copy_construction(const A& a)
{
return a.select_on_container_copy_construction();
}
template<class A>
inline typename detail::alloc_if<!detail::alloc_enable<A>::value ||
!detail::alloc_has_soccc<A>::value, A>::type
inline typename std::enable_if<!detail::alloc_has_soccc<A>::value, A>::type
allocator_select_on_container_copy_construction(const A& a)
{
return a;
}
#endif
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
template<class A>

2
test/alloc_construct_cxx11_test.cpp
View File

@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#include <boost/config.hpp>
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
#include <boost/core/alloc_construct.hpp>
#include <boost/core/lightweight_test.hpp>

52
test/allocator_allocate_hint_test.cpp
View File

@ -8,53 +8,51 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/allocator_access.hpp>
#include <boost/core/lightweight_test.hpp>
template<class T>
struct A1 {
typedef int* pointer;
typedef int size_type;
typedef T value_type;
typedef std::size_t size_type;
typedef T* pointer;
typedef const T* const_pointer;
template<class U>
struct rebind {
typedef A1<U> other;
};
A1()
: value() { }
pointer allocate(size_type n) {
T* allocate(std::size_t n, const void*) {
value = n;
return &value;
return 0;
}
size_type value;
std::size_t value;
};
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef int* pointer;
typedef int size_type;
typedef T value_type;
A2()
: value() { }
pointer allocate(size_type n) {
T* allocate(std::size_t n) {
value = n;
return &value;
return 0;
}
pointer allocate(size_type n, const void*) {
value = n + 1;
return &value;
}
size_type value;
std::size_t value;
};
#endif
int main()
{
{
A1 a;
BOOST_TEST_EQ(*boost::allocator_allocate(a, 1, 0), 1);
A1<int> a;
BOOST_TEST_NOT(boost::allocator_allocate(a, 5, 0));
BOOST_TEST_EQ(a.value, 5);
}
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
{
A2 a;
BOOST_TEST_EQ(*boost::allocator_allocate(a, 1, 0), 2);
A2<int> a;
BOOST_TEST_NOT(boost::allocator_allocate(a, 5, 0));
BOOST_TEST_EQ(a.value, 5);
}
#endif
return boost::report_errors();

20
test/allocator_allocate_test.cpp
View File

@ -8,24 +8,24 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/allocator_access.hpp>
#include <boost/core/lightweight_test.hpp>
template<class T>
struct A {
typedef int* pointer;
typedef int size_type;
typedef T value_type;
typedef T* pointer;
typedef std::size_t size_type;
A()
: value() { }
pointer allocate(size_type n) {
T* allocate(std::size_t n) {
value = n;
return &value;
return 0;
}
size_type value;
std::size_t value;
};
int main()
{
A a;
BOOST_TEST_EQ(*boost::allocator_allocate(a, 5), 5);
A<int> a;
BOOST_TEST_NOT(boost::allocator_allocate(a, 5));
BOOST_TEST_EQ(a.value, 5);
return boost::report_errors();
}

22
test/allocator_const_pointer_test.cpp
View File

@ -9,22 +9,26 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
template<class T>
struct A1 {
typedef char value_type;
typedef int* pointer;
typedef T value_type;
typedef int* const_pointer;
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef char value_type;
typedef int* pointer;
typedef const bool* const_pointer;
typedef T value_type;
};
#endif
int main()
{
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const char*,
boost::allocator_const_pointer<A1>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const bool*,
boost::allocator_const_pointer<A2>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
boost::allocator_const_pointer<A1<char> >::type>));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
boost::allocator_const_pointer<A2<int> >::type>));
#endif
return boost::report_errors();
}

23
test/allocator_const_void_pointer_test.cpp
View File

@ -9,20 +9,31 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
template<class T>
struct A1 {
typedef int* pointer;
typedef T value_type;
typedef int* const_pointer;
typedef int* const_void_pointer;
template<class U>
struct rebind {
typedef A1<U> other;
};
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef int* pointer;
typedef const bool* const_void_pointer;
typedef T value_type;
};
#endif
int main()
{
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
boost::allocator_const_void_pointer<A1<char> >::type>));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const void*,
boost::allocator_const_void_pointer<A1>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const bool*,
boost::allocator_const_void_pointer<A2>::type>));
boost::allocator_const_void_pointer<A2<int> >::type>));
#endif
return boost::report_errors();
}

43
test/allocator_construct_test.cpp
View File

@ -6,43 +6,40 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#include <boost/core/allocator_access.hpp>
#include <boost/core/default_allocator.hpp>
#include <boost/core/lightweight_test.hpp>
struct S {
S(int v)
: value(v) { }
int value;
template<class T>
struct A1 {
typedef T value_type;
A1() { }
};
struct A1 { };
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
void construct(S* p, int v) {
new(p) S(v + 1);
typedef T value_type;
A2() { }
template<class U, class V>
void construct(U* p, const V& v) {
::new((void*)p) U(v + 1);
}
};
#endif
int main()
{
boost::default_allocator<S> d;
{
S* p = d.allocate(1);
A1 a;
boost::allocator_construct(a, p, 1);
BOOST_TEST_EQ(p->value, 1);
d.deallocate(p, 1);
A1<int> a;
int i = 0;
boost::allocator_construct(a, &i, 5);
BOOST_TEST_EQ(i, 5);
}
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
{
S* p = d.allocate(1);
A2 a;
boost::allocator_construct(a, p, 1);
BOOST_TEST_EQ(p->value, 2);
d.deallocate(p, 1);
A1<int> a;
int i = 0;
boost::allocator_construct(a, &i, 5);
BOOST_TEST_EQ(i, 6);
}
#endif
return boost::report_errors();

15
test/allocator_deallocate_test.cpp
View File

@ -8,23 +8,22 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/allocator_access.hpp>
#include <boost/core/lightweight_test.hpp>
template<class T>
struct A {
typedef int* pointer;
typedef int size_type;
typedef T value_type;
typedef T* pointer;
typedef std::size_t size_type;
A()
: value() { }
void deallocate(pointer, size_type n) {
void deallocate(T*, std::size_t n) {
value = n;
}
size_type value;
std::size_t value;
};
int main()
{
A a;
A<int> a;
boost::allocator_deallocate(a, 0, 5);
BOOST_TEST_EQ(a.value, 5);
return boost::report_errors();

42
test/allocator_destroy_test.cpp
View File

@ -6,20 +6,16 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#include <boost/core/allocator_access.hpp>
#include <boost/core/default_allocator.hpp>
#include <boost/core/lightweight_test.hpp>
struct S {
static int count;
S() {
++count;
}
S(const S&) {
++count;
}
~S() {
--count;
}
@ -27,35 +23,39 @@ struct S {
int S::count = 0;
struct A1 { };
template<class T>
struct A1 {
typedef T value_type;
A1() { }
};
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
void destroy(S*) {
++S::count;
typedef T value_type;
A2() { }
template<class U>
void destroy(U* p) {
*p = U();
}
};
#endif
int main()
{
boost::default_allocator<S> d;
{
S* p = d.allocate(1);
new(p) S;
A1 a;
boost::allocator_destroy(a, p);
A1<int> a;
S s;
boost::allocator_destroy(a, &s);
BOOST_TEST_EQ(S::count, 0);
d.deallocate(p, 1);
::new((void*)&s) S();
}
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
{
S* p = d.allocate(1);
new(p) S;
A2 a;
boost::allocator_destroy(a, p);
BOOST_TEST_EQ(S::count, 2);
d.deallocate(p, 1);
A1<int> a;
int i = 5;
boost::allocator_destroy(a, &i);
BOOST_TEST_EQ(i, 0);
}
#endif
return boost::report_errors();

18
test/allocator_difference_type_test.cpp
View File

@ -9,20 +9,26 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
template<class T>
struct A1 {
typedef char* pointer;
typedef T value_type;
typedef short difference_type;
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef char* pointer;
typedef int difference_type;
typedef T value_type;
};
#endif
int main()
{
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<short,
boost::allocator_difference_type<A1<char> >::type>));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
boost::allocator_difference_type<A1>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
boost::allocator_difference_type<A2>::type>));
boost::allocator_difference_type<A2<int> >::type>));
#endif
return boost::report_errors();
}

35
test/allocator_is_always_equal_test.cpp
View File

@ -9,28 +9,39 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
template<class T>
struct A1 {
typedef T value_type;
int value;
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
struct is_always_equal {
BOOST_STATIC_CONSTEXPR bool value = true;
};
int value;
typedef T value_type;
};
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
struct A3 { };
template<class T>
struct A3 {
typedef T value_type;
typedef std::false_type is_always_equal;
};
template<class T>
struct A4 {
typedef T value_type;
typedef std::true_type is_always_equal;
int value;
};
#endif
int main()
{
BOOST_TEST_TRAIT_FALSE((boost::allocator_is_always_equal<A1>::type));
BOOST_TEST_TRAIT_TRUE((boost::allocator_is_always_equal<A2>::type));
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
BOOST_TEST_TRAIT_TRUE((boost::allocator_is_always_equal<A3>::type));
#endif
BOOST_TEST_TRAIT_FALSE((boost::allocator_is_always_equal<A1<int> >::type));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::allocator_is_always_equal<A2<int> >::type));
BOOST_TEST_TRAIT_FALSE((boost::allocator_is_always_equal<A3<int> >::type));
BOOST_TEST_TRAIT_TRUE((boost::allocator_is_always_equal<A4<int> >::type));
#endif
return boost::report_errors();
}

30
test/allocator_max_size_test.cpp
View File

@ -7,29 +7,33 @@ Distributed under the Boost Software License, Version 1.0.
*/
#include <boost/core/allocator_access.hpp>
#include <boost/core/lightweight_test.hpp>
#include <limits>
template<class T>
struct A1 {
typedef long value_type;
typedef T value_type;
typedef short size_type;
};
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
struct A2 {
typedef long value_type;
typedef short size_type;
size_type max_size() const {
A1() { }
short max_size() const {
return 1;
}
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef T value_type;
typedef short size_type;
A2() { }
};
#endif
int main()
{
BOOST_TEST_EQ(boost::allocator_max_size(A1()),
std::numeric_limits<A1::size_type>::max() / sizeof(A1::value_type));
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
BOOST_TEST_EQ(boost::allocator_max_size(A2()), 1);
BOOST_TEST_EQ(boost::allocator_max_size(A1<int>()), 1);
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_LE(boost::allocator_max_size(A2<int>()),
(std::numeric_limits<short>::max)());
#endif
return boost::report_errors();
}

23
test/allocator_pocca_test.cpp
View File

@ -9,19 +9,26 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
struct A1 { };
struct A2 {
struct propagate_on_container_copy_assignment {
BOOST_STATIC_CONSTEXPR bool value = true;
};
template<class T>
struct A1 {
typedef T value_type;
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef T value_type;
typedef std::true_type propagate_on_container_copy_assignment;
};
#endif
int main()
{
BOOST_TEST_TRAIT_FALSE((boost::
allocator_propagate_on_container_copy_assignment<A1>::type));
allocator_propagate_on_container_copy_assignment<A1<int> >::type));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::
allocator_propagate_on_container_copy_assignment<A2>::type));
allocator_propagate_on_container_copy_assignment<A2<int> >::type));
#endif
return boost::report_errors();
}

23
test/allocator_pocma_test.cpp
View File

@ -9,19 +9,26 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
struct A1 { };
struct A2 {
struct propagate_on_container_move_assignment {
BOOST_STATIC_CONSTEXPR bool value = true;
};
template<class T>
struct A1 {
typedef T value_type;
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef T value_type;
typedef std::true_type propagate_on_container_move_assignment;
};
#endif
int main()
{
BOOST_TEST_TRAIT_FALSE((boost::
allocator_propagate_on_container_move_assignment<A1>::type));
allocator_propagate_on_container_move_assignment<A1<int> >::type));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::
allocator_propagate_on_container_move_assignment<A2>::type));
allocator_propagate_on_container_move_assignment<A2<int> >::type));
#endif
return boost::report_errors();
}

23
test/allocator_pocs_test.cpp
View File

@ -9,19 +9,26 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
struct A1 { };
struct A2 {
struct propagate_on_container_swap {
BOOST_STATIC_CONSTEXPR bool value = true;
};
template<class T>
struct A1 {
typedef T value_type;
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef T value_type;
typedef std::true_type propagate_on_container_swap;
};
#endif
int main()
{
BOOST_TEST_TRAIT_FALSE((boost::
allocator_propagate_on_container_swap<A1>::type));
allocator_propagate_on_container_swap<A1<int> >::type));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::
allocator_propagate_on_container_swap<A2>::type));
allocator_propagate_on_container_swap<A2<int> >::type));
#endif
return boost::report_errors();
}

22
test/allocator_pointer_test.cpp
View File

@ -9,20 +9,26 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
template<class T>
struct A1 {
typedef char value_type;
};
struct A2 {
typedef char value_type;
typedef T value_type;
typedef int* pointer;
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef T value_type;
};
#endif
int main()
{
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<char*,
boost::allocator_pointer<A1>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
boost::allocator_pointer<A2>::type>));
boost::allocator_pointer<A1<char> >::type>));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
boost::allocator_pointer<A2<int> >::type>));
#endif
return boost::report_errors();
}

29
test/allocator_rebind_test.cpp
View File

@ -9,22 +9,29 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
template<class, class, class>
struct A1 { };
template<class, class U, class V>
struct A2 {
template<class T>
template<class T>
struct A1 {
typedef T value_type;
template<class>
struct rebind {
typedef A1<T, U, V> other;
typedef A1<int> other;
};
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef T value_type;
};
#endif
int main()
{
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A1<bool, int, float>,
boost::allocator_rebind<A1<char, int, float>, bool>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A1<bool, int, float>,
boost::allocator_rebind<A2<char, int, float>, bool>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A1<int>,
boost::allocator_rebind<A1<char>, bool>::type>));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A2<int>,
boost::allocator_rebind<A2<char>, int>::type>));
#endif
return boost::report_errors();
}

28
test/allocator_size_type_test.cpp
View File

@ -9,26 +9,26 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
template<class T>
struct A1 {
typedef long difference_type;
typedef T value_type;
typedef int size_type;
};
#else
struct A1 {
typedef unsigned long size_type;
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef T value_type;
};
#endif
struct A2 {
typedef long difference_type;
typedef unsigned short size_type;
};
int main()
{
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<unsigned long,
boost::allocator_size_type<A1>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<unsigned short,
boost::allocator_size_type<A2>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
boost::allocator_size_type<A1<char> >::type>));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::size_t,
boost::allocator_size_type<A2<int> >::type>));
#endif
return boost::report_errors();
}

27
test/allocator_soccc_test.cpp
View File

@ -8,33 +8,34 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/allocator_access.hpp>
#include <boost/core/lightweight_test.hpp>
template<class T>
struct A1 {
A1(int v)
: value(v) { }
typedef T value_type;
A1(int n)
: value(n) { }
int value;
};
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
A2(int v)
: value(v) { }
typedef T value_type;
A2(int n)
: value(n) { }
A2 select_on_container_copy_construction() const {
return A2(value + 1);
}
int value;
};
#endif
int main()
{
BOOST_TEST_EQ(1,
boost::allocator_select_on_container_copy_construction(A1(1)).value);
#if defined(BOOST_CORE_ALLOCATOR_DETECTION)
BOOST_TEST_EQ(2,
boost::allocator_select_on_container_copy_construction(A2(1)).value);
BOOST_TEST_EQ(1, boost::
allocator_select_on_container_copy_construction(A1<int>(1)).value);
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_EQ(2, boost::
allocator_select_on_container_copy_construction(A2<int>(1)).value);
#endif
return boost::report_errors();
}

5
test/allocator_value_type_test.cpp
View File

@ -9,13 +9,14 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
template<class T>
struct A {
typedef int value_type;
typedef T value_type;
};
int main()
{
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
boost::allocator_value_type<A>::type>));
boost::allocator_value_type<A<int> >::type>));
return boost::report_errors();
}

21
test/allocator_void_pointer_test.cpp
View File

@ -9,20 +9,31 @@ Distributed under the Boost Software License, Version 1.0.
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp>
template<class T>
struct A1 {
typedef T value_type;
typedef int* pointer;
typedef int* void_pointer;
template<class U>
struct rebind {
typedef A1<U> other;
};
};
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T>
struct A2 {
typedef int* pointer;
typedef bool* void_pointer;
typedef T value_type;
};
#endif
int main()
{
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
boost::allocator_void_pointer<A1<char> >::type>));
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
boost::allocator_void_pointer<A1>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool*,
boost::allocator_void_pointer<A2>::type>));
boost::allocator_void_pointer<A2<int> >::type>));
#endif
return boost::report_errors();
}