#ifndef SPECIFIC_ALLOCATOR_INL
#define SPECIFIC_ALLOCATOR_INL

#include <memory>
#include <cassert>

/// Собственный распределитель памяти
template <typename T> void allocator_construct(T* p, const T& t) { new(p) T(t); }
template <typename T> void allocator_destroy(T* p) { p -> ~T(); }

template <typename T, typename A>
struct rebind_allocator
{
    typedef typename A::template rebind<T> binder;
    typedef typename binder::other type;
};

template <typename T>
class spec_allocator
{
public:
   typedef T                value_type;
   typedef value_type*        pointer;
   typedef const T*            const_pointer;
   typedef T&                reference;
   typedef const T&            const_reference;
   typedef std::size_t        size_type;
   typedef std::ptrdiff_t    difference_type;

   template <typename Other>
   struct rebind
   { typedef spec_allocator<Other> other; };

   spec_allocator() {}
   template <typename Other> spec_allocator(const spec_allocator<Other>&) {}
   spec_allocator(const spec_allocator&) {}
   template <typename Other> spec_allocator& operator=(const spec_allocator<Other>&) { return *this; }
   ~spec_allocator() {}
   pointer address(reference x) { return &x; }
   const_pointer address(const_reference x) const { return &x; }
   pointer allocate(size_type n, const void* = 0)
   { return (n != 0) ? reinterpret_cast<pointer>(::operator new(n * sizeof(value_type))) : 0; }
   void deallocate(pointer p, size_type n)
   { 
       assert((p == 0) == (n == 0));
       ::operator delete((void*)p);
   }
   size_type max_size() const { return size_t(-1) / sizeof(value_type); }
   void construct(pointer p, const T& val) const { allocator_construct(p, val); }
   void destroy(pointer p) const { allocator_destroy(p); }
};

#endif // SPECIFIC_ALLOCATOR_INL