summaryrefslogtreecommitdiffstats
path: root/src/boost/libs/unordered/test/objects
diff options
context:
space:
mode:
Diffstat (limited to 'src/boost/libs/unordered/test/objects')
-rw-r--r--src/boost/libs/unordered/test/objects/cxx11_allocator.hpp344
-rw-r--r--src/boost/libs/unordered/test/objects/exception.hpp752
-rw-r--r--src/boost/libs/unordered/test/objects/fwd.hpp17
-rw-r--r--src/boost/libs/unordered/test/objects/minimal.hpp627
-rw-r--r--src/boost/libs/unordered/test/objects/test.hpp700
5 files changed, 2440 insertions, 0 deletions
diff --git a/src/boost/libs/unordered/test/objects/cxx11_allocator.hpp b/src/boost/libs/unordered/test/objects/cxx11_allocator.hpp
new file mode 100644
index 00000000..e96f8d94
--- /dev/null
+++ b/src/boost/libs/unordered/test/objects/cxx11_allocator.hpp
@@ -0,0 +1,344 @@
+
+// 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
diff --git a/src/boost/libs/unordered/test/objects/exception.hpp b/src/boost/libs/unordered/test/objects/exception.hpp
new file mode 100644
index 00000000..07f343fb
--- /dev/null
+++ b/src/boost/libs/unordered/test/objects/exception.hpp
@@ -0,0 +1,752 @@
+
+// Copyright 2006-2009 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_EXCEPTION_TEST_OBJECTS_HEADER)
+#define BOOST_UNORDERED_EXCEPTION_TEST_OBJECTS_HEADER
+
+#include "../helpers/exception_test.hpp"
+
+#include "../helpers/count.hpp"
+#include "../helpers/fwd.hpp"
+#include "../helpers/generators.hpp"
+#include "../helpers/memory.hpp"
+#include "./fwd.hpp"
+#include <boost/limits.hpp>
+#include <cstddef>
+#include <new>
+
+namespace test {
+ namespace exception {
+ class object;
+ class hash;
+ class equal_to;
+ template <class T> class allocator;
+ object generate(object const*, random_generator);
+ std::pair<object, object> generate(
+ std::pair<object, object> const*, random_generator);
+
+ struct true_type
+ {
+ enum
+ {
+ value = true
+ };
+ };
+
+ struct false_type
+ {
+ enum
+ {
+ value = false
+ };
+ };
+
+ class object : private counted_object
+ {
+ public:
+ int tag1_, tag2_;
+
+ explicit object() : tag1_(0), tag2_(0)
+ {
+ UNORDERED_SCOPE(object::object())
+ {
+ UNORDERED_EPOINT("Mock object default constructor.");
+ }
+ }
+
+ explicit object(int t1, int t2 = 0) : tag1_(t1), tag2_(t2)
+ {
+ UNORDERED_SCOPE(object::object(int))
+ {
+ UNORDERED_EPOINT("Mock object constructor by value.");
+ }
+ }
+
+ object(object const& x)
+ : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+ {
+ UNORDERED_SCOPE(object::object(object))
+ {
+ UNORDERED_EPOINT("Mock object copy constructor.");
+ }
+ }
+
+ ~object()
+ {
+ tag1_ = -1;
+ tag2_ = -1;
+ }
+
+ object& operator=(object const& x)
+ {
+ UNORDERED_SCOPE(object::operator=(object))
+ {
+ tag1_ = x.tag1_;
+ UNORDERED_EPOINT("Mock object assign operator 1.");
+ tag2_ = x.tag2_;
+ // UNORDERED_EPOINT("Mock object assign operator 2.");
+ }
+ return *this;
+ }
+
+ friend bool operator==(object const& x1, object const& x2)
+ {
+ UNORDERED_SCOPE(operator==(object, object))
+ {
+ UNORDERED_EPOINT("Mock object equality operator.");
+ }
+
+ return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
+ }
+
+ friend bool operator!=(object const& x1, object const& x2)
+ {
+ UNORDERED_SCOPE(operator!=(object, object))
+ {
+ UNORDERED_EPOINT("Mock object inequality operator.");
+ }
+
+ return !(x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_);
+ }
+
+ // None of the last few functions are used by the unordered associative
+ // containers - so there aren't any exception points.
+ friend bool operator<(object const& x1, object const& x2)
+ {
+ return x1.tag1_ < x2.tag1_ ||
+ (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
+ }
+
+ friend object generate(object const*, random_generator g)
+ {
+ int* x = 0;
+ return object(::test::generate(x, g), ::test::generate(x, g));
+ }
+
+ friend std::ostream& operator<<(std::ostream& out, object const& o)
+ {
+ return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+ }
+ };
+
+ std::pair<object, object> generate(
+ std::pair<object, object> const*, random_generator g)
+ {
+ int* x = 0;
+ return std::make_pair(
+ object(::test::generate(x, g), ::test::generate(x, g)),
+ object(::test::generate(x, g), ::test::generate(x, g)));
+ }
+
+ class hash
+ {
+ int tag_;
+
+ public:
+ hash(int t = 0) : tag_(t)
+ {
+ UNORDERED_SCOPE(hash::object())
+ {
+ UNORDERED_EPOINT("Mock hash default constructor.");
+ }
+ }
+
+ hash(hash const& x) : tag_(x.tag_)
+ {
+ UNORDERED_SCOPE(hash::hash(hash))
+ {
+ UNORDERED_EPOINT("Mock hash copy constructor.");
+ }
+ }
+
+ hash& operator=(hash const& x)
+ {
+ UNORDERED_SCOPE(hash::operator=(hash))
+ {
+ UNORDERED_EPOINT("Mock hash assign operator 1.");
+ tag_ = x.tag_;
+ UNORDERED_EPOINT("Mock hash assign operator 2.");
+ }
+ return *this;
+ }
+
+ std::size_t operator()(object const& x) const
+ {
+ UNORDERED_SCOPE(hash::operator()(object))
+ {
+ UNORDERED_EPOINT("Mock hash function.");
+ }
+
+ return hash_impl(x);
+ }
+
+ std::size_t operator()(std::pair<object, object> const& x) const
+ {
+ UNORDERED_SCOPE(hash::operator()(std::pair<object, object>))
+ {
+ UNORDERED_EPOINT("Mock hash pair function.");
+ }
+
+ return hash_impl(x.first) * 193ul + hash_impl(x.second) * 97ul + 29ul;
+ }
+
+ std::size_t hash_impl(object const& x) const
+ {
+ int result;
+ switch (tag_) {
+ case 1:
+ result = x.tag1_;
+ break;
+ case 2:
+ result = x.tag2_;
+ break;
+ default:
+ result = x.tag1_ + x.tag2_;
+ }
+ return static_cast<std::size_t>(result);
+ }
+
+ friend bool operator==(hash const& x1, hash const& x2)
+ {
+ UNORDERED_SCOPE(operator==(hash, hash))
+ {
+ UNORDERED_EPOINT("Mock hash equality function.");
+ }
+ return x1.tag_ == x2.tag_;
+ }
+
+ friend bool operator!=(hash const& x1, hash const& x2)
+ {
+ UNORDERED_SCOPE(hash::operator!=(hash, hash))
+ {
+ UNORDERED_EPOINT("Mock hash inequality function.");
+ }
+ return x1.tag_ != x2.tag_;
+ }
+ };
+
+ class less
+ {
+ int tag_;
+
+ public:
+ less(int t = 0) : tag_(t) {}
+
+ less(less const& x) : tag_(x.tag_) {}
+
+ bool operator()(object const& x1, object const& x2) const
+ {
+ return less_impl(x1, x2);
+ }
+
+ bool operator()(std::pair<object, object> const& x1,
+ std::pair<object, object> const& x2) const
+ {
+ if (less_impl(x1.first, x2.first)) {
+ return true;
+ }
+ if (!less_impl(x1.first, x2.first)) {
+ return false;
+ }
+ return less_impl(x1.second, x2.second);
+ }
+
+ bool less_impl(object const& x1, object const& x2) const
+ {
+ switch (tag_) {
+ case 1:
+ return x1.tag1_ < x2.tag1_;
+ case 2:
+ return x1.tag2_ < x2.tag2_;
+ default:
+ return x1 < x2;
+ }
+ }
+
+ friend bool operator==(less const& x1, less const& x2)
+ {
+ return x1.tag_ == x2.tag_;
+ }
+
+ friend bool operator!=(less const& x1, less const& x2)
+ {
+ return x1.tag_ != x2.tag_;
+ }
+ };
+
+ class equal_to
+ {
+ int tag_;
+
+ public:
+ equal_to(int t = 0) : tag_(t)
+ {
+ UNORDERED_SCOPE(equal_to::equal_to())
+ {
+ UNORDERED_EPOINT("Mock equal_to default constructor.");
+ }
+ }
+
+ equal_to(equal_to const& x) : tag_(x.tag_)
+ {
+ UNORDERED_SCOPE(equal_to::equal_to(equal_to))
+ {
+ UNORDERED_EPOINT("Mock equal_to copy constructor.");
+ }
+ }
+
+ equal_to& operator=(equal_to const& x)
+ {
+ UNORDERED_SCOPE(equal_to::operator=(equal_to))
+ {
+ UNORDERED_EPOINT("Mock equal_to assign operator 1.");
+ tag_ = x.tag_;
+ UNORDERED_EPOINT("Mock equal_to assign operator 2.");
+ }
+ return *this;
+ }
+
+ bool operator()(object const& x1, object const& x2) const
+ {
+ UNORDERED_SCOPE(equal_to::operator()(object, object))
+ {
+ UNORDERED_EPOINT("Mock equal_to function.");
+ }
+
+ return equal_impl(x1, x2);
+ }
+
+ bool operator()(std::pair<object, object> const& x1,
+ std::pair<object, object> const& x2) const
+ {
+ UNORDERED_SCOPE(equal_to::operator()(
+ std::pair<object, object>, std::pair<object, object>))
+ {
+ UNORDERED_EPOINT("Mock equal_to function.");
+ }
+
+ return equal_impl(x1.first, x2.first) &&
+ equal_impl(x1.second, x2.second);
+ }
+
+ bool equal_impl(object const& x1, object const& x2) const
+ {
+ switch (tag_) {
+ case 1:
+ return x1.tag1_ == x2.tag1_;
+ case 2:
+ return x1.tag2_ == x2.tag2_;
+ default:
+ return x1 == x2;
+ }
+ }
+
+ friend bool operator==(equal_to const& x1, equal_to const& x2)
+ {
+ UNORDERED_SCOPE(operator==(equal_to, equal_to))
+ {
+ UNORDERED_EPOINT("Mock equal_to equality function.");
+ }
+ return x1.tag_ == x2.tag_;
+ }
+
+ friend bool operator!=(equal_to const& x1, equal_to const& x2)
+ {
+ UNORDERED_SCOPE(operator!=(equal_to, equal_to))
+ {
+ UNORDERED_EPOINT("Mock equal_to inequality function.");
+ }
+ return x1.tag_ != x2.tag_;
+ }
+
+ friend less create_compare(equal_to x) { return less(x.tag_); }
+ };
+
+ template <class T> class allocator
+ {
+ public:
+ int tag_;
+ 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;
+
+ template <class U> struct rebind
+ {
+ typedef allocator<U> other;
+ };
+
+ explicit allocator(int t = 0) : tag_(t)
+ {
+ UNORDERED_SCOPE(allocator::allocator())
+ {
+ UNORDERED_EPOINT("Mock allocator default constructor.");
+ }
+ test::detail::tracker.allocator_ref();
+ }
+
+ template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
+ {
+ test::detail::tracker.allocator_ref();
+ }
+
+ allocator(allocator const& x) : tag_(x.tag_)
+ {
+ test::detail::tracker.allocator_ref();
+ }
+
+ ~allocator() { test::detail::tracker.allocator_unref(); }
+
+ allocator& operator=(allocator const& x)
+ {
+ tag_ = x.tag_;
+ return *this;
+ }
+
+ // If address throws, then it can't be used in erase or the
+ // destructor, which is very limiting. I need to check up on
+ // this.
+
+ pointer address(reference r)
+ {
+ // UNORDERED_SCOPE(allocator::address(reference)) {
+ // UNORDERED_EPOINT("Mock allocator address function.");
+ //}
+ return pointer(&r);
+ }
+
+ const_pointer address(const_reference r)
+ {
+ // UNORDERED_SCOPE(allocator::address(const_reference)) {
+ // UNORDERED_EPOINT("Mock allocator const address function.");
+ //}
+ return const_pointer(&r);
+ }
+
+ pointer allocate(size_type n)
+ {
+ T* ptr = 0;
+ UNORDERED_SCOPE(allocator::allocate(size_type))
+ {
+ UNORDERED_EPOINT("Mock allocator allocate function.");
+
+ using namespace std;
+ ptr = (T*)malloc(n * sizeof(T));
+ if (!ptr)
+ throw std::bad_alloc();
+ }
+ test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+ return pointer(ptr);
+
+ // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+ }
+
+ pointer allocate(size_type n, void const*)
+ {
+ T* ptr = 0;
+ UNORDERED_SCOPE(allocator::allocate(size_type, const_pointer))
+ {
+ UNORDERED_EPOINT("Mock allocator allocate function.");
+
+ using namespace std;
+ ptr = (T*)malloc(n * sizeof(T));
+ if (!ptr)
+ throw std::bad_alloc();
+ }
+ test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+ return pointer(ptr);
+
+ // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+ }
+
+ void deallocate(pointer p, size_type n)
+ {
+ //::operator delete((void*) p);
+ if (p) {
+ test::detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
+ using namespace std;
+ free(p);
+ }
+ }
+
+ void construct(pointer p, T const& t)
+ {
+ UNORDERED_SCOPE(allocator::construct(T*, T))
+ {
+ UNORDERED_EPOINT("Mock allocator construct function.");
+ new (p) T(t);
+ }
+ test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+ }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+ {
+ UNORDERED_SCOPE(allocator::construct(pointer, BOOST_FWD_REF(Args)...))
+ {
+ UNORDERED_EPOINT("Mock allocator construct function.");
+ new (p) T(boost::forward<Args>(args)...);
+ }
+ test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+ }
+#endif
+
+ void destroy(T* p)
+ {
+ test::detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+ p->~T();
+ }
+
+ size_type max_size() const
+ {
+ UNORDERED_SCOPE(allocator::construct(pointer, T))
+ {
+ UNORDERED_EPOINT("Mock allocator max_size function.");
+ }
+ return (std::numeric_limits<std::size_t>::max)();
+ }
+
+ typedef true_type propagate_on_container_copy_assignment;
+ typedef true_type propagate_on_container_move_assignment;
+ typedef true_type propagate_on_container_swap;
+ };
+
+ template <class T> void swap(allocator<T>& x, allocator<T>& y)
+ {
+ std::swap(x.tag_, y.tag_);
+ }
+
+ // It's pretty much impossible to write a compliant swap when these
+ // two can throw. So they don't.
+
+ template <class T>
+ inline bool operator==(allocator<T> const& x, allocator<T> const& y)
+ {
+ // UNORDERED_SCOPE(operator==(allocator, allocator)) {
+ // UNORDERED_EPOINT("Mock allocator equality operator.");
+ //}
+ return x.tag_ == y.tag_;
+ }
+
+ template <class T>
+ inline bool operator!=(allocator<T> const& x, allocator<T> const& y)
+ {
+ // UNORDERED_SCOPE(operator!=(allocator, allocator)) {
+ // UNORDERED_EPOINT("Mock allocator inequality operator.");
+ //}
+ return x.tag_ != y.tag_;
+ }
+
+ template <class T> class allocator2
+ {
+ public:
+ int tag_;
+ 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;
+
+ template <class U> struct rebind
+ {
+ typedef allocator2<U> other;
+ };
+
+ explicit allocator2(int t = 0) : tag_(t)
+ {
+ UNORDERED_SCOPE(allocator2::allocator2())
+ {
+ UNORDERED_EPOINT("Mock allocator2 default constructor.");
+ }
+ test::detail::tracker.allocator_ref();
+ }
+
+ allocator2(allocator<T> const& x) : tag_(x.tag_)
+ {
+ test::detail::tracker.allocator_ref();
+ }
+
+ template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
+ {
+ test::detail::tracker.allocator_ref();
+ }
+
+ allocator2(allocator2 const& x) : tag_(x.tag_)
+ {
+ test::detail::tracker.allocator_ref();
+ }
+
+ ~allocator2() { test::detail::tracker.allocator_unref(); }
+
+ allocator2& operator=(allocator2 const&) { return *this; }
+
+ // If address throws, then it can't be used in erase or the
+ // destructor, which is very limiting. I need to check up on
+ // this.
+
+ pointer address(reference r)
+ {
+ // UNORDERED_SCOPE(allocator2::address(reference)) {
+ // UNORDERED_EPOINT("Mock allocator2 address function.");
+ //}
+ return pointer(&r);
+ }
+
+ const_pointer address(const_reference r)
+ {
+ // UNORDERED_SCOPE(allocator2::address(const_reference)) {
+ // UNORDERED_EPOINT("Mock allocator2 const address function.");
+ //}
+ return const_pointer(&r);
+ }
+
+ pointer allocate(size_type n)
+ {
+ T* ptr = 0;
+ UNORDERED_SCOPE(allocator2::allocate(size_type))
+ {
+ UNORDERED_EPOINT("Mock allocator2 allocate function.");
+
+ using namespace std;
+ ptr = (T*)malloc(n * sizeof(T));
+ if (!ptr)
+ throw std::bad_alloc();
+ }
+ test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+ return pointer(ptr);
+
+ // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+ }
+
+ pointer allocate(size_type n, void const*)
+ {
+ T* ptr = 0;
+ UNORDERED_SCOPE(allocator2::allocate(size_type, const_pointer))
+ {
+ UNORDERED_EPOINT("Mock allocator2 allocate function.");
+
+ using namespace std;
+ ptr = (T*)malloc(n * sizeof(T));
+ if (!ptr)
+ throw std::bad_alloc();
+ }
+ test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+ return pointer(ptr);
+
+ // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+ }
+
+ void deallocate(pointer p, size_type n)
+ {
+ //::operator delete((void*) p);
+ if (p) {
+ test::detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
+ using namespace std;
+ free(p);
+ }
+ }
+
+ void construct(pointer p, T const& t)
+ {
+ UNORDERED_SCOPE(allocator2::construct(T*, T))
+ {
+ UNORDERED_EPOINT("Mock allocator2 construct function.");
+ new (p) T(t);
+ }
+ test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+ }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+ {
+ UNORDERED_SCOPE(allocator2::construct(pointer, BOOST_FWD_REF(Args)...))
+ {
+ UNORDERED_EPOINT("Mock allocator2 construct function.");
+ new (p) T(boost::forward<Args>(args)...);
+ }
+ test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+ }
+#endif
+
+ void destroy(T* p)
+ {
+ test::detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+ p->~T();
+ }
+
+ size_type max_size() const
+ {
+ UNORDERED_SCOPE(allocator2::construct(pointer, T))
+ {
+ UNORDERED_EPOINT("Mock allocator2 max_size function.");
+ }
+ return (std::numeric_limits<std::size_t>::max)();
+ }
+
+ typedef false_type propagate_on_container_copy_assignment;
+ typedef false_type propagate_on_container_move_assignment;
+ typedef false_type propagate_on_container_swap;
+ };
+
+ template <class T> void swap(allocator2<T>& x, allocator2<T>& y)
+ {
+ std::swap(x.tag_, y.tag_);
+ }
+
+ // It's pretty much impossible to write a compliant swap when these
+ // two can throw. So they don't.
+
+ template <class T>
+ inline bool operator==(allocator2<T> const& x, allocator2<T> const& y)
+ {
+ // UNORDERED_SCOPE(operator==(allocator2, allocator2)) {
+ // UNORDERED_EPOINT("Mock allocator2 equality operator.");
+ //}
+ return x.tag_ == y.tag_;
+ }
+
+ template <class T>
+ inline bool operator!=(allocator2<T> const& x, allocator2<T> const& y)
+ {
+ // UNORDERED_SCOPE(operator!=(allocator2, allocator2)) {
+ // UNORDERED_EPOINT("Mock allocator2 inequality operator.");
+ //}
+ return x.tag_ != y.tag_;
+ }
+ }
+}
+
+namespace test {
+ template <typename X> struct equals_to_compare;
+ template <> struct equals_to_compare<test::exception::equal_to>
+ {
+ typedef test::exception::less type;
+ };
+}
+
+// Workaround for ADL deficient compilers
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace test {
+ test::exception::object generate(
+ test::exception::object const* x, random_generator g)
+ {
+ return test::exception::generate(x, g);
+ }
+
+ std::pair<test::exception::object, test::exception::object> generate(
+ std::pair<test::exception::object, test::exception::object> const* x,
+ random_generator g)
+ {
+ return test::exception::generate(x, g);
+ }
+}
+#endif
+
+#endif
diff --git a/src/boost/libs/unordered/test/objects/fwd.hpp b/src/boost/libs/unordered/test/objects/fwd.hpp
new file mode 100644
index 00000000..802b95af
--- /dev/null
+++ b/src/boost/libs/unordered/test/objects/fwd.hpp
@@ -0,0 +1,17 @@
+
+// Copyright 2006-2009 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_OBJECTS_FWD_HEADER)
+#define BOOST_UNORDERED_TEST_OBJECTS_FWD_HEADER
+
+namespace test {
+ class object;
+ class hash;
+ class less;
+ class equal_to;
+ template <class T> class allocator;
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/objects/minimal.hpp b/src/boost/libs/unordered/test/objects/minimal.hpp
new file mode 100644
index 00000000..b89e0af8
--- /dev/null
+++ b/src/boost/libs/unordered/test/objects/minimal.hpp
@@ -0,0 +1,627 @@
+
+// Copyright 2006-2009 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)
+
+// Define some minimal classes which provide the bare minimum concepts to
+// test that the containers don't rely on something that they shouldn't.
+// They are not intended to be good examples of how to implement the concepts.
+
+#if !defined(BOOST_UNORDERED_OBJECTS_MINIMAL_HEADER)
+#define BOOST_UNORDERED_OBJECTS_MINIMAL_HEADER
+
+#include <boost/move/move.hpp>
+#include <cstddef>
+#include <utility>
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable : 4100) // unreferenced formal parameter
+#endif
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, == 1500)
+#define BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED 1
+#else
+#define BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED 0
+#endif
+
+namespace test {
+ namespace minimal {
+ class destructible;
+ class copy_constructible;
+ class copy_constructible_equality_comparable;
+ class default_assignable;
+ class assignable;
+
+ struct ampersand_operator_used
+ {
+ ampersand_operator_used() { BOOST_TEST(false); }
+ };
+
+ template <class T> class hash;
+ template <class T> class equal_to;
+ template <class T> class ptr;
+ template <class T> class const_ptr;
+ template <class T> class allocator;
+ template <class T> class cxx11_allocator;
+
+ struct constructor_param
+ {
+ operator int() const { return 0; }
+ };
+
+ class destructible
+ {
+ public:
+ destructible(constructor_param const&) {}
+ ~destructible() {}
+ void dummy_member() const {}
+
+ private:
+ destructible(destructible const&);
+ destructible& operator=(destructible const&);
+ };
+
+ class copy_constructible
+ {
+ public:
+ copy_constructible(constructor_param const&) {}
+ copy_constructible(copy_constructible const&) {}
+ ~copy_constructible() {}
+ void dummy_member() const {}
+
+ private:
+ copy_constructible& operator=(copy_constructible const&);
+ copy_constructible() {}
+ };
+
+ class copy_constructible_equality_comparable
+ {
+ public:
+ copy_constructible_equality_comparable(constructor_param const&) {}
+
+ copy_constructible_equality_comparable(
+ copy_constructible_equality_comparable const&)
+ {
+ }
+
+ ~copy_constructible_equality_comparable() {}
+
+ void dummy_member() const {}
+
+ private:
+ copy_constructible_equality_comparable& operator=(
+ copy_constructible_equality_comparable const&);
+ copy_constructible_equality_comparable() {}
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+ ampersand_operator_used operator&() const
+ {
+ return ampersand_operator_used();
+ }
+#endif
+ };
+
+ bool operator==(copy_constructible_equality_comparable,
+ copy_constructible_equality_comparable)
+ {
+ return true;
+ }
+
+ bool operator!=(copy_constructible_equality_comparable,
+ copy_constructible_equality_comparable)
+ {
+ return false;
+ }
+
+ class default_assignable
+ {
+ public:
+ default_assignable(constructor_param const&) {}
+
+ default_assignable() {}
+
+ default_assignable(default_assignable const&) {}
+
+ default_assignable& operator=(default_assignable const&) { return *this; }
+
+ ~default_assignable() {}
+
+ void dummy_member() const {}
+
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+ ampersand_operator_used operator&() const
+ {
+ return ampersand_operator_used();
+ }
+#endif
+ };
+
+ class assignable
+ {
+ public:
+ assignable(constructor_param const&) {}
+ assignable(assignable const&) {}
+ assignable& operator=(assignable const&) { return *this; }
+ ~assignable() {}
+ void dummy_member() const {}
+
+ private:
+ assignable() {}
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+ ampersand_operator_used operator&() const
+ {
+ return ampersand_operator_used();
+ }
+#endif
+ };
+
+ struct movable_init
+ {
+ };
+
+ class movable1
+ {
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(movable1)
+
+ public:
+ movable1(constructor_param const&) {}
+ movable1() {}
+ explicit movable1(movable_init) {}
+ movable1(BOOST_RV_REF(movable1)) {}
+ movable1& operator=(BOOST_RV_REF(movable1)) { return *this; }
+ ~movable1() {}
+ void dummy_member() const {}
+ };
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ class movable2
+ {
+ public:
+ movable2(constructor_param const&) {}
+ explicit movable2(movable_init) {}
+ movable2(movable2&&) {}
+ ~movable2() {}
+ movable2& operator=(movable2&&) { return *this; }
+ void dummy_member() const {}
+
+ private:
+ movable2() {}
+ movable2(movable2 const&);
+ movable2& operator=(movable2 const&);
+ };
+#else
+ typedef movable1 movable2;
+#endif
+
+ template <class T> class hash
+ {
+ public:
+ hash(constructor_param const&) {}
+ hash() {}
+ hash(hash const&) {}
+ hash& operator=(hash const&) { return *this; }
+ ~hash() {}
+
+ std::size_t operator()(T const&) const { return 0; }
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+ ampersand_operator_used operator&() const
+ {
+ return ampersand_operator_used();
+ }
+#endif
+ };
+
+ template <class T> class equal_to
+ {
+ public:
+ equal_to(constructor_param const&) {}
+ equal_to() {}
+ equal_to(equal_to const&) {}
+ equal_to& operator=(equal_to const&) { return *this; }
+ ~equal_to() {}
+
+ bool operator()(T const&, T const&) const { return true; }
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+ ampersand_operator_used operator&() const
+ {
+ return ampersand_operator_used();
+ }
+#endif
+ };
+
+ template <class T> class ptr;
+ template <class T> class const_ptr;
+
+ struct void_ptr
+ {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+ template <typename T> friend class ptr;
+
+ private:
+#endif
+
+ void* ptr_;
+
+ public:
+ void_ptr() : ptr_(0) {}
+
+ template <typename T> explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+
+ // I'm not using the safe bool idiom because the containers should be
+ // able to cope with bool conversions.
+ operator bool() const { return !!ptr_; }
+
+ bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
+ bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
+ };
+
+ class void_const_ptr
+ {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+ template <typename T> friend class const_ptr;
+
+ private:
+#endif
+
+ void* ptr_;
+
+ public:
+ void_const_ptr() : ptr_(0) {}
+
+ template <typename T>
+ explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_)
+ {
+ }
+
+ // I'm not using the safe bool idiom because the containers should be
+ // able to cope with bool conversions.
+ operator bool() const { return !!ptr_; }
+
+ bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
+ bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
+ };
+
+ template <class T> class ptr
+ {
+ friend class allocator<T>;
+ friend class const_ptr<T>;
+ friend struct void_ptr;
+
+ T* ptr_;
+
+ ptr(T* x) : ptr_(x) {}
+
+ public:
+ ptr() : ptr_(0) {}
+ explicit ptr(void_ptr const& x) : ptr_((T*)x.ptr_) {}
+
+ T& operator*() const { return *ptr_; }
+ T* operator->() const { return ptr_; }
+ ptr& operator++()
+ {
+ ++ptr_;
+ return *this;
+ }
+ ptr operator++(int)
+ {
+ ptr tmp(*this);
+ ++ptr_;
+ return tmp;
+ }
+ ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
+ friend ptr operator+(std::ptrdiff_t s, ptr p)
+ {
+ return ptr<T>(s + p.ptr_);
+ }
+ T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
+ bool operator!() const { return !ptr_; }
+
+ // I'm not using the safe bool idiom because the containers should be
+ // able to cope with bool conversions.
+ operator bool() const { return !!ptr_; }
+
+ bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
+ bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
+ bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
+ bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
+ bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
+ bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+ ampersand_operator_used operator&() const
+ {
+ return ampersand_operator_used();
+ }
+#endif
+ };
+
+ template <class T> class const_ptr
+ {
+ friend class allocator<T>;
+ friend struct const_void_ptr;
+
+ T const* ptr_;
+
+ const_ptr(T const* ptr) : ptr_(ptr) {}
+
+ public:
+ const_ptr() : ptr_(0) {}
+ const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+ explicit const_ptr(void_const_ptr const& x) : ptr_((T const*)x.ptr_) {}
+
+ T const& operator*() const { return *ptr_; }
+ T const* operator->() const { return ptr_; }
+ const_ptr& operator++()
+ {
+ ++ptr_;
+ return *this;
+ }
+ const_ptr operator++(int)
+ {
+ const_ptr tmp(*this);
+ ++ptr_;
+ return tmp;
+ }
+ const_ptr operator+(std::ptrdiff_t s) const
+ {
+ return const_ptr(ptr_ + s);
+ }
+ friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
+ {
+ return ptr<T>(s + p.ptr_);
+ }
+ T const& operator[](int s) const { return ptr_[s]; }
+ bool operator!() const { return !ptr_; }
+ operator bool() const { return !!ptr_; }
+
+ bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
+ bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
+ bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
+ bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
+ bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
+ bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+ ampersand_operator_used operator&() const
+ {
+ return ampersand_operator_used();
+ }
+#endif
+ };
+
+ template <class T> class allocator
+ {
+ public:
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef void_ptr void_pointer;
+ typedef void_const_ptr const_void_pointer;
+ typedef ptr<T> pointer;
+ typedef const_ptr<T> const_pointer;
+ typedef T& reference;
+ typedef T const& const_reference;
+ typedef T value_type;
+
+ template <class U> struct rebind
+ {
+ typedef allocator<U> other;
+ };
+
+ allocator() {}
+ template <class Y> allocator(allocator<Y> const&) {}
+ allocator(allocator const&) {}
+ ~allocator() {}
+
+ pointer address(reference r) { return pointer(&r); }
+ const_pointer address(const_reference r) { return const_pointer(&r); }
+
+ pointer allocate(size_type n)
+ {
+ return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+ }
+
+ template <class Y> pointer allocate(size_type n, const_ptr<Y>)
+ {
+ return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+ }
+
+ void deallocate(pointer p, size_type)
+ {
+ ::operator delete((void*)p.ptr_);
+ }
+
+ void construct(T* p, T const& t) { new ((void*)p) T(t); }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+ {
+ new ((void*)p) T(boost::forward<Args>(args)...);
+ }
+#endif
+
+ void destroy(T* p) { p->~T(); }
+
+ size_type max_size() const { return 1000; }
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) || \
+ BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+ public:
+ allocator& operator=(allocator const&) { return *this; }
+#else
+ private:
+ allocator& operator=(allocator const&);
+#endif
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+ ampersand_operator_used operator&() const
+ {
+ return ampersand_operator_used();
+ }
+#endif
+ };
+
+ template <class T> class allocator<T const>
+ {
+ public:
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef void_ptr void_pointer;
+ typedef void_const_ptr const_void_pointer;
+ // Maybe these two should be const_ptr<T>
+ typedef ptr<T const> pointer;
+ typedef const_ptr<T const> const_pointer;
+ typedef T const& reference;
+ typedef T const& const_reference;
+ typedef T const value_type;
+
+ template <class U> struct rebind
+ {
+ typedef allocator<U> other;
+ };
+
+ allocator() {}
+ template <class Y> allocator(allocator<Y> const&) {}
+ allocator(allocator const&) {}
+ ~allocator() {}
+
+ const_pointer address(const_reference r) { return const_pointer(&r); }
+
+ pointer allocate(size_type n)
+ {
+ return pointer(static_cast<T const*>(::operator new(n * sizeof(T))));
+ }
+
+ template <class Y> pointer allocate(size_type n, const_ptr<Y>)
+ {
+ return pointer(static_cast<T const*>(::operator new(n * sizeof(T))));
+ }
+
+ void deallocate(pointer p, size_type)
+ {
+ ::operator delete((void*)p.ptr_);
+ }
+
+ void construct(T const* p, T const& t) { new ((void*)p) T(t); }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ template <class... Args>
+ void construct(T const* p, BOOST_FWD_REF(Args)... args)
+ {
+ new ((void*)p) T(boost::forward<Args>(args)...);
+ }
+#endif
+
+ void destroy(T const* p) { p->~T(); }
+
+ size_type max_size() const { return 1000; }
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) || \
+ BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+ public:
+ allocator& operator=(allocator const&) { return *this; }
+#else
+ private:
+ allocator& operator=(allocator const&);
+#endif
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+ ampersand_operator_used operator&() const
+ {
+ return ampersand_operator_used();
+ }
+#endif
+ };
+
+ template <class T>
+ inline bool operator==(allocator<T> const&, allocator<T> const&)
+ {
+ return true;
+ }
+
+ template <class T>
+ inline bool operator!=(allocator<T> const&, allocator<T> const&)
+ {
+ return false;
+ }
+
+ template <class T> void swap(allocator<T>&, allocator<T>&) {}
+
+ // C++11 allocator
+ //
+ // Not a fully minimal C++11 allocator, just what I support. Hopefully will
+ // cut down further in the future.
+
+ template <class T> class cxx11_allocator
+ {
+ public:
+ typedef T value_type;
+ // template <class U> struct rebind { typedef cxx11_allocator<U> other; };
+
+ cxx11_allocator() {}
+ template <class Y> cxx11_allocator(cxx11_allocator<Y> const&) {}
+ cxx11_allocator(cxx11_allocator const&) {}
+ ~cxx11_allocator() {}
+
+ T* address(T& r) { return &r; }
+ T const* address(T const& r) { return &r; }
+
+ T* allocate(std::size_t n)
+ {
+ return static_cast<T*>(::operator new(n * sizeof(T)));
+ }
+
+ template <class Y> T* allocate(std::size_t n, const_ptr<Y>)
+ {
+ return static_cast<T*>(::operator new(n * sizeof(T)));
+ }
+
+ void deallocate(T* p, std::size_t) { ::operator delete((void*)p); }
+
+ void construct(T* p, T const& t) { new ((void*)p) T(t); }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+ {
+ new ((void*)p) T(boost::forward<Args>(args)...);
+ }
+#endif
+
+ void destroy(T* p) { p->~T(); }
+
+ std::size_t max_size() const { return 1000u; }
+ };
+
+ template <class T>
+ inline bool operator==(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+ {
+ return true;
+ }
+
+ template <class T>
+ inline bool operator!=(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+ {
+ return false;
+ }
+
+ template <class T> void swap(cxx11_allocator<T>&, cxx11_allocator<T>&) {}
+ }
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace boost {
+#else
+namespace test {
+ namespace minimal {
+#endif
+ std::size_t hash_value(test::minimal::copy_constructible_equality_comparable)
+ {
+ return 1;
+ }
+#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+}
+}
+#else
+ }
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/src/boost/libs/unordered/test/objects/test.hpp b/src/boost/libs/unordered/test/objects/test.hpp
new file mode 100644
index 00000000..7ce21fa9
--- /dev/null
+++ b/src/boost/libs/unordered/test/objects/test.hpp
@@ -0,0 +1,700 @@
+
+// Copyright 2006-2009 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_OBJECTS_HEADER)
+#define BOOST_UNORDERED_TEST_OBJECTS_HEADER
+
+#include "../helpers/count.hpp"
+#include "../helpers/fwd.hpp"
+#include "../helpers/memory.hpp"
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <cstddef>
+
+namespace test {
+ // Note that the default hash function will work for any equal_to (but not
+ // very well).
+ class object;
+ class movable;
+ class implicitly_convertible;
+ class hash;
+ class less;
+ class equal_to;
+ template <class T> class allocator1;
+ template <class T> class allocator2;
+ object generate(object const*, random_generator);
+ movable generate(movable const*, random_generator);
+ implicitly_convertible generate(
+ implicitly_convertible const*, random_generator);
+
+ inline void ignore_variable(void const*) {}
+
+ class object : private counted_object
+ {
+ friend class hash;
+ friend class equal_to;
+ friend class less;
+ int tag1_, tag2_;
+
+ public:
+ explicit object(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
+
+ ~object()
+ {
+ tag1_ = -1;
+ tag2_ = -1;
+ }
+
+ friend bool operator==(object const& x1, object const& x2)
+ {
+ return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
+ }
+
+ friend bool operator!=(object const& x1, object const& x2)
+ {
+ return x1.tag1_ != x2.tag1_ || x1.tag2_ != x2.tag2_;
+ }
+
+ friend bool operator<(object const& x1, object const& x2)
+ {
+ return x1.tag1_ < x2.tag1_ ||
+ (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
+ }
+
+ friend object generate(object const*, random_generator g)
+ {
+ int* x = 0;
+ return object(generate(x, g), generate(x, g));
+ }
+
+ friend std::ostream& operator<<(std::ostream& out, object const& o)
+ {
+ return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+ }
+ };
+
+ class movable : private counted_object
+ {
+ friend class hash;
+ friend class equal_to;
+ friend class less;
+ int tag1_, tag2_;
+
+ BOOST_COPYABLE_AND_MOVABLE(movable)
+ public:
+ explicit movable(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
+
+ movable(movable const& x)
+ : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+ {
+ BOOST_TEST(x.tag1_ != -1);
+ }
+
+ movable(BOOST_RV_REF(movable) x)
+ : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+ {
+ BOOST_TEST(x.tag1_ != -1);
+ x.tag1_ = -1;
+ x.tag2_ = -1;
+ }
+
+ movable& operator=(BOOST_COPY_ASSIGN_REF(movable) x) // Copy assignment
+ {
+ BOOST_TEST(x.tag1_ != -1);
+ tag1_ = x.tag1_;
+ tag2_ = x.tag2_;
+ return *this;
+ }
+
+ movable& operator=(BOOST_RV_REF(movable) x) // Move assignment
+ {
+ BOOST_TEST(x.tag1_ != -1);
+ tag1_ = x.tag1_;
+ tag2_ = x.tag2_;
+ x.tag1_ = -1;
+ x.tag2_ = -1;
+ return *this;
+ }
+
+ ~movable()
+ {
+ tag1_ = -1;
+ tag2_ = -1;
+ }
+
+ friend bool operator==(movable const& x1, movable const& x2)
+ {
+ BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
+ return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
+ }
+
+ friend bool operator!=(movable const& x1, movable const& x2)
+ {
+ BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
+ return x1.tag1_ != x2.tag1_ || x1.tag2_ != x2.tag2_;
+ }
+
+ friend bool operator<(movable const& x1, movable const& x2)
+ {
+ BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
+ return x1.tag1_ < x2.tag1_ ||
+ (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
+ }
+
+ friend movable generate(movable const*, random_generator g)
+ {
+ int* x = 0;
+ return movable(generate(x, g), generate(x, g));
+ }
+
+ friend std::ostream& operator<<(std::ostream& out, movable const& o)
+ {
+ return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+ }
+ };
+
+ class implicitly_convertible : private counted_object
+ {
+ int tag1_, tag2_;
+
+ public:
+ explicit implicitly_convertible(int t1 = 0, int t2 = 0)
+ : tag1_(t1), tag2_(t2)
+ {
+ }
+
+ operator object() const { return object(tag1_, tag2_); }
+
+ operator movable() const { return movable(tag1_, tag2_); }
+
+ friend implicitly_convertible generate(
+ implicitly_convertible const*, random_generator g)
+ {
+ int* x = 0;
+ return implicitly_convertible(generate(x, g), generate(x, g));
+ }
+
+ friend std::ostream& operator<<(
+ std::ostream& out, implicitly_convertible const& o)
+ {
+ return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+ }
+ };
+
+ // Note: This is a deliberately bad hash function.
+ class hash
+ {
+ int type_;
+
+ public:
+ hash() : type_(0) {}
+
+ explicit hash(int t) : type_(t) {}
+
+ std::size_t operator()(object const& x) const
+ {
+ int result;
+ switch (type_) {
+ case 1:
+ result = x.tag1_;
+ break;
+ case 2:
+ result = x.tag2_;
+ break;
+ default:
+ result = x.tag1_ + x.tag2_;
+ }
+ return static_cast<std::size_t>(result);
+ }
+
+ std::size_t operator()(movable const& x) const
+ {
+ int result;
+ switch (type_) {
+ case 1:
+ result = x.tag1_;
+ break;
+ case 2:
+ result = x.tag2_;
+ break;
+ default:
+ result = x.tag1_ + x.tag2_;
+ }
+ return static_cast<std::size_t>(result);
+ }
+
+ std::size_t operator()(int x) const
+ {
+ int result;
+ switch (type_) {
+ case 1:
+ result = x;
+ break;
+ case 2:
+ result = x * 7;
+ break;
+ default:
+ result = x * 256;
+ }
+ return static_cast<std::size_t>(result);
+ }
+
+ friend bool operator==(hash const& x1, hash const& x2)
+ {
+ return x1.type_ == x2.type_;
+ }
+
+ friend bool operator!=(hash const& x1, hash const& x2)
+ {
+ return x1.type_ != x2.type_;
+ }
+ };
+
+ std::size_t hash_value(test::object const& x) { return hash()(x); }
+
+ std::size_t hash_value(test::movable const& x) { return hash()(x); }
+
+ class less
+ {
+ int type_;
+
+ public:
+ explicit less(int t = 0) : type_(t) {}
+
+ bool operator()(object const& x1, object const& x2) const
+ {
+ switch (type_) {
+ case 1:
+ return x1.tag1_ < x2.tag1_;
+ case 2:
+ return x1.tag2_ < x2.tag2_;
+ default:
+ return x1 < x2;
+ }
+ }
+
+ bool operator()(movable const& x1, movable const& x2) const
+ {
+ switch (type_) {
+ case 1:
+ return x1.tag1_ < x2.tag1_;
+ case 2:
+ return x1.tag2_ < x2.tag2_;
+ default:
+ return x1 < x2;
+ }
+ }
+
+ std::size_t operator()(int x1, int x2) const { return x1 < x2; }
+
+ friend bool operator==(less const& x1, less const& x2)
+ {
+ return x1.type_ == x2.type_;
+ }
+ };
+
+ class equal_to
+ {
+ int type_;
+
+ public:
+ equal_to() : type_(0) {}
+
+ explicit equal_to(int t) : type_(t) {}
+
+ bool operator()(object const& x1, object const& x2) const
+ {
+ switch (type_) {
+ case 1:
+ return x1.tag1_ == x2.tag1_;
+ case 2:
+ return x1.tag2_ == x2.tag2_;
+ default:
+ return x1 == x2;
+ }
+ }
+
+ bool operator()(movable const& x1, movable const& x2) const
+ {
+ switch (type_) {
+ case 1:
+ return x1.tag1_ == x2.tag1_;
+ case 2:
+ return x1.tag2_ == x2.tag2_;
+ default:
+ return x1 == x2;
+ }
+ }
+
+ std::size_t operator()(int x1, int x2) const { return x1 == x2; }
+
+ friend bool operator==(equal_to const& x1, equal_to const& x2)
+ {
+ return x1.type_ == x2.type_;
+ }
+
+ friend bool operator!=(equal_to const& x1, equal_to const& x2)
+ {
+ return x1.type_ != x2.type_;
+ }
+
+ friend less create_compare(equal_to x) { return less(x.type_); }
+ };
+
+ // allocator1 only has the old fashioned 'construct' method and has
+ // a few less typedefs. allocator2 uses a custom pointer class.
+
+ template <class T> class allocator1
+ {
+ public:
+ int tag_;
+
+ typedef T value_type;
+
+ template <class U> struct rebind
+ {
+ typedef allocator1<U> other;
+ };
+
+ allocator1() : tag_(0) { detail::tracker.allocator_ref(); }
+
+ explicit allocator1(int t) : tag_(t) { detail::tracker.allocator_ref(); }
+
+ template <class Y> allocator1(allocator1<Y> const& x) : tag_(x.tag_)
+ {
+ detail::tracker.allocator_ref();
+ }
+
+ allocator1(allocator1 const& x) : tag_(x.tag_)
+ {
+ detail::tracker.allocator_ref();
+ }
+
+ ~allocator1() { detail::tracker.allocator_unref(); }
+
+ T* allocate(std::size_t n)
+ {
+ T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+ detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+ return ptr;
+ }
+
+ T* allocate(std::size_t n, void const*)
+ {
+ T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+ detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+ return ptr;
+ }
+
+ void deallocate(T* p, std::size_t n)
+ {
+ detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
+ ::operator delete((void*)p);
+ }
+
+#if BOOST_UNORDERED_CXX11_CONSTRUCTION
+ template <typename U, typename... Args> void construct(U* p, Args&&... args)
+ {
+ detail::tracker.track_construct((void*)p, sizeof(U), tag_);
+ new (p) U(boost::forward<Args>(args)...);
+ }
+
+ template <typename U> void destroy(U* p)
+ {
+ detail::tracker.track_destroy((void*)p, sizeof(U), tag_);
+ p->~U();
+
+ // Work around MSVC buggy unused parameter warning.
+ ignore_variable(&p);
+ }
+#else
+ private:
+ // I'm going to claim in the documentation that construct/destroy
+ // is never used when C++11 support isn't available, so might as
+ // well check that in the text.
+ // TODO: Or maybe just disallow them for values?
+ template <typename U> void construct(U* p);
+ template <typename U, typename A0> void construct(U* p, A0 const&);
+ template <typename U, typename A0, typename A1>
+ void construct(U* p, A0 const&, A1 const&);
+ template <typename U, typename A0, typename A1, typename A2>
+ void construct(U* p, A0 const&, A1 const&, A2 const&);
+ template <typename U> void destroy(U* p);
+
+ public:
+#endif
+
+ bool operator==(allocator1 const& x) const { return tag_ == x.tag_; }
+
+ bool operator!=(allocator1 const& x) const { return tag_ != x.tag_; }
+
+ enum
+ {
+ is_select_on_copy = false,
+ is_propagate_on_swap = false,
+ is_propagate_on_assign = false,
+ is_propagate_on_move = false
+ };
+ };
+
+ template <class T> class ptr;
+ template <class T> class const_ptr;
+
+ struct void_ptr
+ {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+ template <typename T> friend class ptr;
+
+ private:
+#endif
+
+ void* ptr_;
+
+ public:
+ void_ptr() : ptr_(0) {}
+
+ template <typename T> explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+
+ // I'm not using the safe bool idiom because the containers should be
+ // able to cope with bool conversions.
+ operator bool() const { return !!ptr_; }
+
+ bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
+ bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
+ };
+
+ class void_const_ptr
+ {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+ template <typename T> friend class const_ptr;
+
+ private:
+#endif
+
+ void* ptr_;
+
+ public:
+ void_const_ptr() : ptr_(0) {}
+
+ template <typename T>
+ explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_)
+ {
+ }
+
+ // I'm not using the safe bool idiom because the containers should be
+ // able to cope with bool conversions.
+ operator bool() const { return !!ptr_; }
+
+ bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
+ bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
+ };
+
+ template <class T> class ptr
+ {
+ friend class allocator2<T>;
+ friend class const_ptr<T>;
+ friend struct void_ptr;
+
+ T* ptr_;
+
+ ptr(T* x) : ptr_(x) {}
+
+ public:
+ ptr() : ptr_(0) {}
+ explicit ptr(void_ptr const& x) : ptr_((T*)x.ptr_) {}
+
+ T& operator*() const { return *ptr_; }
+ T* operator->() const { return ptr_; }
+ ptr& operator++()
+ {
+ ++ptr_;
+ return *this;
+ }
+ ptr operator++(int)
+ {
+ ptr tmp(*this);
+ ++ptr_;
+ return tmp;
+ }
+ ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
+ friend ptr operator+(std::ptrdiff_t s, ptr p) { return ptr<T>(s + p.ptr_); }
+ T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
+ bool operator!() const { return !ptr_; }
+
+ // I'm not using the safe bool idiom because the containers should be
+ // able to cope with bool conversions.
+ operator bool() const { return !!ptr_; }
+
+ bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
+ bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
+ bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
+ bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
+ bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
+ bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
+ };
+
+ template <class T> class const_ptr
+ {
+ friend class allocator2<T>;
+ friend struct const_void_ptr;
+
+ T const* ptr_;
+
+ const_ptr(T const* ptr) : ptr_(ptr) {}
+
+ public:
+ const_ptr() : ptr_(0) {}
+ const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+ explicit const_ptr(void_const_ptr const& x) : ptr_((T const*)x.ptr_) {}
+
+ T const& operator*() const { return *ptr_; }
+ T const* operator->() const { return ptr_; }
+ const_ptr& operator++()
+ {
+ ++ptr_;
+ return *this;
+ }
+ const_ptr operator++(int)
+ {
+ const_ptr tmp(*this);
+ ++ptr_;
+ return tmp;
+ }
+ const_ptr operator+(std::ptrdiff_t s) const { return const_ptr(ptr_ + s); }
+ friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
+ {
+ return ptr<T>(s + p.ptr_);
+ }
+ T const& operator[](int s) const { return ptr_[s]; }
+ bool operator!() const { return !ptr_; }
+ operator bool() const { return !!ptr_; }
+
+ bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
+ bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
+ bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
+ bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
+ bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
+ bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
+ };
+
+ template <class T> class allocator2
+ {
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+ public:
+#else
+ template <class> friend class allocator2;
+#endif
+ int tag_;
+
+ public:
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef void_ptr void_pointer;
+ typedef void_const_ptr const_void_pointer;
+ typedef ptr<T> pointer;
+ typedef const_ptr<T> const_pointer;
+ typedef T& reference;
+ typedef T const& const_reference;
+ typedef T value_type;
+
+ template <class U> struct rebind
+ {
+ typedef allocator2<U> other;
+ };
+
+ allocator2() : tag_(0) { detail::tracker.allocator_ref(); }
+
+ explicit allocator2(int t) : tag_(t) { detail::tracker.allocator_ref(); }
+
+ template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
+ {
+ detail::tracker.allocator_ref();
+ }
+
+ allocator2(allocator2 const& x) : tag_(x.tag_)
+ {
+ detail::tracker.allocator_ref();
+ }
+
+ ~allocator2() { 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 p(static_cast<T*>(::operator new(n * sizeof(T))));
+ detail::tracker.track_allocate((void*)p.ptr_, n, sizeof(T), tag_);
+ return p;
+ }
+
+ 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)
+ {
+ detail::tracker.track_deallocate((void*)p.ptr_, n, sizeof(T), tag_);
+ ::operator delete((void*)p.ptr_);
+ }
+
+ 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 <class... 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)();
+ }
+
+ bool operator==(allocator2 const& x) const { return tag_ == x.tag_; }
+
+ bool operator!=(allocator2 const& x) const { return tag_ != x.tag_; }
+
+ enum
+ {
+ is_select_on_copy = false,
+ is_propagate_on_swap = false,
+ is_propagate_on_assign = false,
+ is_propagate_on_move = false
+ };
+ };
+
+ template <class T>
+ bool equivalent_impl(
+ allocator1<T> const& x, allocator1<T> const& y, test::derived_type)
+ {
+ return x == y;
+ }
+
+ template <class T>
+ bool equivalent_impl(
+ allocator2<T> const& x, allocator2<T> const& y, test::derived_type)
+ {
+ return x == y;
+ }
+}
+
+#endif
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-08 07:44:21 +0000