mirror of
https://github.com/boostorg/unordered.git
synced 2025-11-03 17:21:48 +01:00
358 lines
8.3 KiB
C++
358 lines
8.3 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(); }
|
|
|
|
#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
|
|
cxx11_allocator_base& operator=(cxx11_allocator_base const& x) = default;
|
|
#endif
|
|
|
|
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) {}
|
|
|
|
#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
|
|
cxx11_allocator& operator=(cxx11_allocator const& x) = default;
|
|
#endif
|
|
|
|
// 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) {}
|
|
|
|
#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
|
|
cxx11_allocator& operator=(cxx11_allocator const& x) = default;
|
|
#endif
|
|
|
|
// 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
|