#ifndef __HEAP_H__
#define __HEAP_H__

#include "types.h"
#include "tlsf.h"

class Heap
{
	public:
		Heap(void* baseAddress, size_t size) {
			_mp = tlsf_create(baseAddress, size);
		}

		~Heap() {
			tlsf_destroy(_mp);
		}

		void* Allocate(size_t size) {
			return tlsf_malloc(_mp, size);
		}

		void* AllocateAligned(size_t alignment, size_t bytes) {
			return tlsf_memalign(_mp, alignment, bytes);
		}

		void* AllocateN(size_t nelem, size_t elem_size) {
			return tlsf_malloc(_mp, nelem * elem_size);
		}

		void* AllocateNAligned(size_t alignment, size_t nelem, size_t elem_size) {
			return tlsf_memalign(_mp, alignment, nelem * elem_size);
		}

		void Release(void* ptr) {
			tlsf_free(_mp, ptr);
		}

		void* Reallocate(void* ptr, size_t size) {
			return tlsf_realloc(_mp, ptr, size);
		}

		void* ReallocateAligned(void* ptr, size_t alignment, size_t size) {
			return tlsf_realloc_aligned(_mp, ptr, alignment, size);
		}

		bool Damaged(void) {
			return (tlsf_check_heap(_mp) != 0) ? true : false;
		}

		// Returns internal block size, not original request size */
		size_t BlockSize(void* ptr) {
			return tlsf_block_size(ptr);
		}

		// Overhead of per-pool internal structures.
		size_t Overhead(void) {
			return tlsf_overhead();
		}

	private:

		tlsf_pool	_mp;
};

#endif // __HEAP_H__