#include "stdafx.h"

class kxMemoryChunk
{
public: // Methods

	// *******************************************************************************************
	kxMemoryChunk(size_t size = 0)
	{
		if(size == 0) 	{ 
			return; 
		}

		m_Data =  malloc(size);
		m_Size = size;
	}

	// *******************************************************************************************
	~kxMemoryChunk()
	{
		
	}

	// Pretizeni lokalniho new 
	void* operator new(size_t size)
	{	
		if(m_Count == 0) // Musime inicializovat begin a end
		{
			m_Begin.m_Prev = NULL;
			m_Begin.m_Next = &m_End;

			m_End.m_Prev = &m_Begin;
			m_End.m_Next = NULL;
		}

		
		// Linknuti
		kxMemoryChunk* ptr = (kxMemoryChunk*)malloc(size);
		ptr->m_Prev = m_End.m_Prev;
		ptr->m_Next = &m_End;
		m_End.m_Prev->m_Next = ptr;
		m_End.m_Prev = ptr;
		m_Count++;
		

		return ptr;
	}

	// Pretizeni lokalniho delete
	void operator delete(void* ptr)  
	{
		kxMemoryChunk* chunk = (kxMemoryChunk*)ptr;

		if(m_Count == 1)
		{
			m_Begin.m_Prev = m_Begin.m_Next = m_End.m_Prev = m_End.m_Next = NULL; // sichr je sichr
		}
		// Unlinknuti
		chunk->m_Prev->m_Next = chunk->m_Next;
		chunk->m_Next->m_Prev = chunk->m_Prev;
		
		free(ptr);
		m_Count--;
	}

	// Dalsi prasarna 
	static kxMemoryChunk* GetBegin()
	{
		return &m_Begin;
	}

	// Dalsi prasarna
	static kxMemoryChunk* GetEnd()
	{
		return &m_End;
	}

	// Pocet prvku
	static unsigned long int GetCount()
	{
		return m_Count;
	}

	static void Delete(void* data_ptr)
	{
		kxMemoryChunk* tmp = m_Begin.m_Next;
		while(tmp != &m_End)
		{
			if(tmp->m_Data == data_ptr)
			{
				delete tmp;
				return;
			}
		}
	}

public:  // DATA
	kxMemoryChunk* m_Prev;
	kxMemoryChunk* m_Next;
	void* m_Data;
	size_t m_Size;

protected: // Vsechno zverstvo se deje zde...
	static kxMemoryChunk m_Begin;
	static kxMemoryChunk m_End;
	static unsigned long int m_Count; 
} ;

// Inicializace statickych clenskych promennych
unsigned long int kxMemoryChunk::m_Count = 0;







// Pretizeni globalniho new
static void* operator new(size_t size)
{
	kxMemoryChunk* tmp = new kxMemoryChunk(size);
	if(tmp->m_Data == NULL) // Pokud se nam nepodarilo alokovat data
	{
		delete tmp;
		return NULL;
	}

	return tmp->m_Data;
}




// Pretizeni globalniho delete
static void operator delete(void* ptr)
{
	kxMemoryChunk::Delete(ptr);
}