#pragma once
#include "C4JMemoryPool.h"

// Custom allocator, takes a C4JMemoryPool class, which can be one of a number
// of pool implementations.

template <class T>
class C4JPoolAllocator {
public:
    typedef T value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

    typedef T* pointer;
    typedef const T* const_pointer;

    typedef T& reference;
    typedef const T& const_reference;

    //! A struct to construct an allocator for a different type.
    template <typename U>
    struct rebind {
        typedef C4JPoolAllocator<U> other;
    };

    C4JMemoryPool* m_pPool;
    bool m_selfAllocated;

    C4JPoolAllocator(C4JMemoryPool* pool = new C4JMemoryPoolFixed(32, 4096))
        : m_pPool(pool), m_selfAllocated(true) {
        printf("allocated mempool\n");
    }

    template <typename U>
    C4JPoolAllocator(C4JPoolAllocator<U> const& obj)
        : m_pPool(obj.m_pPool),
          m_selfAllocated(false)  // copy constructor
    {
        printf("C4JPoolAllocator constructed from 0x%08x\n", &obj);
        assert(obj.m_pPool);
    }

private:
public:
    ~C4JPoolAllocator() {
        if (m_selfAllocated) delete m_pPool;
    }

    pointer address(reference r) const { return &r; }
    const_pointer address(const_reference r) const { return &r; }

    pointer allocate(size_type n, const void* /*hint*/ = 0) {
        assert(m_pPool);
        return (pointer)m_pPool->Alloc(n * sizeof(T));
    }

    void deallocate(pointer p, size_type /*n*/) {
        assert(m_pPool);
        m_pPool->Free(p);
    }

    void construct(pointer p, const T& val) { new (p) T(val); }

    void destroy(pointer p) { p->~T(); }

    size_type max_size() const { return ULONG_MAX / sizeof(T); }
};

template <class T>
bool operator==(const C4JPoolAllocator<T>& left,
                const C4JPoolAllocator<T>& right) {
    if (left.m_pPool == right.m_pPool) {
        return true;
    }
    return false;
}

template <class T>
bool operator!=(const C4JPoolAllocator<T>& left,
                const C4JPoolAllocator<T>& right) {
    if (left.m_pPool != right.m_pPool) {
        return true;
    }
    return false;
}