forked from boostorg/unordered
Remove more of the old unordered containers test files.
[SVN r2878]
This commit is contained in:
Daniel James
@@ -1,376 +0,0 @@
|
||||
|
||||
// Copyright Daniel James 2005. Use, modification, and distribution are
|
||||
// subject to 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_HELPERS_ALLOCATOR_HEADER)
|
||||
#define BOOST_UNORDERED_TEST_HELPERS_ALLOCATOR_HEADER
|
||||
|
||||
#include <iosfwd>
|
||||
#include <cstddef>
|
||||
#include <boost/limits.hpp>
|
||||
|
||||
namespace test
|
||||
{
|
||||
struct allocator_base
|
||||
{
|
||||
typedef std::size_t size_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
|
||||
int tag;
|
||||
|
||||
allocator_base(int x);
|
||||
allocator_base(allocator_base const&);
|
||||
~allocator_base();
|
||||
|
||||
size_type max_size() const;
|
||||
|
||||
void* allocate(size_type, void const*, size_type);
|
||||
void construct(void*);
|
||||
void destroy(void*);
|
||||
void deallocate(void*, size_type);
|
||||
void swap(allocator_base&);
|
||||
private:
|
||||
allocator_base& operator=(allocator_base const&);
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream&, allocator_base const&);
|
||||
bool allocator_equals(allocator_base const& x, allocator_base const& y);
|
||||
|
||||
template <class T>
|
||||
struct allocator : allocator_base
|
||||
{
|
||||
typedef T* pointer;
|
||||
typedef T const* const_pointer;
|
||||
typedef T& reference;
|
||||
typedef T const& const_reference;
|
||||
typedef T value_type;
|
||||
|
||||
template <class T1>
|
||||
struct rebind
|
||||
{
|
||||
typedef allocator<T1> other;
|
||||
};
|
||||
|
||||
pointer address(reference x) const
|
||||
{
|
||||
return &x;
|
||||
}
|
||||
|
||||
const_pointer address(const_reference x) const
|
||||
{
|
||||
return &x;
|
||||
}
|
||||
|
||||
allocator(int x = 1) : allocator_base(x) {}
|
||||
template <class T1>
|
||||
allocator(allocator<T1> const& x) : allocator_base(x) {}
|
||||
allocator(allocator const& x) : allocator_base(x) {}
|
||||
~allocator() {}
|
||||
|
||||
pointer allocate(size_type n, T const* hint = 0)
|
||||
{
|
||||
return static_cast<pointer>(
|
||||
allocator_base::allocate(n, hint, sizeof(T)));
|
||||
}
|
||||
|
||||
void construct(pointer ptr, T const& x)
|
||||
{
|
||||
allocator_base::construct(ptr);
|
||||
new((void*)ptr)T(x);
|
||||
}
|
||||
|
||||
void destroy(pointer ptr)
|
||||
{
|
||||
allocator_base::destroy(ptr);
|
||||
ptr->~T();
|
||||
}
|
||||
|
||||
void deallocate(pointer ptr, size_type n)
|
||||
{
|
||||
allocator_base::deallocate(ptr, n);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
inline bool operator==(allocator<T> const& x, allocator<T> const& y)
|
||||
{
|
||||
return test::allocator_equals(x, y);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline bool operator!=(allocator<T> const& x, allocator<T> const& y)
|
||||
{
|
||||
return !test::allocator_equals(x, y);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void swap(allocator<T>& x, allocator<T>& y)
|
||||
{
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
allocator<T> create_allocator(allocator<T>*)
|
||||
{
|
||||
return allocator<T>();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
allocator<T> create_allocator(allocator<T>*, int x)
|
||||
{
|
||||
return allocator<T>(x);
|
||||
}
|
||||
|
||||
template <class T> struct minimal_allocator;
|
||||
typedef unsigned short minimal_size_type;
|
||||
|
||||
template <class Ptr, class T>
|
||||
class minimal_pointer_base
|
||||
{
|
||||
protected:
|
||||
typedef minimal_pointer_base<Ptr, T> pointer_base;
|
||||
minimal_pointer_base() : ptr_(0) {}
|
||||
explicit minimal_pointer_base(T* ptr) : ptr_(ptr) {}
|
||||
~minimal_pointer_base() {}
|
||||
Ptr& get() { return *static_cast<Ptr*>(this); }
|
||||
T* ptr_;
|
||||
public:
|
||||
typedef void (minimal_pointer_base::*bool_type)() const;
|
||||
void this_type_does_not_support_comparisons() const {}
|
||||
|
||||
T& operator*() const { return *ptr_; }
|
||||
T* operator->() const { return ptr_; }
|
||||
Ptr& operator++() { ++ptr_; return get(); }
|
||||
Ptr operator++(int) { Ptr tmp(get()); ++ptr_; return tmp; }
|
||||
|
||||
Ptr operator+(minimal_size_type s) const
|
||||
{
|
||||
return Ptr(ptr_ + s);
|
||||
}
|
||||
|
||||
T& operator[](minimal_size_type s) const
|
||||
{
|
||||
return ptr_[s];
|
||||
}
|
||||
|
||||
operator bool_type() const
|
||||
{
|
||||
return ptr_ ?
|
||||
&minimal_pointer_base::this_type_does_not_support_comparisons
|
||||
: 0;
|
||||
}
|
||||
|
||||
bool operator!() 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_; }
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& out, minimal_pointer_base const& x)
|
||||
{
|
||||
out<<x.ptr_;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> class minimal_pointer;
|
||||
template <class T> class minimal_const_pointer;
|
||||
|
||||
template <class T>
|
||||
class minimal_pointer
|
||||
: public minimal_pointer_base<minimal_pointer<T>, T>
|
||||
{
|
||||
friend struct minimal_allocator<T>;
|
||||
friend class minimal_pointer_base<minimal_pointer<T>, T>;
|
||||
friend class minimal_const_pointer<T>;
|
||||
typedef typename minimal_pointer::pointer_base base;
|
||||
minimal_pointer(T* ptr) : base(ptr) {}
|
||||
|
||||
typedef minimal_const_pointer<T> const_pointer;
|
||||
typedef minimal_pointer<T> pointer;
|
||||
public:
|
||||
minimal_pointer() : base() {}
|
||||
|
||||
bool operator==(pointer const& x) const { return base::operator==(x); }
|
||||
bool operator!=(pointer const& x) const { return base::operator!=(x); }
|
||||
bool operator<(pointer const& x) const { return base::operator<(x);}
|
||||
bool operator>(pointer const& x) const { return base::operator>(x);}
|
||||
bool operator<=(pointer const& x) const { return base::operator<=(x);}
|
||||
bool operator>=(pointer const& x) const { return base::operator<=(x);}
|
||||
|
||||
bool operator==(const_pointer const& x) const { return x == *this; }
|
||||
bool operator!=(const_pointer const& x) const { return x != *this; }
|
||||
bool operator<(const_pointer const& x) const { return x > *this; }
|
||||
bool operator>(const_pointer const& x) const { return x < *this; }
|
||||
bool operator<=(const_pointer const& x) const { return x >= *this; }
|
||||
bool operator>=(const_pointer const& x) const { return x <= *this; }
|
||||
};
|
||||
|
||||
template <class T>
|
||||
class minimal_const_pointer
|
||||
: public minimal_pointer_base<minimal_const_pointer<T>, T const>
|
||||
{
|
||||
friend struct minimal_allocator<T>;
|
||||
friend class minimal_pointer_base<minimal_const_pointer<T>, T const>;
|
||||
typedef typename minimal_const_pointer::pointer_base base;
|
||||
minimal_const_pointer(T* ptr) : base(ptr) {}
|
||||
|
||||
typedef minimal_const_pointer<T> const_pointer;
|
||||
typedef minimal_pointer<T> pointer;
|
||||
public:
|
||||
minimal_const_pointer() : base() {}
|
||||
minimal_const_pointer(minimal_pointer<T> const& x) : base(x.ptr_) {}
|
||||
|
||||
bool operator==(const_pointer const& x) const { return base::operator==(x); }
|
||||
bool operator!=(const_pointer const& x) const { return base::operator!=(x); }
|
||||
bool operator<(const_pointer const& x) const { return base::operator<(x);}
|
||||
bool operator>(const_pointer const& x) const { return base::operator>(x);}
|
||||
bool operator<=(const_pointer const& x) const { return base::operator<=(x);}
|
||||
bool operator>=(const_pointer const& x) const { return base::operator<=(x);}
|
||||
|
||||
bool operator==(pointer const& x) const { return operator==(const_pointer(x)); }
|
||||
bool operator!=(pointer const& x) const { return operator!=(const_pointer(x)); }
|
||||
bool operator<(pointer const& x) const { return operator<(const_pointer(x));}
|
||||
bool operator>(pointer const& x) const { return operator>(const_pointer(x));}
|
||||
bool operator<=(pointer const& x) const { return operator<=(const_pointer(x));}
|
||||
bool operator>=(pointer const& x) const { return operator<=(const_pointer(x));}
|
||||
};
|
||||
|
||||
struct minimal_allocator_base
|
||||
{
|
||||
typedef minimal_size_type size_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
|
||||
int tag;
|
||||
|
||||
minimal_allocator_base(int x);
|
||||
minimal_allocator_base(minimal_allocator_base const&);
|
||||
~minimal_allocator_base();
|
||||
|
||||
size_type max_size() const;
|
||||
|
||||
void* allocate(size_type, void const*, size_type);
|
||||
void construct(void*);
|
||||
void destroy(void*);
|
||||
void deallocate(void*, size_type);
|
||||
void swap(minimal_allocator_base&);
|
||||
private:
|
||||
minimal_allocator_base& operator=(minimal_allocator_base const&);
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream&, minimal_allocator_base const&);
|
||||
bool allocator_equals(minimal_allocator_base const&, minimal_allocator_base const&);
|
||||
|
||||
template <class T>
|
||||
struct minimal_allocator : minimal_allocator_base
|
||||
{
|
||||
typedef minimal_pointer<T> pointer;
|
||||
typedef minimal_const_pointer<T> const_pointer;
|
||||
typedef T& reference;
|
||||
typedef T const& const_reference;
|
||||
typedef T value_type;
|
||||
|
||||
template <class U>
|
||||
struct rebind
|
||||
{
|
||||
typedef minimal_allocator<U> other;
|
||||
};
|
||||
|
||||
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*>(
|
||||
minimal_allocator_base::allocate(n, 0, sizeof(T))));
|
||||
}
|
||||
|
||||
pointer allocate(size_type n, const_pointer u)
|
||||
{
|
||||
return pointer(static_cast<T*>(
|
||||
minimal_allocator_base::allocate(n, u.ptr_, sizeof(T))));
|
||||
}
|
||||
|
||||
void deallocate(pointer p, size_type n)
|
||||
{
|
||||
minimal_allocator_base::deallocate(p.ptr_, n);
|
||||
}
|
||||
|
||||
minimal_allocator()
|
||||
: minimal_allocator_base(0)
|
||||
{
|
||||
}
|
||||
|
||||
explicit minimal_allocator(int tag)
|
||||
: minimal_allocator_base(tag)
|
||||
{
|
||||
}
|
||||
|
||||
template <class Y>
|
||||
minimal_allocator(minimal_allocator<Y> const& x)
|
||||
: minimal_allocator_base(x)
|
||||
{
|
||||
}
|
||||
|
||||
minimal_allocator(minimal_allocator const& x)
|
||||
: minimal_allocator_base(x)
|
||||
{
|
||||
}
|
||||
|
||||
void construct(pointer p, T const& t)
|
||||
{
|
||||
minimal_allocator_base::construct(p.ptr_);
|
||||
new((void*)p.ptr_) T(t);
|
||||
}
|
||||
|
||||
void destroy(pointer p)
|
||||
{
|
||||
minimal_allocator_base::destroy(p.ptr_);
|
||||
((T*)p.ptr_)->~T();
|
||||
}
|
||||
private:
|
||||
minimal_allocator& operator=(minimal_allocator const&);
|
||||
};
|
||||
|
||||
template <class T>
|
||||
inline bool operator==(minimal_allocator<T> const& x, minimal_allocator<T> const& y)
|
||||
{
|
||||
return test::allocator_equals(x, y);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline bool operator!=(minimal_allocator<T> const& x, minimal_allocator<T> const& y)
|
||||
{
|
||||
return !test::allocator_equals(x, y);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void swap(minimal_allocator<T>& x, minimal_allocator<T>& y)
|
||||
{
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
minimal_allocator<T> create_allocator(minimal_allocator<T>*)
|
||||
{
|
||||
return minimal_allocator<T>();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
minimal_allocator<T> create_allocator(minimal_allocator<T>*, int x)
|
||||
{
|
||||
return minimal_allocator<T>(x);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user