1 files changed, 627 insertions, 0 deletions
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 000000000..b89e0af82
--- /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