mirror of
https://github.com/boostorg/unordered.git
synced 2025-10-25 05:41:47 +02:00
7da307c696
The rebind mechanism doesn't work for templates with multiple template parameters on old versions of GCC. But allocators written for that compiler will have an explicit rebind, so that should be acceptable.
322 lines
8.8 KiB
C++
322 lines
8.8 KiB
C++
|
|
// Copyright 2006-2011 Daniel James.
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
#if !defined(BOOST_UNORDERED_TEST_CXX11_ALLOCATOR_HEADER)
|
|
#define BOOST_UNORDERED_TEST_CXX11_ALLOCATOR_HEADER
|
|
|
|
#include <boost/config.hpp>
|
|
#include <boost/limits.hpp>
|
|
#include <cstddef>
|
|
|
|
#include "../helpers/fwd.hpp"
|
|
#include "../helpers/memory.hpp"
|
|
|
|
namespace test
|
|
{
|
|
struct allocator_false
|
|
{
|
|
enum {
|
|
is_select_on_copy = 0,
|
|
is_propagate_on_swap = 0,
|
|
is_propagate_on_assign = 0,
|
|
is_propagate_on_move = 0,
|
|
cxx11_construct = 0
|
|
};
|
|
};
|
|
|
|
struct allocator_flags_all
|
|
{
|
|
enum {
|
|
is_select_on_copy = 1,
|
|
is_propagate_on_swap = 1,
|
|
is_propagate_on_assign = 1,
|
|
is_propagate_on_move = 1,
|
|
cxx11_construct = 1
|
|
};
|
|
};
|
|
|
|
struct select_copy : allocator_false
|
|
{ enum { is_select_on_copy = 1 }; };
|
|
struct propagate_swap : allocator_false
|
|
{ enum { is_propagate_on_swap = 1 }; };
|
|
struct propagate_assign : allocator_false
|
|
{ enum { is_propagate_on_assign = 1 }; };
|
|
struct propagate_move : allocator_false
|
|
{ enum { is_propagate_on_move = 1 }; };
|
|
|
|
struct no_select_copy : allocator_flags_all
|
|
{ enum { is_select_on_copy = 0 }; };
|
|
struct no_propagate_swap : allocator_flags_all
|
|
{ enum { is_propagate_on_swap = 0 }; };
|
|
struct no_propagate_assign : allocator_flags_all
|
|
{ enum { is_propagate_on_assign = 0 }; };
|
|
struct no_propagate_move : allocator_flags_all
|
|
{ enum { is_propagate_on_move = 0 }; };
|
|
|
|
template <typename Flag>
|
|
struct swap_allocator_base
|
|
{
|
|
struct propagate_on_container_swap {
|
|
enum { value = Flag::is_propagate_on_swap }; };
|
|
};
|
|
|
|
template <typename Flag>
|
|
struct assign_allocator_base
|
|
{
|
|
struct propagate_on_container_copy_assignment {
|
|
enum { value = Flag::is_propagate_on_assign }; };
|
|
};
|
|
|
|
template <typename Flag>
|
|
struct move_allocator_base
|
|
{
|
|
struct propagate_on_container_move_assignment {
|
|
enum { value = Flag::is_propagate_on_move }; };
|
|
};
|
|
|
|
namespace
|
|
{
|
|
// boostinspect:nounnamed
|
|
bool force_equal_allocator_value = false;
|
|
}
|
|
|
|
struct force_equal_allocator
|
|
{
|
|
bool old_value_;
|
|
|
|
explicit force_equal_allocator(bool value)
|
|
: old_value_(force_equal_allocator_value)
|
|
{ force_equal_allocator_value = value; }
|
|
|
|
~force_equal_allocator()
|
|
{ force_equal_allocator_value = old_value_; }
|
|
};
|
|
|
|
template <typename T>
|
|
struct cxx11_allocator_base
|
|
{
|
|
int tag_;
|
|
int selected_;
|
|
|
|
typedef std::size_t size_type;
|
|
typedef std::ptrdiff_t difference_type;
|
|
typedef T* pointer;
|
|
typedef T const* const_pointer;
|
|
typedef T& reference;
|
|
typedef T const& const_reference;
|
|
typedef T value_type;
|
|
|
|
explicit cxx11_allocator_base(int t)
|
|
: tag_(t), selected_(0)
|
|
{
|
|
detail::tracker.allocator_ref();
|
|
}
|
|
|
|
template <typename Y> cxx11_allocator_base(
|
|
cxx11_allocator_base<Y> const& x)
|
|
: tag_(x.tag_), selected_(x.selected_)
|
|
{
|
|
detail::tracker.allocator_ref();
|
|
}
|
|
|
|
cxx11_allocator_base(cxx11_allocator_base const& x)
|
|
: tag_(x.tag_), selected_(x.selected_)
|
|
{
|
|
detail::tracker.allocator_ref();
|
|
}
|
|
|
|
~cxx11_allocator_base()
|
|
{
|
|
detail::tracker.allocator_unref();
|
|
}
|
|
|
|
pointer address(reference r)
|
|
{
|
|
return pointer(&r);
|
|
}
|
|
|
|
const_pointer address(const_reference r)
|
|
{
|
|
return const_pointer(&r);
|
|
}
|
|
|
|
pointer allocate(size_type n) {
|
|
pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
|
|
detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
|
|
return ptr;
|
|
}
|
|
|
|
pointer allocate(size_type n, void const*)
|
|
{
|
|
pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
|
|
detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
|
|
return ptr;
|
|
}
|
|
|
|
void deallocate(pointer p, size_type n)
|
|
{
|
|
// Only checking tags when propagating swap.
|
|
// Note that tags will be tested
|
|
// properly in the normal allocator.
|
|
detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_,
|
|
!force_equal_allocator_value);
|
|
::operator delete((void*) p);
|
|
}
|
|
|
|
void construct(T* p, T const& t) {
|
|
detail::tracker.track_construct((void*) p, sizeof(T), tag_);
|
|
new(p) T(t);
|
|
}
|
|
|
|
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
|
template<typename... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
|
|
detail::tracker.track_construct((void*) p, sizeof(T), tag_);
|
|
new(p) T(boost::forward<Args>(args)...);
|
|
}
|
|
#endif
|
|
|
|
void destroy(T* p) {
|
|
detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
|
|
p->~T();
|
|
}
|
|
|
|
size_type max_size() const {
|
|
return (std::numeric_limits<size_type>::max)();
|
|
}
|
|
};
|
|
|
|
template <typename T, typename Flags = propagate_swap,
|
|
typename Enable = void>
|
|
struct cxx11_allocator;
|
|
|
|
template <typename T, typename Flags>
|
|
struct cxx11_allocator<
|
|
T, Flags,
|
|
typename boost::disable_if_c<Flags::is_select_on_copy>::type
|
|
> : public cxx11_allocator_base<T>,
|
|
public swap_allocator_base<Flags>,
|
|
public assign_allocator_base<Flags>,
|
|
public move_allocator_base<Flags>,
|
|
Flags
|
|
{
|
|
#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
|
|
template <typename U> struct rebind {
|
|
typedef cxx11_allocator<U, Flags> other;
|
|
};
|
|
#endif
|
|
|
|
explicit cxx11_allocator(int t = 0)
|
|
: cxx11_allocator_base<T>(t)
|
|
{
|
|
}
|
|
|
|
template <typename Y> cxx11_allocator(
|
|
cxx11_allocator<Y, Flags> const& x)
|
|
: cxx11_allocator_base<T>(x)
|
|
{
|
|
}
|
|
|
|
cxx11_allocator(cxx11_allocator const& x)
|
|
: cxx11_allocator_base<T>(x)
|
|
{
|
|
}
|
|
|
|
// When not propagating swap, allocators are always equal
|
|
// to avoid undefined behaviour.
|
|
bool operator==(cxx11_allocator const& x) const
|
|
{
|
|
return force_equal_allocator_value || (this->tag_ == x.tag_);
|
|
}
|
|
|
|
bool operator!=(cxx11_allocator const& x) const
|
|
{
|
|
return !(*this == x);
|
|
}
|
|
};
|
|
|
|
template <typename T, typename Flags>
|
|
struct cxx11_allocator<
|
|
T, Flags,
|
|
typename boost::enable_if_c<Flags::is_select_on_copy>::type
|
|
> : public cxx11_allocator_base<T>,
|
|
public swap_allocator_base<Flags>,
|
|
public assign_allocator_base<Flags>,
|
|
public move_allocator_base<Flags>,
|
|
Flags
|
|
{
|
|
cxx11_allocator select_on_container_copy_construction() const
|
|
{
|
|
cxx11_allocator tmp(*this);
|
|
++tmp.selected_;
|
|
return tmp;
|
|
}
|
|
|
|
#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
|
|
template <typename U> struct rebind {
|
|
typedef cxx11_allocator<U, Flags> other;
|
|
};
|
|
#endif
|
|
|
|
explicit cxx11_allocator(int t = 0)
|
|
: cxx11_allocator_base<T>(t)
|
|
{
|
|
}
|
|
|
|
template <typename Y> cxx11_allocator(
|
|
cxx11_allocator<Y, Flags> const& x)
|
|
: cxx11_allocator_base<T>(x)
|
|
{
|
|
}
|
|
|
|
cxx11_allocator(cxx11_allocator const& x)
|
|
: cxx11_allocator_base<T>(x)
|
|
{
|
|
}
|
|
|
|
// When not propagating swap, allocators are always equal
|
|
// to avoid undefined behaviour.
|
|
bool operator==(cxx11_allocator const& x) const
|
|
{
|
|
return force_equal_allocator_value || (this->tag_ == x.tag_);
|
|
}
|
|
|
|
bool operator!=(cxx11_allocator const& x) const
|
|
{
|
|
return !(*this == x);
|
|
}
|
|
};
|
|
|
|
template <typename T, typename Flags>
|
|
bool equivalent_impl(
|
|
cxx11_allocator<T, Flags> const& x,
|
|
cxx11_allocator<T, Flags> const& y,
|
|
test::derived_type)
|
|
{
|
|
return x.tag_ == y.tag_;
|
|
}
|
|
|
|
// Function to check how many times an allocator has been selected,
|
|
// return 0 for other allocators.
|
|
|
|
struct convert_from_anything
|
|
{
|
|
template <typename T>
|
|
convert_from_anything(T const&) {}
|
|
};
|
|
|
|
inline int selected_count(convert_from_anything)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
template <typename T, typename Flags>
|
|
int selected_count(cxx11_allocator<T, Flags> const& x)
|
|
{
|
|
return x.selected_;
|
|
}
|
|
}
|
|
|
|
#endif
|