Gérer ses données en C++

/*!
 * \brief Interface des gestionnaires de données.
 */
class IGesData
{
protected:
	/*!
	 * \brief Constructeur.
	 */
	IGesData();
	
	/*!
	 * \brief Destructeur.
	 */
	virtual ~IGesData();
};

/*!
 * \brief Gestionnaire d'entités de type T.
 *
 * \tparam T Le type de donnée à gérer.
 */
template<class T>
class CGesData : public IGesData // Un gestionnaire de T, dont T sera un livre, un auteur etc...
{
public:
	// Les méthodes de manipulation des T
};

template<class T>
class CGesData : public IGesData
{
public:
	/*!
	 * \brief Obtient le nombre de données.
	 *
	 * \return le nombre de données.
	 */
	unsigned long GetCount() const;

	/*!
	 * \brief Obtient une donnée par son index.
	 *
	 * \param ulIndex L'index.
	 * \return La donnée.
	 */
	T* GetAt(unsigned long ulIndex) const;

private:
	/*!
	 * \brief Ajoute une série de données.
	 *
	 * \param poData Un pointeur vers le tableau des données à ajouter.
	 * \param ulCount Le nombre de données.
	 */
	void AddData(CData<T>** poData, unsigned long ulCount);
	
	/*!
	 * \brief Retire une série de données.
	 *
	 * \param poData Un pointeur vers le tableau des données à retirer.
	 * \param ulCount Le nombre de données.
	 */
	void RemoveData(CData<T>** poData, unsigned long ulCount);
	
	typedef std::vector<CData<T>*> TVecDatas; /*!< Type du stockage des données. */
	TVecDatas m_vecData; /*!< Liste des données. */
};

template<class T>
unsigned long CGesData<T>::GetCount() const
{
	return static_cast<unsigned long>(m_vecData.size());
}

template<class T>
T* CGesData<T>::GetAt(unsigned long ulIndex) const
{
	return static_cast<T*>(m_vecData[ulIndex]);
}

template<class T>
void CGesData<T>::AddData(CData<T>** poData, unsigned long ulCount)
{
	std::copy(poData, poData + ulCount, std::back_inserter(m_vecData));
}

template<class T>
void CGesData<T>::RemoveData(CData<T>** poData, unsigned long ulCount)
{
	for(unsigned long ulDataIt = 0; ulDataIt < ulCount; ulDataIt)
		m_vecData.erase(std::remove(m_vecData.begin(), m_vecData.end(), poData[ulDataIt]), m_vecData.end());
}

template<class T>
class CGesData : public IGesData, public CSingleton<CGesData<T>>

class CGesManager : public CSingleton<CGesManager>
{
public
	template<class T> unsigned long GetCount()
	{
		if(stdcmp(CDataTrait<T>::CODE, "BOOK") == 0)
			return m_gesBooks.GetCount();
		else if(stdcmp(CDataTrait<T>::CODE, "AUTHOR") == 0)
			return m_gesAuthors.GetCount();
		else if(stdcmp(CDataTrait<T>::CODE, "EDITOR") == 0)
			return m_gesEditors.GetCount();
		else
			throw ... ;
	}
	
private:
	CGesData<CBook> m_gesBooks;
	CGesData<CAuthor> m_gesAuthors;
	CGesData<CEditor> m_gesEditors;
};

class CGesManager : public CSingleton<CGesManager>,
				public CGesData<CBook>,
				public CGesData<CAuthor>,
				public CGesData<CEditor>
{
public
	template<class T> unsigned long GetCount();
};

template<class T>
CGesManager::GetCount()
{
	return CGesData<T>::GetCount();
}

template<class T>
class CGesData : public IGesData
{
public:
	/*!
	 * \brief Enregistre une propriété.
	 *
	 * \param rstrPropertyName Le nom de la propriété.
	 * \param memPropertyPtr Le pointeur de membre de la propriété.
	 */
	void RegisterPropertyMemPtr(const std::string& rstrPropertyName, typename IProperty T::*memPropertyPtr);
	
	/*!
	 * \brief Obtient la propriété d'une donnée, par son nom.
	 *
	 * \param poData La donnée.
	 * \param rstrPropertyName Le nom de la propriété.
	 * \return La propriété.
	 */
	IProperty* GetProperty(CData<T>* poData, const std::string& rstrPropertyName);

private:
	typedef std::map<std::string, typename IProperty T::*> TMapPropertiesMemPtr; /*!< Type du mapping des propriétés et leur nom. */
	TMapPropertiesMemPtr m_mapPropertiesMemPtr; /*!< Mapping des propriétés et de leur nom. */
};

template<class T> void CGesData<T>::RegisterPropertyMemPtr(const std::string& rstrPropertyName, typename IProperty T::*memPropertyPtr)
{
#ifdef _DEBUG
	if(m_mapPropertiesMemPtr.find(rstrPropertyName) != m_mapPropertiesMemPtr.end())
		Log << "La propriété " << rstrPropertyName << " de " << CDataTrait<T>::CODE << " est déjà enregistrée\r\n";
#endif
	m_mapPropertiesMemPtr[rstrPropertyName] = memPropertyPtr;
}

template<class T> IProperty* CGesData<T>::GetProperty(CData<T>* poData, const std::string& rstrPropertyName)
{
	if(m_mapPropertiesMemPtr.size() == 0)
		throw CPropertiesNotRegistredException(CDataTrait<T>::CODE);

	TMapPropertiesMemPtr::const_iterator it = m_mapPropertiesMemPtr.find(rstrPropertyName);
	if(it == m_mapPropertiesMemPtr.end())
		throw CPropertyNotFoundException(CDataTrait<T>::CODE, rstrPropertyName);

	return &(((T*)poData)->*(it->second));
}

/*!
 * \brief Structure d'enregistrement des propriétés d'un type donnée.
 *
 * \tparam Le type de donnée.
 */
template<class T>
struct SPropertyRegistrer
{
	/*!
	 * \brief Enregistre les propriétés du type T.
	 */
	static void RegisterProperties();
};

template<> void SPropertyRegistrer<CBook>::RegisterProperties()
{
	GesMgr.RegisterPropertyMemPtr<CBook>("ID", reinterpret_cast<IProperty CBook::*>(&CBook::m_ulIdent));
};

#define BEGIN_PROPERTY_MAP(Class) \
	template<> void SPropertyRegistrer<Class>::RegisterProperties() {
	
#define REG_PROPERTY(Class, Key, Prop) GesMgr.RegisterPropertyMemPtr<Class>(Key, reinterpret_cast<IProperty Class::*>(&Class::Prop));

#define END_PROPERTY_MAP() }

BEGIN_PROPERTY_MAP(CBook)
	REG_PROPERTY(CBook, "ID", m_ulIdent)
	REG_PROPERTY(CBook, "TITLE", m_strTitle)
	REG_PROPERTY(CBook, "DESCRIPTION", m_strDescription)
	REG_PROPERTY(CBook, "YEAR", m_uiYear)
	REG_PROPERTY(CBook, "ID_EDITOR", m_ulIdentEditor)
	REG_PROPERTY(CBook, "ID_AUTHOR", m_ulIdentAuthor)
END_PROPERTY_MAP()

#define MAKE_DATA(Class) \
	friend struct SPropertyRegistrer<Class>;

class CBook : public CData<CBook>
{
MAKE_DATA(CBook)

public:
	unsigned _int64 GetIdent() const;

	const std::string& GetTitle() const;
	void SetTitle(const std::string& rstrTitle);

	const std::string& GetDescription() const;
	void SetDescription(const std::string& rstrDescription);

	unsigned int GetYear() const;
	void SetYear(unsigned int uiYear);

private:
	TUInt64Property m_ulIdent;
	TStringProperty m_strTitle;
	TStringProperty m_strDescription;
	TUInt32Property m_uiYear;
	TUInt64Property m_ulIdentAuthor;
};

BEGIN_PROPERTY_MAP(CBook)
	REG_PROPERTY(CBook, "ID", m_ulIdent)
	REG_PROPERTY(CBook, "TITLE", m_strTitle)
	REG_PROPERTY(CBook, "DESCRIPTION", m_strDescription)
	REG_PROPERTY(CBook, "YEAR", m_uiYear)
	REG_PROPERTY(CBook, "ID_AUTHOR", m_ulIdentAuthor)
END_PROPERTY_MAP()

unsigned _int64 CBook::GetIdent() const
{
	return m_ulIdent;
}

const std::string& CBook::GetTitle() const
{
	return m_strTitle;
}

void CBook::SetTitle(const std::string& rstrTitle)
{
	m_strTitle = rstrTitle;
}

const std::string& CBook::GetDescription() const
{
	return m_strDescription;
}

void CBook::SetDescription(const std::string& rstrDescription)
{
	m_strDescription = rstrDescription;
}

unsigned int CBook::GetYear() const
{
	return m_uiYear;
}

void CBook::SetYear(unsigned int uiYear)
{
	m_uiYear = uiYear;
}

class IData
{
public:
	/*!
	 * \brief Obtient une propriété de cette donnée, par son nom.
	 *
	 * \return La propriété.
	 */
	virtual IProperty* GetProperty(const std::string& rstrPropertyName) = 0;
};

template<class T>
class CData : public IData
{
public:
	/*!
	 * \brief Obtient une propriété de cette donnée, par son nom.
	 *
	 * \return La propriété.
	 */
	virtual IProperty* GetProperty(const std::string& rstrPropertyName);
};

template <class T>
IProperty* CData<T>::GetProperty(const std::string& rstrPropertyName)
{
	return CGesManager::GetInstance().GetProperty(this, rstrPropertyName);
}

template<class T>
class CGesData : public IGesData
{
public:
	/*!
	 * \brief Enregistre une propriété identifiante.
	 *
	 * \param rstrPropertyName Le nom de la propriété identifiante.
	 */
	void RegisterIdent(const std::string& rstrPropertyName);

private:
	typedef std::vector<std::string> TVecIdents; /*!< Type de stockage des noms de propriétés identifiantes. */
	TVecIdents m_vecIdents; /*!< Propriétés identifiantes. */
};

template<class T> void CGesData<T>::RegisterIdent(const std::string& rstrPropertyName)
{
#ifdef _DEBUG
	if(m_mapPropertiesMemPtr.find(rstrPropertyName) == m_mapPropertiesMemPtr.end())
		Log << "La propriété identifiante " << rstrPropertyName << " de " << CDataTrait<T>::CODE << " n'est pas une propriété\r\n";
#endif
	m_vecIdents.push_back(rstrPropertyName);
}

template<class T>
struct SIdentRegistrer
{
	static void RegisterIdents();
};

#define BEGIN_IDENT_LIST(Class) \
	template<> void SIdentRegistrer<Class>::RegisterIdents() {

#define REG_IDENT(Class, Prop) CGesManager::GetInstance().RegisterIdent<Class>(Key);

#define END_IDENT_LIST() }

BEGIN_IDENT_LIST(CBook)
	REG_IDENT(CBook, "ID")
END_IDENT_LIST()

#define MAKE_DATA(Class) \
	friend struct SPropertyRegistrer<Class>; \
	friend struct SIdentRegistrer<Class>;

template<class T>
class CGesData : public IGesData
{
public:
	/*!
	 * \brief Obtient une donnée par son/ses identifiant(s).
	 *
	 * \param mapIdents Les couples identifiant/valeur.
	 * \return La donnée si elle a été trouvé sinon 0.
	 */
	T* GetFromIdentsStr(std::map<std::string, std::string>& mapIdents);
	
	/*!
	 * \brief Obtient une donnée par son/ses identifiant(s).
	 *
	 * \param mapIdents Les couples identifiant/valeur.
	 * \return La donnée si elle a été trouvé sinon 0.
	 */
	T* GetFromIdents(std::map<std::string, IProperty&>& mapIdents);
};

template<class T> T* CGesData<T>::GetFromIdentsStr(std::map<std::string, std::string>& mapIdents)
{
	TVecDatas::iterator it = m_vecData.begin();
	while(it != m_vecData.end())
	{
		bool bFound = true;
		TVecIdents::iterator itIdents = m_vecIdents.begin();
		while(itIdents != m_vecIdents.end())
		{
			if((((T*)(*it))->*m_mapPropertiesMemPtr[*itIdents]).ToString() != mapIdents[*itIdents])
			{
				bFound = false;
				break;
			}
			++itIdents;
		}

		if(bFound)
			return static_cast<T*>(*it);

		++it;
	}

	return 0;
}
	
template<class T> T* CGesData<T>::GetFromIdents(std::map<std::string, IProperty&>& mapIdents)
{
	std::map<std::string, std::string> stringMap;

	std::map<std::string, IProperty*>::iterator it = mapIdents.begin();
	while(it != mapIdents.end())
	{
		stringMap[it->first] = it->second.ToString();
		++it;
	}

	return *(GetFromIdents(stringMap));
}

template<class T>
class CDataIterator
{
public:
	/*!
	 * \brief Constructeur.
	 */
	CDataIterator();

	/*!
	 * \brief Obtient la donnée courante.
	 *
	 * \return La donnée courante.
	 */
	CData<T>* GetData() const;

	/*!
	 * \brief Poursuite la lecture.
	 */
	void Next();

private:
	typename CGesData<T>::TVecDatas& m_vecData; /*!< Les données surlesquelles itérer. */
	typename CGesData<T>::TVecDatas::const_iterator m_iter; /*!< L'itérateur interne. */
};

template<class T>
CDataIterator<T>::CDataIterator()
	: m_vecData(((CGesData<T>*)(&CGesManager::GetInstance()))->m_vecData)
{
	m_iter = m_vecData.begin();
}

template<class T>
CData<T>* CDataIterator<T>::GetData() const
{
	return m_iter == m_vecData.end() ? 0 : *m_iter;
}

template<class T>
void CDataIterator<T>::Next()
{
	++m_iter;
}

CDataIterator<CBook> iter;
T* currentData = 0;
while((currentData = iter.GetData()) != 0)
{
	std::cout << currentData->GetTitle();
	iter.Next();
}

// L'opérateur =
CUnaryEqualFilter::CUnaryEqualFilter(const std::string& strPropertyName, const IProperty* pProperty)
	: m_pProperty(pProperty), m_strPropertyName(strPropertyName)
{

}
bool CUnaryEqualFilter::IsOk(const IData& rData) const
{
	return (*(rData.GetProperty(m_strPropertyName))).Compare(*m_pProperty) == 0;
}

// La liste :
void CUnaryFilterList::AddFilter(IUnaryFilter* pFilter)
{
	m_vecFilters.push_back(pFilter);
}
void CUnaryFilterList::RemoveFilter(IUnaryFilter* pFilter)
{
	m_vecFilters.erase(std::remove(m_vecFilters.begin(), m_vecFilters.end(), pFilter), m_vecFilters.end());
}

// Le AND
bool CUnaryAndFilter::IsOk(const kin::IData& rData) const
{
	std::vector<IUnaryFilter*>::const_iterator it = m_vecFilters.begin();
	while(it != m_vecFilters.end())
	{
		if(!(*it)->IsOk(rData))
			return false;
		++it;
	}
	return true;
}

// Le OR
bool CUnaryOrFilter::IsOk(const kin::IData& rData) const
{
	std::vector<IUnaryFilter*>::const_iterator it = m_vecFilters.begin();
	while(it != m_vecFilters.end())
	{
		if((*it)->IsOk(rData))
			return true;
		++it;
	}
	return false;
}

CUnaryOrFilter* p1914OrFilter = new CUnaryOrFilter(); // >= 1914
p1914OrFilter->AddFilter(new CUnaryEqualFilter("YEAR", &TUIntProperty(1914)));
p1914OrFilter->AddFilter(new CUnaryGreaterFilter("YEAR", &TUIntProperty(1914)));

CUnaryOrFilter* p1918OrFilter = new CUnaryOrFilter(); // <= 1918
p1918OrFilter->AddFilter(new CUnaryEqualFilter("YEAR", &TUIntProperty(1918)));
p1918OrFilter->AddFilter(new CUnarySmallerFilter("YEAR", &TUIntProperty(1918)));

CUnaryAndFilter* pFirstAndFilter = new CUnaryAndFilter(); // >= 1914 AND <= 1918
pFirstAndFilter->AddFilter(p1914OrFilter);
pFirstAndFilter->AddFilter(p1918OrFilter);

CUnaryOrFilter* p1939OrFilter = new CUnaryOrFilter(); // >= 1939
p1939OrFilter->AddFilter(new CUnaryEqualFilter("YEAR", &TUIntProperty(1939)));
p1939OrFilter->AddFilter(new CUnaryGreaterFilter("YEAR", &TUIntProperty(1939)));

CUnaryOrFilter* p1945OrFilter = new CUnaryOrFilter(); // <= 1945
p1945OrFilter->AddFilter(new CUnaryEqualFilter("YEAR", &TUIntProperty(1945)));
p1945OrFilter->AddFilter(new CUnaryGreaterFilter("YEAR", &TUIntProperty(1945)));

CUnaryAndFilter* pSecondAndFilter = new CUnaryAndFilter(); // >= 1939 AND <= 1945
pFirstAndFilter->AddFilter(p1939OrFilter);
pFirstAndFilter->AddFilter(p1945OrFilter);

CUnaryAndFilter* pFilter = new CUnaryAndFilter(); // (>= 1914 AND <= 1918) OR (>= 1939 AND <= 1945)
pFilter->AddFilter(pFirstAndFilter);
pFilter->AddFilter(pSecondAndFilter);

template<class T>
class CUnaryQuery
{
friend class CUnaryResultsIterator<T>;

public:
	/*!
	 * \brief Constructeur.
	 *
	 * \param poFilter Le filtre utilisé pour effectuer la requête.
	 */
	CUnaryQuery(IUnaryFilter* poFilter);
		
	/*!
	 * \brief Lance la requête.
	 */
	void Query();

private:
	IUnaryFilter* m_pFilter; /*!< Le filtre interne. */

	typedef std::vector<CData<T>*> TVecResults; /*!< Type de stockage des résultats. */
	TVecResults m_vecResults; /*!< Les résultats. */
};

template<class T>
CUnaryQuery<T>::CUnaryQuery(IUnaryFilter* poFilter)
	: m_pFilter(poFilter), m_bConnected(false)
{

}

template<class T>
void CUnaryQuery<T>::Query()
{
	CDataIterator<T> it; CData<T>* poData = 0;
	while((poData = it.GetData()) != 0)
	{
		if(m_pFilter->IsOk(*poData)) // Donnée trouvée
			m_vecResults.push_back(poData); // Nous l'ajoutons aux résultats

		ListenData(poData, true); // Nous écoutons toutes les données

		it.Next();
	}
}

/*!
 * \brief Itérateur des résultats d'une requête unaire.
 */
template<class T>
class CUnaryResultsIterator
{
public:
	/*!
	 * \brief Constructeur.
	 *
	 * \param roQuery La requête dont les résultats seront itérés.
	 */
	CUnaryResultsIterator(typename CUnaryQuery<T>& roQuery);

	/*!
	 * \brief Obtient le résultat courant.
	 *
	 * \return Le résultat courant.
	 */
	CData<T>* GetData() const;

	/*!
	 * \brief Avance la lecture.
	 */
	void Next();

private:
	typename CUnaryQuery<T>::TVecResults& m_vecResults; /*!< Les résultats sur lesquels itérer. */
	typename CUnaryQuery<T>::TVecResults::const_iterator m_iter; /*!< L'itérateur interne. */
};

template<class T>
CUnaryResultsIterator<T>::CUnaryResultsIterator(typename CUnaryQuery<T>& roQuery)
	: m_vecResults(roQuery.m_vecResults)
{
	roQuery.Query();
	m_iter = m_vecResults.begin();
}

template<class T>
CData<T>* CUnaryResultsIterator<T>::GetData() const
{
	return m_iter == m_vecResults.end() ? 0 : *m_iter;
}

template<class T>
void CUnaryResultsIterator<T>::Next()
{
	++m_iter;
}

// Construction puis exécution de la requête "mémoire"
CUnaryQuery<CBook> myQuery(pFilter);
myQuery.Query();

// Puis parcours des résultats
CUnaryResultsIterator<CBook> it(myQuery);
CBook* pData = 0;
while((pData = it.GetData()) != 0)
{
	//Résultat courant dans pData
	it.Next();
}

/*!
 * \brief Interface d'écoute d'une requête unaire.
 */
template<class T>
class IQueryListener
{
friend class CUnaryQuery<T>;

protected:
	/*!
	 * \brief Callback appelé lorsqu'un résultat a été ajouté à une requête unaire.
	 *
	 * \param poUnaryQuery La requête.
	 * \param poData Pointeur vers le tableau des éléments qui ont été ajoutés.
	 * \param ulCount Nombre des éléments ajoutés
	 */
	virtual void OnQueryResultAdded(CUnaryQuery<T>* poUnaryQuery, CData<T>** poData, unsigned long ulCount) = 0;

	/*!
	 * \brief Callback appelé lorsqu'un résultat a été retiré d'une requête unaire.
	 *
	 * \param poUnaryQuery La requête.
	 * \param poData Pointeur vers le tableau des éléments qui ont été retirés.
	 * \param ulCount Nombre des éléments retirés
	 */
	virtual void OnQueryResultRemoved(CUnaryQuery<T>* poUnaryQuery, CData<T>** poData, unsigned long ulCount) = 0;
};

template<class T>
class CUnaryQuery : public IGesDataListener<T>
{
public:
	/*!
	 * \brief Destructeur.
	 */
	void ~CUnaryQuery()
	
	/*!
	 * \brief Ajoute un écouteur à cette requête.
	 *
	 * \param poListener L'écouteur à ajouter.
	 */
	void AddListener(IQueryListener<T>* poListener);

	/*!
	 * \brief Retire un écouteur de cette requête.
	 *
	 * \param poListener L'écouteur à retirer.
	 */
	void RemoveListener(IQueryListener<T>* poListener);
	
private:
	/*!
	 * \brief Callback appelé lorsque des données ont été ajouté dans le gestionnaire.
	 *
	 * \param poData pointeur sur le tableau de donnée qui a été ajouté.
	 * \param ulCount Nombre de données ajoutées.
	 */
	virtual void OnDataAdded(CData<T>** poData, unsigned long ulCount);

	/*!
	 * \brief Callback appelé lorsque des données ont été retiré dans le gestionnaire.
	 *
	 * \param poData pointeur sur le tableau de donnée qui a été ajouté.
	 * \param ulCount Nombre de données ajoutées.
	 */
	virtual void OnDataRemoved(CData<T>** poData, unsigned long ulCount);
	
	/*!
	 * \brief Notifie les écouteurs de cette requête que des résultats ont été ajoutés.
	 *
	 * \param poData pointeur sur le tableau de donnée qui a été ajouté.
	 * \param ulCount Nombre de données ajoutées.
	 */
	void NotifyQueryResultAdded(CData<T>** poData, unsigned long ulCount);

	/*!
	 * \brief Notifie les écouteurs de cette requête que des résultats ont été retirés.
	 *
	 * \param poData pointeur sur le tableau de donnée qui a été retiré.
	 * \param ulCount Nombre de données retirées.
	 */
	void NotifyQueryResultRemoved(CData<T>** poData, unsigned long ulCount);
	
	typedef std::vector<IQueryListener<T>*> TVecListeners; /*!< Type de stockage des écouteurs. */
	TVecListeners m_vecListeners; /*!< Les écouteurs. */
	
	bool m_bConnected; /*!< Flag interne indiquant si la requête est connectée ou non aux données. */
}

template<class T>
void CUnaryQuery<T>::Query()
{
	if(m_bConnected)
		return;
		
	// Traitement de la requête
	
	// Nous écoutons le gestionnaire
	CGesManager::GetInstance().AddListener<T>(this);
	m_bConnected = true;
}

template<class T>
CUnaryQuery<T>::~CUnaryQuery()
{
	if(!m_bConnected)
		return;

	m_pFilter->RemoveListener(this);
}

template<class T>
void CUnaryQuery<T>::AddListener(IQueryListener<T>* poListener)
{
	m_vecListeners.push_back(poListener);
}

template<class T>
void CUnaryQuery<T>::RemoveListener(IQueryListener<T>* poListener)
{
	m_vecListeners.erase(std::remove(m_vecListeners.begin(), m_vecListeners.end(), poListener), m_vecListeners.end());
}

template<class T>
void CUnaryQuery<T>::NotifyQueryResultAdded(CData<T>** poData, unsigned long ulCount)
{
	std::vector<IQueryListener<T>*>::iterator it = m_vecListeners.begin();
	while(it != m_vecListeners.end())
	{
		(*it)->OnQueryResultAdded(this, poData, ulCount);
		++it;
	}
}

template<class T>
void CUnaryQuery<T>::NotifyQueryResultRemoved(CData<T>** poData, unsigned long ulCount)
{
	std::vector<IQueryListener<T>*>::iterator it = m_vecListeners.begin();
	while(it != m_vecListeners.end())
	{
		(*it)->OnQueryResultRemoved(this, poData, ulCount);
		++it;
	}
}

template<class T>
void CUnaryQuery<T>::OnDataAdded(CData<T>** poData, unsigned long ulCount)
{
	// Pour chaque donnée ajoutée, "garder" celles qui correspondent au filtre
	std::vector<CData<T>*> vecAddedData; vecAddedData.reserve(ulCount);

	for(unsigned long ulIt = 0; ulIt < ulCount; ulIt++)
	{
		if(m_pFilter->IsOk(*(poData[ulIt])))
		{
			m_vecResults.push_back(poData[ulIt]);
			vecAddedData.push_back(poData[ulIt]);
		}
		ListenData(poData[ulIt], true); // Puis nous écoutons la donnée
	}

	NotifyQueryResultAdded(&vecAddedData[0], static_cast<unsigned long>(vecAddedData.size()));
}

template<class T>
void CUnaryQuery<T>::OnDataRemoved(CData<T>** poData, unsigned long ulCount)
{
	// pour chaque donnée retirée, dégager celles qui sont stockées ici si elles ne correspondent plus au filtre
	std::vector<CData<T>*> vecRemovedData; vecRemovedData.reserve(ulCount);

	for(unsigned long ulIt = 0; ulIt < ulCount; ulIt++)
	{
		std::vector<CData<T>*>::iterator it = std::find(m_vecResults.begin(), m_vecResults.end(), poData[ulIt]);
		if(it != m_vecResults.end())
		{
			m_vecResults.erase(it);
			vecRemovedData.push_back(poData[ulIt]);
		}
		ListenData(poData[ulIt], false);
	}

	NotifyQueryResultRemoved(&vecRemovedData[0], static_cast<unsigned long>(vecRemovedData.size()));
}

1;Octave est un publicitaire blasé par le monde du maketing qui...;2000;25
2;C++ pour les Nuls;Apprenez efficacement les rouages de C++ dans un...;2006;37
3;Candide;Candide, un jeune homme à la vie heureuse, se voit basculé dans...;1759;14

<CSV>
	<BOOK>
		<FILE>Books.csv</FILE>
		<PROPERTIES>
			<PROPERTY>ID</PROPERTY>
			<PROPERTY>TITLE</PROPERTY>
			<PROPERTY>DESCRIPTION</PROPERTY>
			<PROPERTY>YEAR</PROPERTY>
			<PROPERTY>ID_AUTHOR</PROPERTY>
		</PROPERTIES>
	</BOOK>
	<AUTHOR>
		<FILE>Author.csv</FILE>
		<PROPERTIES>
			// propriétés
		</PROPERTIES>
	</AUTHOR>
</CSV>

/*!
 * \brief Mapping CSV.
 */
class CCSVMapping
{
public:
	/*!
	 * \brief Positionne le fichier de mapping.
	 *
	 * \param rstrXml Le fichier XML.
	 */
	void SetXml(const std::string& rstrXml);

	/*!
	 * \brief Obtient le mapping.
	 *
	 * \return Le mapping.
	 */
	static CCSVMapping& GetMapping();

	typedef std::vector<std::string> TVecProperties; /*!< Type de stockage des propriétés. */

	/*!
	 * \brief Obtient les propriétés d'une entité donnée.
	 *
	 * \param rstrEntity Le nom de l'entité.
	 * \return Les propriétés correspondantes.
	 */
	TVecProperties& GetProperties(const std::string& rstrEntity);

	/*!
	 * \brief Obtient le fichier des données pour une entité.
	 *
	 * \param rstrEntity Le nom de l'entité.
	 * \return Le nom du fichier de données.
	 */
	const std::string& GetFile(const std::string& rstrEntity);

private:
	/*!
	 * \brief Constructeur.
	 */
	CCSVMapping();

	/*!
	 * \brief Charge le mapping.
	 */
	void Load();

	/*!
	 * \brief Structure réunissant le fichier d'un type de données et ses propriétés.
	 */
	struct SEntityMapping
	{
		std::string m_strFile;
		TVecProperties m_vecProperties;
	};
	typedef std::map<std::string, SEntityMapping> TMapping; /*!< Type du mapping. */

	TMapping m_oMapping; /*!< Stockage du Mapping. */

	std::string m_strXml; /*!< Fichier de mapping. */
};

#define CSVMapping CCSVMapping::GetMapping()

CCSVMapping::CCSVMapping()
	: m_strXml("")
{
	
}

CCSVMapping& CCSVMapping::GetMapping()
{
	static CCSVMapping oMapping;
	return oMapping;
}

void CCSVMapping::SetXml(const std::string& rstrXml)
{
	if(m_strXml != rstrXml)
	{
		m_strXml = rstrXml;
		Load();
	}
}

void CCSVMapping::Load()
{
	m_oMapping.clear();

	if(m_strXml.size() == 0)
		return;

	xmlDocPtr doc = xmlParseFile(m_strXml.c_str());
	if(!doc)
		throw CXMLParseException(m_strXml);

	xmlNodePtr poFirstChild = doc->children;

	if(xmlStrcmp(poFirstChild->name, BAD_CAST("CSV")) != 0)
		throw CXMLReadException(m_strXml, reinterpret_cast<const char*>(poFirstChild->name), poFirstChild->line);

	xmlNodePtr poEntityNode = poFirstChild->children;
	while(poEntityNode)
	{
		if(poEntityNode->type == XML_TEXT_NODE)
			poEntityNode = poEntityNode->next;
		if(!poEntityNode)
			break;

		SEntityMapping& mapping = m_oMapping[reinterpret_cast<const char*>(poEntityNode->name)];

		xmlNodePtr poPropertiesNode = poEntityNode->children;
		while(poPropertiesNode)
		{
			if(poPropertiesNode->type == XML_TEXT_NODE)
				poPropertiesNode = poPropertiesNode->next;
			if(!poPropertiesNode)
				break;

			if(xmlStrcmp(poPropertiesNode->name, BAD_CAST("PROPERTIES")) == 0)
			{
				xmlNodePtr poPropertyNode = poPropertiesNode->children;
				while(poPropertyNode)
				{
					if(poPropertyNode->type == XML_TEXT_NODE)
						poPropertyNode = poPropertyNode->next;
					if(!poPropertyNode)
						break;

					if(reinterpret_cast<const char*>(poPropertyNode->name) != "PROPERTY")
						throw CXMLReadException(m_strXml,
							reinterpret_cast<const char*>(poPropertyNode->name),
							poPropertyNode->line);

					mapping.m_vecProperties.push_back(reinterpret_cast< const char* >(poPropertyNode->children->content));

					poPropertyNode = poPropertyNode->next;
				}
			}
			else if(xmlStrcmp(poPropertiesNode->name, BAD_CAST("FILE")) == 0)
			{
				mapping.m_strFile = reinterpret_cast< const char* >(poPropertiesNode->children->content);
			}
			else
				throw CXMLReadException(m_strXml, reinterpret_cast<const char*>(poPropertiesNode->name), poPropertiesNode->line);

			poPropertiesNode = poPropertiesNode->next;
		}
		poEntityNode = poEntityNode->next;
	}

	xmlFreeDoc(doc);
}

CCSVMapping::TVecProperties& CCSVMapping::GetProperties(const std::string& rstrEntity)
{
	return m_oMapping[rstrEntity].m_vecProperties;
}

const std::string& CCSVMapping::GetFile(const std::string& rstrEntity)
{
	return m_oMapping[rstrEntity].m_strFile;
}

/*!
 * \brief Le connecteur CSV.
 *
 * \tparam T Le type de donnée à interfacer avec la source.
 */
template<class T>
class CCSVConnector : public IIoConnector<T>
{
friend class CIoFactory;

public:
	/*!
	 * \brief Obtient le fichier de données.
	 *
	 * \return Le fichier de données.
	 */
	const std::string& GetDataFile();

protected:
	/*!
	 * \brief Crée une donnée.
	 *
	 * \param (*pValues) Valeur des propriétés de la donnée à créer.
	 * \return La donnée nouvellement créée.
	 */
	virtual CData<T>* Create(std::map<std::string, std::string>* pValues);

	/*!
	 * \brief Charge les données.
	 *
	 * \param usLoadNum Le numéro de chargement.
	 * \param (*pValues) Les éventuels paramètres de chargement.
	 */
	virtual void Load();

	/*!
	 * \brief Met à jour une donnée vers la source.
	 *
	 * \param roData La donnée à mettre à jour.
	 */
	virtual void Update(CData<T>* pData);

	/*!
	 * \brief Supprime une donnée dans la source.
	 *
	 * \param roData La donnée à supprimer.
	 */
	virtual void Delete(CData<T>* pData);

	/*!
	 * \brief Crée un nouvel identifiant pour ce type de donnée.
	 *
	 * \return Le nouvel identifiant.
	 */
	virtual TUInt64Property GetNewIdent();

private:
	/*!
	 * \brief Constructeur interdit, uniquement créé par la fabrique.
	 */
	CCSVConnector(){};
	
	/*!
	 * \brief Lit une ligne du fichier pour remplir une donnée.
	 *
	 * \param oFile Le fichier à lire.
	 * \param roData La donnée à remplir.
	 * \return true si le traitement s'est bien passé, sinon false.
	 */
	bool ReadLine(std::fstream& oFile, CData<T>& roData);

	/*!
	 * \brief Remplir une donnée à partir d'une chaîne (ligne).
	 *
	 * \param strLine La ligne.
	 * \param roData La donnée à remplir.
	 */
	void ReadLine(std::string& strLine, CData<T>& roData);

	/*!
	 * \brief Convertit une donnée en ligne CSV.
	 *
	 * \param roData La donnée à convertir.
	 * \return La ligne.
	 */
	std::string ToLine(CData<T>& roData);

	/*!
	 * \brief Formatte une chaîne au format CSV.
	 *
	 * \param rstrValue La chaîne à formatter.
	 * \return La chaîne formatté.
	 */
	std::string FormatToExport(const std::string& rstrValue);

	/*!
	 * \brief Retire le format CSV d'une chaîne.
	 *
	 * \param rstrValue La chaîne formattée.
	 * \return La chaîne sans format.
	 */
	std::string FormatToImport(const std::string& rstrValue);
	
	std::string m_strDataFile; /*!< Le fichier des données T. */
};

template<class T>
const std::string& CCSVConnector<T>::GetDataFile()
{
	if(m_strDataFile.size() == 0)
		m_strDataFile = CSVMapping.GetFile(SDataTrait<T>::CODE);
	return m_strDataFile;
}

template<class T>
std::string CCSVConnector<T>::FormatToExport(const std::string& rstrValue)
{
	std::string strValue = rstrValue;
	if(strValue.find_first_of(';') != std::string::npos)
	{
		strValue = Replace(strValue, "\"", "\"\"");
		strValue = "\"" + strValue + "\"";
	}
	return strValue;
}

template<class T>
std::string CCSVConnector<T>::FormatToImport(const std::string& rstrValue)
{
	if(rstrValue.size() < 2)
		return rstrValue;

	if(rstrValue[0] == '"' && rstrValue[rstrValue.size() - 1] == '"')
		return Replace(rstrValue.substr(1, rstrValue.size() - 2), "\"\"", "\"");

	return rstrValue;
}

template<class T>
bool CCSVConnector<T>::ReadLine(std::fstream& oFile, CData<T>& roData)
{
	std::string strLine;
	if(!std::getline(oFile, strLine))
	{
		oFile.clear();
		return false;
	}

	if(strLine.size() > 0)
	{
		ReadLine(strLine, roData);
	}

	return true;
}

template<class T>
std::string CCSVConnector<T>::ToLine(CData<T>& roData)
{
	std::string strLine = "";

	CCSVMappingIterator<T> iter;
	while(iter.HasNext())
	{
		const std::string& rstrPropertyName = iter.GetPropertyName();
		std::string strValue = roData.GetProperty(rstrPropertyName)->ToString();
		strValue = FormatToExport(strValue);

		if(!iter.IsFirst())
			strLine += ";";
		strLine += strValue;

		iter.Next();
	}

	return strLine;
}

<XML>
	<BOOK>
		<NODES>
			<NODE>
				<NODE>ident</NODE>
				<PROPERTY>ID</PROPERTY>
			</NODE>
			<NODE>
				<NODE>titre</NODE>
				<PROPERTY>TITLE</PROPERTY>
			</NODE>
			<NODE>
				<NODE>description</NODE>
				<PROPERTY>DESCRIPTION</PROPERTY>
			</NODE>
			<NODE>
				<NODE>year</NODE>
				<PROPERTY>YEAR</PROPERTY>
			</NODE>
			<NODE>
				<NODE>autheur</NODE>
				<PROPERTY>ID_AUTHOR</PROPERTY>
			</NODE>
		</NODES>
	</BOOK>
	<AUTHOR>
		// Mapping noeud/propriétés
	</AUTHOR>
</XML>

<XMLDATA>
	<DATA>
		<ident>1</ident>
		<titre>99 francs (14,99€)</titre>
		<description>Octave est un publicitaire blasé par le monde du maketing qui...</description>
		<year>2000</year>
		<autheur>25</autheur>
	</DATA>
	<DATA>
		<ident>2</ident>
		<titre>C++ pour les Nuls</titre>
		<description>Apprenez efficacement les rouages de C++ dans un...</description>
		<year>2006</year>
		<autheur>37</autheur>
	</DATA>
	<DATA>
		<ident>3</ident>
		<titre>Candide</titre>
		<description>Candide, un jeune homme à la vie heureuse, se voit basculé dans...</description>
		<year>1759</year>
		<autheur>14</autheur>
	</DATA>
</XMLDATA>

private:
	std::map<std::string, std::string> m_oMapPropertiesToNodes; // Map des propriétés vers les noeuds
	std::map<std::string, std::string> m_oMapNodesToProperties; // Map des noeuds vers les propriétés
	std::vector<std::string> m_vecProperties; // Liste des propriétés, dans l'ordre du mapping
	std::vector<std::string> m_vecNodes; // Liste des noeuds, dans l'ordre du mapping

private:
/*!
 * \brief Structure de regroupement d'un nom de propriété/nom de noeud.
 */
struct SNode
{
	std::string m_strNodeName; /*!< Le nom du noeud. */
	std::string m_strPropertyName; /*!< Le nom de la propriété. */
};

/*!
 * \brief Identifiant de l'index d'ordonnancement par insertion.
 */
struct SOrderedAsInserted{};

/*!
 * \brief Identifiant de l'index d'ordonnancement par noeud.
 */
struct SOrderedAsNodes{};

/*!
 * \brief Identifiant de l'index d'ordonnancement par propriété.
 */
struct SOrderedAsProperties{};

typedef boost::multi_index::multi_index_container<SNode, // container de nodes
	boost::multi_index::indexed_by< // indexé par
		boost::multi_index::sequenced<boost::multi_index::tag<SOrderedAsInserted>>, // insertion
		boost::multi_index::ordered_unique< // noeuds
			boost::multi_index::tag<SOrderedAsNodes>, 
			boost::multi_index::member<SNode,std::string,&SNode::m_strNodeName>>,
		boost::multi_index::ordered_unique<  // propriété
			boost::multi_index::tag<SOrderedAsProperties>,
			boost::multi_index::member<SNode,std::string,&SNode::m_strPropertyName>>
		>
	> TMappingSet; /*!< Type du mapping par entité. */
	
// Quelques racourcit pour accéder aux index
typedef TMappingSet::index<SOrderedAsInserted>::type TMappingByInsertion; /*!< Type de l'index par insertion. */
typedef TMappingSet::index<SOrderedAsNodes>::type TMappingByNodes; /*!< Type de l'index sur les noeuds. */
typedef TMappingSet::index<SOrderedAsProperties>::type TMappingByProperties; /*!< Type de l'index sur les propriétés. */

/*!
 * \brief Structure liant le fichier de données et le mapping des propriétés pour un type d'entité.
 */
struct SEntityMapping
{
	std::string m_strFile; /*!< Le fichier. */
	TMappingSet m_oMapping; /*!< Le mapping.*/
};

typedef std::map<std::string, SEntityMapping> TMapping; /*!< Type du mapping complet. */
TMapping m_oMapping; /*!< Le mapping. */

// insertion
SNode node;
node.m_strNodeName = [nom du noeud];
node.m_strPropertyName = [nom de la propriété];
m_oMapping[CBaseTrait<T>::CODE].insert(mapNodes.end(), newNode);

// recherche d'un noeud selon une propriété (utilisé pour la sauvegarde)
const std::string& CXmlMapping::GetNodeByProperty(const std::string& rstrEntity, const std::string& rstrPropertyName)
{
	return (*(m_oMapping[rstrEntity].m_oMapping.get<SOrderedAsProperties>().find(rstrPropertyName))).m_strNodeName;
}

// recherche d'une propriété selon un noeud (utilisé pour le chargement des données)
const std::string& CXmlMapping::GetPropertyByNode(const std::string& rstrEntity, const std::string& strNodeName)
{
	return (*(m_oMapping[rstrEntity].m_oMapping.get<SOrderedAsNodes>().find(strNodeName))).m_strPropertyName;
}

// Récupération de la liste des noeuds, prête à être parcourue par un itérateur.
CXmlMapping::TMappingByInsertion& CXmlMapping::GetNodes(const std::string& rstrEntity)
{
	return m_oMapping[rstrEntity].m_oMapping.get<SOrderedAsInserted>();
}

const std::string& CXmlMapping::GetFile(const std::string& rstrEntity)
{
	return m_oMapping[rstrEntity].m_strFile;
}

// Le TMappingByInsertion est utilisable comme un vector par exemple (iterator, begin, end etc...),
// par conséquent, l'itérateur sera similaire aux autres.

1    99 francs (14,99€)            Octave est un publicitaire blasé par le monde du maketing qui...                                    200025    
2    C++ pour les Nuls             Apprenez efficacement les rouages de C++ dans un...                                                 200637    
3    Candide                       Candide, un jeune homme à la vie heureuse, se voit basculé dans...                                  175914

<PLATFILE>
	<BOOK>
		<FILE>Books.txt</FILE>
		<PROPERTIES>
			<PROPERTY>
				<PROPERTY>ID</PROPERTY>
				<SIZE>6</SIZE>
			</PROPERTY>
			<PROPERTY>
				<PROPERTY>TITLE</PROPERTY>
				<SIZE>30</SIZE>
			</PROPERTY>
			<PROPERTY>
				<PROPERTY>DESCRIPTION</PROPERTY>
				<SIZE>150</SIZE>
			</PROPERTY>
			<PROPERTY>
				<PROPERTY>YEAR</PROPERTY>
				<SIZE>4</SIZE>
			</PROPERTY>
			<PROPERTY>
				<PROPERTY>ID_EDITOR</PROPERTY>
				<SIZE>6</SIZE>
			</PROPERTY>
			<PROPERTY>
				<PROPERTY>ID_AUTHOR</PROPERTY>
				<SIZE>6</SIZE>
			</PROPERTY>
		</PROPERTIES>
	</BOOK>
	<AUTHOR>
		...
	</AUTHOR>
</PLATFILE>

/*!
 * \brief Structure de regroupement d'un nom de propriété avec sa taille.
 */
struct SData
{
	std::string m_strPropertyName; /*!< Le nom de la propriété. */
	unsigned int m_uiSize; /*!< Sa taille dans le fichier. */
};

/*!
 * \brief Identifiant de l'index d'ordonnancement par insertion.
 */
struct SOrderedAsInserted{};

/*!
 * \brief Identifiant de l'index d'ordonnancement par propriété.
 */
struct SOrderedAsProperties{};

typedef boost::multi_index::multi_index_container<SData, // container de nodes
	boost::multi_index::indexed_by< // indexé par
		boost::multi_index::sequenced<boost::multi_index::tag<SOrderedAsInserted>>, // insertion
		boost::multi_index::ordered_unique< // propriétés
			boost::multi_index::tag<SOrderedAsProperties>, 
			boost::multi_index::member<SData,std::string,&SData::m_strPropertyName>>
		>
	> TMappingSet; /*!< Type du mapping par entité. */
	
typedef TMappingSet::index<SOrderedAsInserted>::type TMappingByInsertion; /*!< Type de l'index par insertion. */
typedef TMappingSet::index<SOrderedAsProperties>::type TMappingByProperties; /*!< Type de l'index sur les propriétés. */

/*!
 * \brief Structure liant le fichier et le mapping des propriétés pour un type d'entité.
 */
struct SEntityMapping
{
	std::string m_strFile; /*!< Le fichier. */
	TMappingSet m_oMapping; /*!< Le mapping.*/
};

typedef std::map<std::string, SEntityMapping> TMapping; /*!< Type du mapping complet. */
TMapping m_oMapping; /*!< Le mapping. */

<ODBC>
	<BOOK TABLE="TBOOKS">
		<CONNECT_STRING>DRIVER=SQL Server;SERVER=127.0.0.1\SQLEXPRESS;UID=user;PWD=pass;</CONNECT_STRING>
		<FIELDS>
			<FIELD>
				<BASE>USR_ID</BASE>
				<PROPERTY>ID</PROPERTY>
			</FIELD>
			<FIELD>
				<BASE>USR_LOGIN</BASE>
				<PROPERTY>LOGIN</PROPERTY>
			</FIELD>
			<FIELD>
				<BASE>USR_PASS</BASE>
				<PROPERTY>PASS</PROPERTY>
			</FIELD>
			<FIELD>
				<BASE>USR_AGE</BASE>
				<PROPERTY>AGE</PROPERTY>
			</FIELD>
			<FIELD>
				<BASE>USR_CAR_ID</BASE>
				<PROPERTY>CAR_ID</PROPERTY>
			</FIELD>
		</FIELDS>
	</BOOK>
	<AUTHOR TABLE="...">
	   ...
	</AUTHOR>
</ODBC>

/*!
 * \brief Structure de correspondance champ/propriété
 */
struct SField
{
	std::string m_strFieldName; /*!< Le nom du champ en base. */
	std::string m_strPropertyName; /*!< La propriété. */
};

/*!
 * \brief Identifiant de l'index d'ordonnancement par insertion.
 */
struct SOrderedAsInserted{};

/*!
 * \brief Identifiant de l'index d'ordonnancement par les champs.
 */
struct SOrderedAsFields{};

/*!
 * \brief Identifiant de l'index d'ordonnancement par les propriétés.
 */
struct SOrderedAsProperties{};

typedef boost::multi_index::multi_index_container<SField, // Container de SField
	boost::multi_index::indexed_by< // référencé par
		boost::multi_index::sequenced<boost::multi_index::tag<SOrderedAsInserted>>, // insertion
		boost::multi_index::ordered_unique< // champs
			boost::multi_index::tag<SOrderedAsFields>, 
			boost::multi_index::member<SField,std::string,&SField::m_strFieldName>>,
		boost::multi_index::ordered_unique< // propriétés
			boost::multi_index::tag<SOrderedAsProperties>,
			boost::multi_index::member<SField,std::string,&SField::m_strPropertyName>>
		>
	> TMappingSet; /*!< Type de stockage du mapping. */

typedef TMappingSet::index<SOrderedAsInserted>::type TMappingByInsertion; /*!< Type de l'index par insertion. */
typedef TMappingSet::index<SOrderedAsFields>::type TMappingByFields; /*!< Type de l'index par champs. */
typedef TMappingSet::index<SOrderedAsProperties>::type TMappingByProperties; /*!< Type de l'index par propriétés. */

/*!
 * \brief Structure de l'ensemble du mapping pour une entité.
 */
struct SEntityData
{
	std::string m_strTableName; /*!< Le nom de la table correspondante. */
	std::string m_strConnectString; /*!< La chaîne de connexion à utiliser. */
	TMappingSet m_Fields; /*!< Le mapping champ/propriété. */
};

typedef std::map<std::string, SEntityData> TEntityMapping; /*!< Table de correspondance entre les entités et leur données de mapping. */
TEntityMapping m_oMapping; /*!< Type de stockage des données de ce mapping. */

<IOCONFIG>
	<BOOKS MODE="ODBC"/>
	<AUTHOR MODE="XML"/>
	<EDITOR MODE="CSV"/>
</IOCONFIG>

template<class T>
class CGesData : public IGesData
{
protected:
	/*!
	 * \brief Constructeur.
	 */
	CGesData();

	/*!
	 * \brief Destructeur.
	 */
	virtual ~CGesData();
		
private:
	/*!
	 * \brief Obtient le connecteur IO de ce gestionnaire.
	 *
	 * \return Le connecteur IO.
	 */
	IIoConnector<T>* GetIoConnector();
		
	IIoConnector<T>* m_pIoConnector; /*!< Connecteur de données. */
};

template<class T>
CGesData<T>::CGesData()
	: m_pIoConnector(0)
{

}

template<class T>
CGesData<T>::~CGesData()
{
	if(m_pIoConnector)
	{
		delete m_pIoConnector;
		m_pIoConnector = 0;
	}
}
	
template<class T>
IIoConnector<T>* CGesData<T>::GetIoConnector()
{
	if(!m_pIoConnector)
		m_pIoConnector = CIoFactory::Get().CreateConnector<T>();
	return m_pIoConnector;
}

template<class T>
class CGesData : public IGesData
{
protected:
	/*!
	 * \brief Charge les données.
	 */
	void Load();
	
	/*!
	 * \brief Met à jour une donnée dans la source.
	 *
	 * \param pData La donnée.
	 */
	void Update(CData<T>* pData);
	
	/*!
	 * \brief Supprime une donnée dans la source.
	 *
	 * \param pData La donnée à supprimer.
	 */
	void Delete(CData<T>* pData);
	
	/*!
	 * \brief Crée une donnée en base.
	 *
	 * \param pValues La map des propriétés/valeurs des propriétés.
	 * \return La donnée créée.
	 */
	CData<T>* Create(std::map<std::string, std::string>* pValues = 0);
};

template<class T>
void CGesData<T>::Load()
{
	GetIoConnector()->Load();
}

template<class T>
void CGesData<T>::Update(CData<T>* pData)
{
	GetIoConnector()->Update(pData);
}

template<class T>
void CGesData<T>::Delete(CData<T>* pData)
{
	GetIoConnector()->Delete(pData);
}

template<class T>
CData<T>* CGesData<T>::Create(std::map<std::string, std::string>* pValues)
{
	return GetIoConnector()->Create(pValues);
}

// Notre config IO
//<IOCONFIG>
//	<BOOKS MODE="ODBC"/>
//	<AUTHOR MODE="XML"/>
//	<EDITOR MODE="CSV"/>
//</IOCONFIG>

// Initialisation de "qui est branché sur quoi
IOFactory.SetXml(rstrXml);

// Enregistrement des mappings utilisés
ODBCMapping.SetXml("xml/ODBCMapping.xml"); // Ira chercher dans la base référencé par la chaîne de connexion lié au livres
CSVMapping.SetXml("xml/CSVMapping.xml"); // Ira chercher dans le fichier CSV
XMLMapping.SetXml("xml/XMLMapping.xml"); // Ira chercher dans le fichier XML

// Et on attaque direct
GesMgr.Load<CBook>();
GesMgr.Load<CAuthor>();
GesMgr.Load<CEditor>();