Gérer ses données en C++

// Ce que nous ne proposerons pas :
CFileAccessException except;
except.SetMessage("Impossible d'accéder au fichier");
except.AddParam("FICHIER", strFile);
except.AddCause("Vous n'avez pas les droits d'accéder au fichier");
except.AddCause("Le fichier est verrouillé");
throw except;

// Et éviter ceci :
CFileAccessException except;
throw except; // Qui n'aurai aucune valeur informative si ce n'est que ça a planter

// Et mettons en place ceci :
throw CFileAccessException(strFile);

// En spécifiant les détails dans l'exception elle même
CFileAccessException::CFileAccessException(const std::string& rstrFile)
{
	SetMessage("Impossible d'accéder au fichier");
	
	AddParam(rstrFile);
	
	AddCause("Vous n'avez pas les droits d'accéder au fichier");
	AddCause("Le fichier est verrouillé");
}

/*!
 * \brief Classe de base de nos exceptions.
 *
 * Toute exception peut contenir une exception d'origine.
 */
class CException
{
public :
	/*!
	 * \brief Constructeur par défaut.
	 *
	 * \param [in] poOriginException L'éventuelle exception à l'origine de celle-ci.
	 * \param [in] rstrMessage Le message associé à cette exception.
	 */
	CException(const CException* poOriginException = 0);

	/*!
	 * \brief Destructeur.
	 */
	virtual ~CException();

	/*!
	 * \brief Obtient l'exception à l'origine de celle-ci.
	 *
	 * \return L'exception à l'origine de celle-ci.
	 */
	const CException* GetOriginException() const;

	/*!
	 * \brief Obtient le message descriptif de cette exception.
	 *
	 * \return Le message descriptif de cette exception.
	 */
	virtual const char* what() const;

	/*!
	 * \brief Obtient la description complète de cette exception.
	 *
	 * \param [in] rstrLinePrefix Le préfixe à appliquer à chaque ligne de cette description.
	 * \return La description complète de cette exception.
	 */
	std::string GetFullMessage(const std::string& rstrLinePrefix = "") const;

protected :
	/*!
	 * \brief Positionne le message de cette exception.
	 *
	 * \param [in] rstrMessage Le message.
	 */
	void SetMessage(const std::string& rstrMessage);
	
	/*!
	 * \brief Ajoute une cause à cette description.
	 *
	 * \param [in] rstrCause La cause à ajouter à cette exception.
	 */
	void AddCause(const std::string& rstrCause);

	/*!
	 * \brief Ajoute un paramètre utile à connaître pour décrire cette exception.
	 *
	 * \param [in] rstrKey La clé du paramètre.
	 * \param [in] rtValue La valeur du paramètre.
	 */
	template<class T> void AddParam(const std::string& rstrKey, const T& rtValue);

	/*!
	 * \brief Ajoute une résolution à cette exception.
	 *
	 * \param [in] rstrResolution La résolution à ajouter.
	 */
	void AddResolution(const std::string& rstrResolution);

private:
	std::string m_strMessage; /*<! Le message descriptif de cette exception */
	const CException* m_poOriginException; /*!< L'exception à l'origine de celle-ci. */

	typedef std::vector<std::string> TVecCauses; /*!< Type pour stocker les causes. */
	TVecCauses m_oVecCauses; /*!< La liste des causes possibles de cette exception. */

	typedef std::vector<std::string> TVecResolutions; /*!< Type pour stocker les résolutions. */
	TVecResolutions m_oVecResolutions; /*!< La liste des résolutions possibles. */

	typedef std::map<std::string, std::string> TMapParams; /*!< Type pour mapper les paramètres et leurs valeurs. */
	TMapParams m_oMapParams; /*!< La liste des paramètres additionnels. */
};

std::string CException::GetFullMessage(const std::string& rstrLinePrefix) const
{
	std::string sWhat = "";
	sWhat += rstrLinePrefix;
	sWhat += "--> " + m_strMessage;
	sWhat += "\n";
	if(m_oVecCauses.size() > 0)
	{
		sWhat += rstrLinePrefix;

		if(m_oVecCauses.size() > 1)
			sWhat += "\t*Causes possibles :\n";
		else
			sWhat += "\t*Cause possible :\n";

		for each(std::string sCauseIt in m_oVecCauses)
		{
			sWhat += rstrLinePrefix;
			sWhat += "\t\t- ";
			sWhat += sCauseIt + "\n";
		}
	}
	if(m_oVecResolutions.size() > 0)
	{
		sWhat += rstrLinePrefix;

		if(m_oVecResolutions.size() > 1)
			sWhat += "\t*Résolutions possibles :\n";
		else
			sWhat += "\t*Résolution possible :\n";

		for each(std::string sResolutionIt in m_oVecResolutions)
		{
			sWhat += rstrLinePrefix;
			sWhat += "\t\t- ";
			sWhat += sResolutionIt + "\n";
		}
	}
	if(m_oMapParams.size() > 0)
	{
		sWhat += rstrLinePrefix;

		if(m_oMapParams.size() > 1)
			sWhat += "\t*Paramètres :\n";
		else
			sWhat += "\t*Paramètre :\n";

		for each(const std::pair<std::string, std::string> oParamIt in m_oMapParams)
		{
			sWhat += rstrLinePrefix;
			sWhat += "\t\t- ";
			sWhat += oParamIt.first + " : " + oParamIt.second + "\n";
		}
	}
	if(m_poOriginException != 0)
	{
		sWhat += rstrLinePrefix;
		sWhat += "\t*Origine :\n";
		sWhat += rstrLinePrefix;
		sWhat += m_poOriginException->GetFullMessage("\t\t");
	}

	return sWhat;
}

/*!
 * \brief Exception levée lorsque l'accès au fichier de log de l'utilisation de la mémoire présente un problème.
 */
class CFileAccessException : public CException
{
public:
	/*!
	 * \brief Constructeur.
	 *
	 * \param [in] rstrFilename Le nom du fichier dont l'accès a échouée.
	 * \param [in] poOriginException L'éventuelle exception à l'origine de celle-ci.
	 */
	CFileAccessException(
		const std::string& rstrFilename,
		const CException* poOriginException = 0)
	{
		SetMessage("Impossible d'accéder au fichier");

		AddCause("Le nom du fichier est incorrect.");
		AddCause("Le fichier est verrouillé.");
		AddCause("Vous n'avez pas les droits d'accéder à ce fichier.");

		AddResolution("Essayez de l'ouvrir manuellement");

		AddParam("Nom du fichier", rstrFilename);
	}
};

CBook* pBook = 0;
#ifdef _DEBUG
pBook = SafeNew(CBook);
#else
pBook = new CBook();
#endif // _DEBUG

...

#ifdef _DEBUG
SafeDelete(pBook);
#else
delete pBook
#endif // _DEBUG

class CLogger
{
private:
	virtual void Write(const std::string& rstrMessage) = 0;
};

/*!
 * \brief Opérateur d'insertion dans un flux.
 *
 * \param [in] rtToLog Le T à logger.
 */
template <class T> ILogger& ILogger::operator <<(const T& rtToLog)
{
	std::ostringstream Stream;
	Stream << rtToLog;
	Write(Stream.str());

	return *this; // Nous renvoyons le logger pour pouvoir cumuler les appels à <<
}

class CDebugLogger : public CLogger
{
private:
	virtual void Write(const std::string& rstrMessage);
};

void CDebugLogger::Write(const std::string& rstrMessage)
{
	OutputDebugString(rstrMessage.c_str());
}

CDebugLogger logger;
int i = 0;
float f = 0.;
logger << "Un message de log, nous y mettons un entier " << i << " puis un flottant " << f;

class CFileLogger : public CLogger { ... };
class CConsoleLogger : public CLogger { ... };
class CSocketLogger : public CLogger { ... };
// etc...

g_fileLogger << "Un message de log, nous y mettons un entier " << i << " puis un flottant " << f;
g_socketLogger << "Un message de log, nous y mettons un entier " << i << " puis un flottant " << f;
#ifdef _DEBUG
	g_debugLogger << "Un message de log, nous y mettons un entier " << i << " puis un flottant " << f;
	g_consoleLogger << "Un message de log, nous y mettons un entier " << i << " puis un flottant " << f;
#endif // <i>DEBUG

/*!
 * \brief Gestionnaire de log.
 */
class CLogManager : public CSingleton<CLogManager>, public ILogger
{
SINGLETON_DECLARE(CLogManager);

public:
	/*!
	 * \brief Branche un logger à ce gestionnaire.
	 *
	 * \param pLogger Le logger.
	 * \param bExtern Indique si le logger est extern à l'instance applicative.
	 */
	void AddLogger(ILogger* pLogger, bool bExtern = false);

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

	/*!
	 * \brief Destructeur.
	 */
	virtual ~CLogManager();

	/*!
	 * \brief Log un message.
	 *
	 * \param [in] rstrMessage Le message à logger.
	 */
	void Write(const std::string& rstrMessage);

	typedef std::map<ILogger*, bool> TMapLoggers; /*!< Type de stockage des loggers internes. */
	TMapLoggers m_mapLoggers; /*!< La liste des loggers enregistrés. */
};

#define Log CLogManager::GetInstance() // Petit racourcit pratique.

Log.AddLogger(new CFileLogger("kin.log"));
Log.AddLogger(new CSocketLogger("pc-de-control", 3159));

// Si nous sommes en debug, nous branchons aussi le cadre de sortie de l'IDE, ainsi que la console.
#ifdef _DEBUG
	Log.AddLogger(new CConsoleLogger());
	Log.AddLogger(new CDebugLogger());
#endif // DEBUG

Log << "Un message de log, nous y mettons un entier " << i << " puis un flottant " << f;

Log.AddLogger(new CFileLogger("kin.log"));
Log.AddLogger(new CSocketLogger("pc-de-control", 3159));

#ifdef _DEBUG
	Log.AddLogger(new CConsoleLogger());
	Log.AddLogger(new CDebugLogger());
#endif // DEBUG

// Redirection des messages de la DLL dans ceux de l'exe.
kinAddLogger(Log); // Log, le gestionnaire étant lui même un logger, ça passe.

kinTestApp - Début d'exécution
kinBusiness - Chargement des clients, 2884 données, 23 ms
kinTestApp - Fin d'exécution

int i; float f;

// Construction d'une chaîne
std::ostringstream ostream;
steam << i << f;
std::string strString = stream.str();

// Extraction des valeur depuis la chaîne.
std::istringstream istream(strString);
istream >> f >> i;

/*!
 * \brief Constructeur de chaîne à partir de tout type de données.
 */
class CStringBuilder
{
public :
	/*!
	 * \brief Constructeur.
	 */
	CStringBuilder();

	/*!
	 * \brief Constructeur avec construction initiale.
	 *
	 * \tparam T Le type de la donnée à partir de laquelle initialiser cette instance.
	 * \param [in] rtValue La valeur initiale.
	 */
	template <typename T> CStringBuilder(const T& rtValue);

	/*!
	 * \brief Alimente ce constructeur de chaîne.
	 *
	 * \tparam T Le type de la donnée source.
	 * \param [in] rtValue La valeur à ajouter à ce constructeur de chaîne.
	 */
	template <typename T> inline CStringBuilder& operator ()(const T& rtValue);
	
	/*!
	 * \brief Opérateur de conversion en chaîne de caractère.
	 *
	 * \return La chaîne construite.
	 */
	inline operator std::string();

private:
	std::ostringstream m_oOutStream; /*!< Le flux de sortie interne. */
};

template <typename T>
inline CStringBuilder::CStringBuilder(const T& rtValue)
{
	m_oOutStream << rtValue;
}

template <typename T>
inline CStringBuilder& CStringBuilder::operator ()(const T& rtValue)
{
	m_oOutStream << rtValue;

	return *this;
}

inline CStringBuilder::operator std::string()
{
	return m_oOutStream.str();
}

CStringBuilder builder; int i = 2; float f = 3.4;
std::string str = builder(i)(f);

/*!
 * \brief Extracteur de chaînes dans un type choisit.
 */
class CStringExtractor
{
public :
	/*!
	 * \brief Constructeur.
	 *
	 * \param [in] rstrText La chaîne initiale.
	 */
	CStringExtractor(const std::string& rstrText = "");

	/*!
	 * \brief Remplit une valeur.
	 *
	 * \tparam T Le type de la valeur à templir.
	 * \param [in] rtValue La valeur à remplir.
	 */
	template <typename T> CStringExtractor& operator ()(T& rtValue);

	/*!
	 * \brief Indique si cet extracteur est vide ou non.
	 */
	bool Empty();

	/*!
	 * \brief Réalimente cet extracteur.
	 *
	 * \param [in] rstrText Le texte avec lequel réalimenter cet extracteur.
	 */
	void Push(const std::string& rstrText);

private :
	std::istringstream m_oInStream; /*!< Le lfux d'entrée interne. */
};

template <typename T>
inline CStringExtractor& CStringExtractor::operator ()(T& rtValue)
{
	if (m_oInStream.str().size() == 0)
		return *this;

	if (!(m_oInStream >> rtValue))
	{
		if (m_oInStream.eof())
			throw new CExtractorConvertException(typeid(T).name());
		else
			throw new CExtractorEmptyException(typeid(T).name());
	}

	return *this;
}

inline bool CStringExtractor::Empty()
{
	return m_oInStream.eof();
}

inline void CStringExtractor::Push(const std::string& rstrText)
{
	m_oInStream.clear();
	m_oInStream.str(rstrText.c_str());
}

CStringExtractor oExtractor("2 3,4");
int i = 0; float f = 0.;
oExtractor(i)(f);