123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627 |
- // 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
|