Programming

#ifndef ABSTRACTSINGLETONFACTORY_H
#define ABSTRACTSINGLETONFACTORY_H

#include <map>

// forward declaration
template<typename T, typename, typename, T> class AbstractSingletonSubclass;

/**
 * Template class AbstractSingletonFactory
 *
 * Template params:
 *
 *   IDT - sub-class ID type, must be comparable, used to look-up a factory
 *           for each registered sub-class.
 *
 *   BCT - base class type -- the base class from which each sub-class shall
 *           inherit.
 *
 */
template<typename IDT, typename BCT> class AbstractSingletonFactory
{
	// friend to allow registration of sub-classes
	template<typename T, typename, typename, T> friend class AbstractSingletonSubclass;
	
public:
	AbstractSingletonFactory()
	{
	}
	
	~AbstractSingletonFactory()
	{
		typename std::map<IDT, BCT *>::iterator it;
		
		for (it = _singletonMap.begin(); it != _singletonMap.end(); ++it)
		{
			delete it->second;
		}
	}
	
	BCT *getSingletonInstance(IDT forId)
	{
		BCT *instance;
		
		typename std::map<IDT, BCT *>::iterator it;
		if ((it = _singletonMap.find(forId)) != _singletonMap.end())
		{
			instance = it->second;
		}
		else
		{
			IAbstractSingletonFactory *factory =
						AbstractSingletonFactory<IDT, BCT>::GetDirectory().getSubclassFactory(forId);
			
			instance = factory != NULL ? factory->createSubclassInstance() : NULL;
			
			if (instance)
			{
				_singletonMap.insert(std::pair<IDT, BCT *>(forId, instance));
			}
		}		
				
		return instance;
	}
	
private:
	class IAbstractSingletonFactory
	{
	public:
		virtual BCT *createSubclassInstance() = 0;
	};
	
	class SubclassDirectory
	{	
	public:
		SubclassDirectory()
		{
		}
		
		void setSubclassFactory(IDT forId, IAbstractSingletonFactory *factory)
		{
			_scFactoryMap.insert(
				std::pair<IDT, IAbstractSingletonFactory *>(forId, factory));
		}
		
		IAbstractSingletonFactory *getSubclassFactory(IDT forId)
		{
			IAbstractSingletonFactory *factory;
			
			typename std::map<IDT, IAbstractSingletonFactory *>::iterator it;
		
			if ((it = _scFactoryMap.find(forId)) != _scFactoryMap.end())
			{
				factory = it->second;
			}
			else
			{
				factory = NULL;
			}
			
			return factory;
		}
		
	private:		
		std::map<IDT, IAbstractSingletonFactory *> _scFactoryMap;
	};
	
	static void RegisterSubclassId(IDT id, IAbstractSingletonFactory *factory)
	{
		AbstractSingletonFactory<IDT, BCT>::GetDirectory().setSubclassFactory(id, factory);		
	}
	
	static SubclassDirectory &GetDirectory()
	{
		static SubclassDirectory theDirectory;
		
		return theDirectory;
	}
	
	std::map<IDT, BCT *> _singletonMap;
};

#endif // ABSTRACTSINGLETONFACTORY_H

#ifndef ABSTRACTSINGLETONSUBCLASS_H
#define ABSTRACTSINGLETONSUBCLASS_H

#include "AbstractSingletonFactory.H"

template<typename IDT, typename BCT, typename SCT, IDT SCID> class AbstractSingletonSubclass
{
protected:	
	static void AbstractSingletonSubclassInit()
	{		
		AbstractSingletonFactory<IDT, BCT>::RegisterSubclassId(SCID, &_factory);
	}
	
	class InitAbstractSingletonSubclass
	{
	public:
		InitAbstractSingletonSubclass()
		{
			AbstractSingletonSubclassInit();
		}
	};
	
private:
	class Factory : public AbstractSingletonFactory<IDT, BCT>::IAbstractSingletonFactory
	{
	private:
		BCT *createSubclassInstance()
		{
			return new SCT;
		}
	};
	
	static Factory _factory;
};

template<typename IDT, typename BCT, typename SCT, IDT SCID>
typename AbstractSingletonSubclass<IDT, BCT, SCT, SCID>::Factory
AbstractSingletonSubclass<IDT, BCT, SCT, SCID>::_factory;

#endif  // ABSTRACTSINGLETONSUBCLASS_H

class NewClassBase
{
public:
	virtual int getId() = 0;

// boilerplate destructor and friendship to insure only factory can delete
protected:
	template<typename, typename> friend class AbstractSingletonFactory;	
	virtual ~NewClassBase()
	{
		std::cout << "Destroying NewClassBase @ " << this << std::endl;
	}
};

template<typename SCT, int SCID> class NewClassBaseSubclassBase :
	public NewClassBase,
	protected AbstractSingletonSubclass<int, NewClassBase, SCT, SCID>
{
};

class NewSubclass1 : public NewClassBaseSubclassBase<NewSubclass1, 1>
{
public:
	virtual int getId() { return 1; }
	
// boilerplate initialization stub to register with AbstractSingletonFactory
private:
	static InitAbstractSingletonSubclass _initStub;
};

NewSubclass1::InitAbstractSingletonSubclass NewSubclass1::_initStub;

class NewSubclass2 : public NewClassBaseSubclassBase<NewSubclass2, 2>
{
public:
	virtual int getId() { return 2; }
	
// boilerplate initialization stub to register with AbstractSingletonFactory
private:
	static InitAbstractSingletonSubclass _initStub;
};

NewSubclass2::InitAbstractSingletonSubclass NewSubclass2::_initStub;

static void TestNewBaseClass(AbstractSingletonFactory<int, NewClassBase> &abFactory)
{
	std::cout << std::endl
			  << "================================================================================"
			  << std::endl << std::endl
			  << "testing new base class..." <<
			  std::endl;
	
	for (int i = 1; i <= 2; i++)
	{
		NewClassBase *ncb = abFactory.getSingletonInstance(i);
	
		std::cout << "NCB[" << i << "] @ " << ncb << "; id=" << ncb->getId() << std::endl;
	}
}

int main(int argc, char **argv)
{
	AbstractSingletonFactory<int, NewClassBase> abFactory;
	
	TestNewBaseClass(abFactory);
}