| |
| // 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 <boost/config.hpp> |
| #include <boost/limits.hpp> |
| #include <cstddef> |
| #include "../helpers/fwd.hpp" |
| #include "../helpers/count.hpp" |
| #include "../helpers/memory.hpp" |
| |
| 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*); |
| movable generate(movable const*); |
| implicitly_convertible generate(implicitly_convertible const*); |
| |
| 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*) { |
| int* x = 0; |
| return object(generate(x), generate(x)); |
| } |
| |
| 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*) { |
| int* x = 0; |
| return movable(generate(x), generate(x)); |
| } |
| |
| 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*) { |
| int* x = 0; |
| return implicitly_convertible(generate(x), generate(x)); |
| } |
| |
| 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: |
| explicit hash(int t = 0) : type_(t) {} |
| |
| std::size_t operator()(object const& x) const { |
| switch(type_) { |
| case 1: |
| return x.tag1_; |
| case 2: |
| return x.tag2_; |
| default: |
| return x.tag1_ + x.tag2_; |
| } |
| } |
| |
| std::size_t operator()(movable const& x) const { |
| switch(type_) { |
| case 1: |
| return x.tag1_; |
| case 2: |
| return x.tag2_; |
| default: |
| return x.tag1_ + x.tag2_; |
| } |
| } |
| |
| std::size_t operator()(int x) const { |
| return x; |
| } |
| |
| 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: |
| explicit equal_to(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==(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; }; |
| |
| explicit allocator1(int t = 0) : 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* u) |
| { |
| 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); |
| } |
| |
| void construct(T* p, T const& t) { |
| // Don't count constructions here as it isn't always called. |
| //detail::tracker.track_construct((void*) p, sizeof(T), tag_); |
| new(p) T(t); |
| } |
| |
| void destroy(T* p) { |
| //detail::tracker.track_destroy((void*) p, sizeof(T), tag_); |
| p->~T(); |
| |
| // Work around MSVC buggy unused parameter warning. |
| ignore_variable(&p); |
| } |
| |
| 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; }; |
| |
| explicit allocator2(int t = 0) : 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* u) |
| { |
| 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 |