GainputAllocator.h

#ifndef GAINPUTALLOCATOR_H_
#define GAINPUTALLOCATOR_H_

namespace gainput
{


class GAINPUT_LIBEXPORT Allocator
{
public:
    enum { DefaultAlign = 0 };


    virtual void* Allocate(size_t size, size_t align = DefaultAlign) = 0;

    virtual void Deallocate(void* ptr) = 0;


    template <class T>
    T* New()
    {
        return new (Allocate(sizeof(T))) T();
    }


    template <class T, class P0>
    T* New(P0& p0)
    {
        return new (Allocate(sizeof(T))) T(p0);
    }


    template <class T, class P0>
    T* New(const P0& p0)
    {
        return new (Allocate(sizeof(T))) T(p0);
    }


    template <class T, class P0, class P1>
    T* New(P0& p0, P1& p1)
    {
        return new (Allocate(sizeof(T))) T(p0, p1);
    }


    template <class T, class P0, class P1>
    T* New(const P0& p0, P1& p1)
    {
        return new (Allocate(sizeof(T))) T(p0, p1);
    }


    template <class T, class P0, class P1>
    T* New(P0& p0, const P1& p1)
    {
        return new (Allocate(sizeof(T))) T(p0, p1);
    }


    template <class T, class P0, class P1, class P2>
    T* New(P0& p0, const P1& p1, const P2& p2)
    {
        return new (Allocate(sizeof(T))) T(p0, p1, p2);
    }


    template <class T, class P0, class P1, class P2>
    T* New(P0& p0, const P1& p1, P2& p2)
    {
        return new (Allocate(sizeof(T))) T(p0, p1, p2);
    }


    template <class T, class P0, class P1, class P2, class P3>
    T* New(P0& p0, P1& p1, P2& p2, P3& p3)
    {
        return new (Allocate(sizeof(T))) T(p0, p1, p2, p3);
    }


    template <class T, class P0, class P1, class P2, class P3>
    T* New(P0& p0, const P1& p1, P2& p2, P3& p3)
    {
        return new (Allocate(sizeof(T))) T(p0, p1, p2, p3);
    }


    template <class T, class P0, class P1, class P2, class P3, class P4>
    T* New(P0& p0, P1& p1, P2& p2, P3& p3, P4& p4)
    {
        return new (Allocate(sizeof(T))) T(p0, p1, p2, p3, p4);
    }


    template <class T, class P0, class P1, class P2, class P3, class P4>
    T* New(P0& p0, const P1& p1, P2& p2, P3& p3, P4& p4)
    {
        return new (Allocate(sizeof(T))) T(p0, p1, p2, p3, p4);
    }


    template <class T>
    void Delete(T* ptr)
    {
        if (ptr)
        {
            ptr->~T();
            Deallocate(ptr);
        }
    }
};


class GAINPUT_LIBEXPORT DefaultAllocator : public Allocator
{
public:
    void* Allocate(size_t size, size_t /*align*/)
    {
        return malloc(size);
    }

    void Deallocate(void* ptr)
    {
        free(ptr);
    }
};


GAINPUT_LIBEXPORT DefaultAllocator& GetDefaultAllocator();

template<class K, class V>
class GAINPUT_LIBEXPORT HashMap;


class GAINPUT_LIBEXPORT TrackingAllocator : public Allocator
{
public:
    TrackingAllocator(Allocator& backingAllocator, Allocator& internalAllocator = GetDefaultAllocator());
    ~TrackingAllocator();

    void* Allocate(size_t size, size_t align = DefaultAlign);
    void Deallocate(void* ptr);

    size_t GetAllocateCount() const { return allocateCount_; }
    size_t GetDeallocateCount() const { return deallocateCount_; }
    size_t GetAllocatedMemory() const { return allocatedMemory_; }

private:
    Allocator& backingAllocator_;
    Allocator& internalAllocator_;
    HashMap<void*, size_t>* allocations_;
    size_t allocateCount_;
    size_t deallocateCount_;
    size_t allocatedMemory_;
};



}

#endif