#ifndef MultiBase_h__
#define MultiBase_h__


#include <boost/thread.hpp>
#include <string>
#include <map>
#include <QString>
#include <QMap>

template <class T>
class CMultiBase
{

public:
	class PTR
	{

	public:
		PTR(T* ptr){
			m_PTR = ptr;
		}

		~PTR(){
			if (m_PTR != 0){
				m_PTR->m_mutexlock.unlock_shared();
			}
		}

		bool valid(){
			if (m_PTR != 0)
				return true;
			
			return false;
		}

		T* operator->() { return m_PTR; }

	private:
		T* m_PTR;
	};

protected:
	static boost::recursive_mutex        m_mutex_instancemap;
	static std::map<std::string, T*>  m_mapInstances;
	QString m_strInstanceName;
	boost::shared_mutex   m_mutexlock;

public:
	CMultiBase(const QString& strInstanceName)
	{
		m_strInstanceName = strInstanceName;
	};

	virtual ~CMultiBase(void)
	{

	};

	virtual void Close()
	{
		return;
	};

	static void createinstance(const QString& strInstanceName)
	{

		boost::recursive_mutex::scoped_lock lock(m_mutex_instancemap);

		if (strInstanceName.isEmpty())
			return;

		std::string sname = strInstanceName.toStdString();
		typename std::map<std::string, T*>::iterator itr;
		itr = m_mapInstances.find(sname);

		if (itr == m_mapInstances.end())
		{
			m_mapInstances[sname] = new T(strInstanceName);
		}
	};

	static T* getinstance(const QString& strInstanceName)
	{
		boost::recursive_mutex::scoped_lock lock(m_mutex_instancemap);

		if (strInstanceName.isEmpty())
			return 0;

		std::string sname = strInstanceName.toStdString();
		typename std::map<std::string, T*>::iterator itr;
		itr = m_mapInstances.find(sname);

		if (itr != m_mapInstances.end())
		{
			itr->second->m_mutexlock.lock_shared();
			return itr->second;
		}
		else
		{
			return 0;
		}

	};

	static void uninstance(const QString& strInstanceName)
	{
		boost::recursive_mutex::scoped_lock lock(m_mutex_instancemap);

		if (strInstanceName.isEmpty())
			return;

		std::string sname = strInstanceName.toStdString();
		typename std::map<std::string, T*>::iterator itr;
		itr = m_mapInstances.find(sname);

		if (itr != m_mapInstances.end())
		{
			T* pptr = itr->second;
			pptr->m_mutexlock.lock();
			pptr->m_mutexlock.unlock();
			m_mapInstances.erase(itr);
			pptr->Close();
		}
	};

	static void uninstanceall()
	{
		boost::recursive_mutex::scoped_lock lock(m_mutex_instancemap);

		for (typename std::map<std::string, T*>::iterator itr = m_mapInstances.begin(); itr != m_mapInstances.end();)
		{
			T* pptr = itr->second;
			pptr->m_mutexlock.lock();
			pptr->m_mutexlock.unlock();
			m_mapInstances.erase(itr++);
			pptr->Close();
		}

	};
};




template <class T>
std::map<std::string, T*>  CMultiBase<T>::m_mapInstances;
template <class T>
boost::recursive_mutex  CMultiBase<T>::m_mutex_instancemap;


#endif // MultiBase_h__