//! A base abstract class to manage heap memory use.
/*!
 Part of the memory management module. Holds a list of all newly created objects and also handles
 Garbarge Collection. Concept taken from
 <A HREF="http://www.gamedev.net/reference/articles/article1954.asp">Enginuity, Part II</A>.
 \sa MMPointer, MMDynamicBlob and MMBlob.
*/
#ifndef MMOBJECT_H
#define MMOBJECT_H

#include <list>

namespace yaustar
{
	class MMObject
	{
		private:
		//! A list of pointers to hold all the 'Live' objects.
		/*!
		 This list holds a pointer to all newly created objects that derieve from MMObject.
		*/
		static std::list<MMObject *> LiveObjects;

		//! A list of pointers to hold all the 'Dead' objects.
		/*!
		 This list holds a pointer to all objects that derieve from MMObject which are no longer
		 needed by any part of the program.
		*/
		static std::list<MMObject *> DeadObjects;

		//! Reference Counter.
		/*!
		 Keeps count of how many pointers are asscoiated with this object. When it is 0, it is moved
		 to the DeadObjects list.
		*/
		unsigned long RefCount;

		public:
		//! Constructor.
		/*!
		 Defaults the RefCount to 0 and adds itself to the LiveObjects list.
		*/
		MMObject(void);

		//! Destructor.
		/*!
		 Does nothing. Zip, nada, sweet FA.
		*/
		virtual ~MMObject(void)
		{
			// Do nothing
		}

		//! Increments RefCount by 1.
		void AddRef(void)
		{
			++RefCount;
		}

		//! Decreases RefCount by 1.
		void Release(void)
		{
			--RefCount;
			// Check if the RefCount is 0, if it is then move to the DeadObjects list
			if(RefCount <= 0)
			{
				LiveObjects.remove(this);
				DeadObjects.push_back(this);
			}
		}

		//! Frees up memory used by Dead Objects.
		/*!
		 Tranverses through the list of DeadObjects and destroys each object.
		*/
		static void CollectGarbarge(void);

		//! Frees up all objects dereived from this class.
		/*!
		 Tranverses through the list of LiveObjects and destroys each object. Not sure why it would
		 by used expect for the VERY end of the program in case the smart pointers don't do their
		 job.
		*/
		static void CollectAllObjects(void);

		//! Pure virtual function to get the size of the object.
		virtual unsigned long Size(void) = 0;
	};

	// Small #define to make it easier for derieved classes to implement MMObject::Size(void).
	#define AUTO_SIZE unsigned long size(void) { return sizeof(*this); }
}

#endif

//======================

#include "./MMObject.h"

using yaustar::MMObject;

// Declare the static variables
std::list <MMObject *> MMObject::LiveObjects;
std::list <MMObject *> MMObject::DeadObjects;

MMObject::MMObject(void)
{
	// Add itself to the list
	LiveObjects.push_back(this);
	// Reset the RefCount
	RefCount = 0;
}

void MMObject::CollectGarbarge(void)
{
	// For all the objects in the DeadObject list, destroy
	for(std::list <MMObject *>::iterator itr = DeadObjects.begin();
		itr != DeadObjects.end();
		++itr )
	{
		delete (*itr);
	}

	// Clear the list of pointers
	DeadObjects.clear();
}

void MMObject::CollectAllObjects(void)
{
	// Collect Garbarge
	MMObject::CollectGarbarge();

	// For all the objects in the LiveObject list, destroy
	for(std::list <MMObject *>::iterator itr = LiveObjects.begin();
		itr != LiveObjects.end();
		++itr)
	{
		delete (*itr);
	}

	// Clear the list of pointers
	LiveObjects.clear();
}