#ifndef SPECIFIC_ALLOCATOR_INL
#define SPECIFIC_ALLOCATOR_INL

#include <memory>
#include <cassert>

#define CHUNK_SIZE 4096

/// Собственный распределитель памяти
template <typename T> class pool_alloc: public std::allocator<T>
{
private:
    static const difference_type chunk_size = CHUNK_SIZE;
    struct Link { Link* next; };
    struct Chunk
    {
        Chunk* next;
        char memory[chunk_size];
    };
    Link* head;
    Chunk* chunks;
    static const size_type elem_size = (sizeof(T) < sizeof(Link*)) ? sizeof(Link*) : sizeof(T);
    static const size_type num_elem = chunk_size / elem_size;

private:
    void grow(bool special = false)            ///< увеличиваем пулл
    {
        Chunk* n = new Chunk;
        n -> next = chunks;
        chunks = n;

        char* start = n -> memory;
        char* last = &n -> memory[(num_elem - 1) * elem_size];
        for(char* p=start; p<last; p+=elem_size)
            reinterpret_cast<Link*> (p) -> next = reinterpret_cast<Link*> (p + elem_size);
        reinterpret_cast<Link*> (last) -> next = (special) ? head : 0;
        head = reinterpret_cast<Link*> (start);
    }

public:
    pool_alloc() throw(): head(0), chunks(0) {}
    pointer allocate(size_type n)            ///< выделяем память под n элементов типа T
    {
        if(n * elem_size > chunk_size) throw "Unsuccessfully memory allotment";
        if(!head) grow();
        else if(n != 1) grow(true);
        Link* p = head;
        while(n--) head = head -> next;
        return reinterpret_cast<pointer> (p);
    }
    void deallocate(pointer p, size_type n) ///< возвращаем память в пулл
    {
        while(n--)
        {
            reinterpret_cast<Link*> (p) -> next = head;
            head = reinterpret_cast<Link*> (p);
        }
    }
    ~pool_alloc() throw()
    {
        Chunk* n = chunks;
        while(n)
        {
            Chunk* p = n;
            n = n -> next;
            delete p;
        }
    }
    template <typename Other> struct rebind
    { typedef pool_alloc<Other> other; };
    template <typename Other> pool_alloc(const pool_alloc<Other>& p) throw() { head = 0, chunks = 0; }
    template <typename Other> pool_alloc<T>& operator=(const pool_alloc<Other>&)
    { head = 0; chunks = 0; return *this; }
    pool_alloc(const pool_alloc<T>& p) throw() { head = 0, chunks = 0; }
};

#endif // SPECIFIC_ALLOCATOR_INL