Error.h

Aller à la documentation de ce fichier.

/*! \file Error.h
    \brief Gestion d'erreurs.

    Sytème de gestion des exception (localisation, désignation).

    \author     aerith (http://aerith.fr)
    \version    1.0
    \date       20/05/2008
*/

#ifndef INCLUDE_RSRC_ERROR
#define INCLUDE_RSRC_ERROR

#include    "../Surcouche/SurcoucheMultitache.h"
#include    "../Tools/Tools.h"
#include    "ErrorCode.h"
#include    <stdlib.h>
#include    <time.h>
#include    <stdarg.h>
#include    <string>
#include    <vector>
#include    <iostream>
#include    <fstream>

using namespace std;

#define     ERROR_DEFLANG   "../../files/ErrorCode.FR"  /*!< Fichier des erreurs par defaut.            */
#define     ERROR_BUFFER    1024                        /*!< Taille du buffer de travail.               */

//! Informations sur une fonction logée
/*! Informations sur une fonction logée
*/
class FuncInfos
{
public      :
    string          func;
    string          file;
    unsigned int    line;

    /*! Initalisé avec des paramètres.
        \param pFunc nom de la fonction
        \param pFile fichier où se trouve la fonction
        \param iLine ligne dans le fichier où se trouve la fonction
    */
    FuncInfos(const char *pFunc, const char *pFile, unsigned int iLine)
    {
        func = pFunc;
        file = pFile;
        line = iLine;
    };
};

//! Pile d'appel d'un thread
/*! Pile d'appel de fonction d'un thread
*/
class ThreadCallStack
{
public      :
    unsigned int        id;
    vector<FuncInfos *> stack;
    unsigned int        nbInstance;

    /*! Initalisé avec des paramètres par defauts.
    */
    ThreadCallStack()
    {
        id = ThreadId();
        nbInstance = 0;
    };
};

typedef struct
{
    unsigned int    no;
    string          desc;
} ErrorDesc;

//! Gestion d'erreur
/*! Sytème de gestion des exception (localisation, désignation).
*/
class Error
{
private     :
    static string                       log;                /*!< Fichier des logs.                                          */
    static string                       langue;             /*!< Nom du fichier charger ("ErrorCode.FR" par defaut).        */
    static vector<ThreadCallStack *>    callStacks;         /*!< Piles d'appel des threads.                                 */
    ThreadCallStack                     *currentCallStack;  /*!< Piles d'appel du thread courant.                           */
    static vector<ErrorDesc *>          descError;          /*!< Descriptions des codes d'erreurs.                          */
    string                              loc;                /*!< Nom de la fonction en cour d'éxécution.                    */
    unsigned int                        line;               /*!< Ligne de l'exception.                                      */

    //! Log un message
    /*! Log un message vers stderr et un fichier.
        \param pBuffer chaine construite comme pour printf.
        \param ... argument pour construire la chaine
    */
    void    LogError(const char *pBuffer, ...);

public      :
    /*! Initalisé par defaut en langue "ErrorCode.FR". 
    */
    Error();

    /*! Libére la mémoire proprement. 
    */
    ~Error();

    //! Définie le nom du fichier de log
    /*! Définie le nom du fichier de log des erreurs.
        \param pLog nom de la section
    */
    inline void     SetLog(const char *pLog)
    {
        log = pLog;
    };

    //! Definie le nom de la fonction courant
    /*! Définie le nom de la fonction en cour d'éxécution.
        \param pLoc nom de la fonction
    */
    inline void     SetLoc(const char *pLoc)
    {
        loc = pLoc;
    };

    //! Langue des messages d'erreur
    /*! Permet de définir la langue dans laquelle seront les messages d'erreurs (fichier ErrorCode.\a lang).
        \param pFile nom du fichier de la langue.
    */
    void    SetLangue(const char *pFile);

    //! Génère une exception
    /*! Enregistre le numéro de la ligne et génère une exception
        \param iLine numéro de la ligne
        \param iCode code de l'erreur
    */
    inline void     Throw(unsigned int iLine, unsigned int iCode)
    {
        line = iLine;
        throw iCode;
    };

    //! Ajoute une fonction à la liste d'appel
    /*! Ajoute une fonction à la suite de la pile d'appel (LIFO).
        \param pFunc nom de la fonction courante.
        \param pFile nom du fichier de la fonction.
    */
    void    AddFunc(const char *pFunc, const char *pFile);

    //! Affiche la description de l'erreur
    /*! Affiche et log la description de l'exception enregistrée par le systeme.
        \param iCode code de l'erreur

    */
    void    Perror(unsigned int iCode);
};

//! Nom de la variable d'erreur
/*! Nom de la variable instanciant la classe de gestion d'erreur.
*/
#define     ERRORVAR        SysError

//! Initialise le systeme
/*! Placer comme une variable.
*/
#define     TRY         Error   ERRORVAR; try {

//! Génère une exception
/*! Enregisre la ligne de l'erreur et génère une exception.
    \param code code de l'erreur
*/
#define     THROW(code)     ERRORVAR.Throw(__LINE__, code);

//! Nom du fichier des log
/*! Spécifie le fichier utilise pour loger les erreurs de \a PERROR .
    \param log nom du fichier
*/
#define     LOG(log)        ERRORVAR.SetLog(log);

//! Nome la section
/*! Permet de nomer la section pour situer l'erreur (nouveau thread ou autre ...).
    \param func nom de la section
*/
#define     LOC(func)       ERRORVAR.SetLoc(func);

//! Langue des messages d'erreur
/*! Permet de définir la fichier pour la langue dans laquelle seront les messages d'erreurs.
    \param fichier fichier utiliser pour la langue. \n
    ex : "FR" pour le fichier "ErrorCode.FR"
*/
#define     LANG(fichier)   ERRORVAR.SetLangue(fichier);

//! Traite l'exception et affiche la description de l'erreur
/*! Affiche et log la description de l'exception enregistrée par le systeme.
*/
#define     CATCH_PRINT     } \
                            catch(unsigned int iCode) { \
                                ERRORVAR.AddFunc(__FUNCTION__, __FILE__); \
                                ERRORVAR.Perror(iCode); \
                                throw; \
                            } \
                            catch(...) { \
                                ERRORVAR.AddFunc(__FUNCTION__, __FILE__); \
                                ERRORVAR.Perror(ERROR_C_UNKNOW); \
                                throw ERROR_C_UNKNOW; \
                            }

//! Sauve le nom de la fonction et fait suivre l'exception
/*! Sauve le nom de la fonction et fait suivre l'exception
*/
#define     CATCH           } \
                            catch(unsigned int iCode) { \
                                ERRORVAR.AddFunc(__FUNCTION__, __FILE__); \
                                throw; \
                            } \
                            catch(...) { \
                                ERRORVAR.AddFunc(__FUNCTION__, __FILE__); \
                                throw ERROR_C_UNKNOW; \
                            }


#endif

---