ss/include/nw4r/snd/snd_InstancePool.h

#ifndef NW4R_SND_INSTANCE_POOL_H
#define NW4R_SND_INSTANCE_POOL_H
#include <nw4r/types_nw4r.h>

namespace nw4r {
namespace snd {
namespace detail {

class PoolImpl {
public:
    PoolImpl() : mNext(NULL) {}

protected:
    u32 CreateImpl(void* pBuffer, u32 size, u32 stride);
    void DestroyImpl(void* pBuffer, u32 size);
    int CountImpl() const;

    void* AllocImpl();
    void FreeImpl(void* pElem);

private:
    PoolImpl* mNext; // at 0x0
};

template <typename T> class InstancePool : private PoolImpl {
public:
    u32 Create(void* pBuffer, u32 size) {
        return CreateImpl(pBuffer, size, sizeof(T));
    }

    void Destroy(void* pPtr, u32 size) {
        DestroyImpl(pPtr, size);
    }

    int Count() const {
        return CountImpl();
    }

    T* Alloc() {
        void* pPtr = AllocImpl();
        if (pPtr == NULL) {
            return NULL;
        }

        return new (pPtr) T;
    }

    void Free(T* pElem) {
        if (pElem != NULL) {
            pElem->~T();
            FreeImpl(pElem);
        }
    }
};

template <typename T> class MemoryPool : private PoolImpl {
public:
    u32 Create(void* pBuffer, u32 size) {
        return CreateImpl(pBuffer, size, sizeof(T));
    }

    void Destroy(void* pPtr, u32 size) {
        DestroyImpl(pPtr, size);
    }

    int Count() const {
        return CountImpl();
    }

    T* Alloc() {
        return static_cast<T*>(AllocImpl());
    }

    void Free(T* pElem) {
        FreeImpl(pElem);
    }
};

} // namespace detail
} // namespace snd
} // namespace nw4r

#endif