ModuleDynamiqueModule.h

Aller à la documentation de ce fichier.

/*! \file ModuleDynamiqueModule.h
    \brief Gestion de module dynamique.

    Gestion d'un module. \n

    \author     aerith (www.aerith.fr)
    \version    1.0
    \date       01/11/2007
*/

#ifndef INCLUDE_RSRC_MODULEDYNAMIQUEMODULE
#define INCLUDE_RSRC_MODULDYNAMIQUEMODULE

#include    "../Surcouche/SurcoucheModule.h"
#include    "../Surcouche/SurcoucheMultitache.h"
#include    "../Tools/Tools.h"
#include    "../Error/Error.h"
#include    <vector>

#define MODULE_FILE     256
#define MODULE_NAME     128
#define MODULE_VERSION  16
#define MODULE_AUTOR    128
#define MODULE_DESC     256


//! Liste des Options
/*! Liste des options d'un module
*/
typedef struct _ModuleFonction
{
    char        Name[MODULE_NAME];          /*!< Nom de la fonction.                                */
    ROUTINE     Fonction;                   /*!< Adresse mémoire de la fonction.                    */
} ModuleFonction;

//! Gestion de module dynamique.
/*! Permet l'utilisation de module dynamique comme simple classe.
*/
class ModuleDynamiqueModule
{
private :
    char                            File[MODULE_FILE];      /*!< Fichier du module.                                 */
    char                            Name[MODULE_NAME];      /*!< Nom donné au module.                               */
    char                            Realname[MODULE_NAME];  /*!< Nom réel du module.                                */
    char                            Version[MODULE_VERSION];/*!< Version du module.                                 */
    char                            Autor[MODULE_AUTOR];    /*!< Auteur du module.                                  */
    char                            Desc[MODULE_DESC];      /*!< Description du module.                             */
    ROUTINE                         Fonction;               /*!< Liste des fonctions à importées.                   */
    MODULE                          ModuleAdr;              /*!< Adresse mémoire du module.                         */
    int                             NbFonction;             /*!< Nombre de fonction importées.                      */
    std::vector<ModuleFonction *>   Fonctions;              /*!< Chaque lignes est une fonction importer.           */
    int                             Loaded;                 /*!< A 1 si le module a été charger, sinon 0.           */

public  :
    /*! Initialise avec des valeurs par defaut.
    */
    ModuleDynamiqueModule();

    /*! Libere proprement la mémoire.
    */
    ~ModuleDynamiqueModule();

    //! Charge le module.
    /*! Charge le module de fichier \a pFile .
        \param pName nom du module
        \param pFile nom du fichier du module
        \return code d'erreur.
        \sa UnLoad().
    */
    int     Load(char *pName, char *pFile);

    //! Decharge le module.
    /*! Decharge le module.
        \return code d'erreur.
        \sa Load().
    */
    int     UnLoad();

    //! Importe une fonction.
    /*! Importe la fonction de nom \a pName .
        \param pName nom de la fonction
        \return code d'erreur.
        \sa DelFonction(), GetFonction() et GetNbFonction().
    */
    int     AddFonction(char *pName);

    //! Supprime une fonction.
    /*! Supprime la fonction étant à la position \a iPos.
        \param iPos position de la fonction.
        \return code d'erreur.
        \sa AddFonction(), GetFonction() et GetNbFonction().
    */
    int     DelFonction(int iPos);

    //! Supprime une fonction.
    /*! Supprime la fonction de nom \a pName.
        \param pName nom de la fonction.
        \return code d'erreur.
        \sa AddFonction(), GetFonction() et GetNbFonction().
    */
    inline int      DelFonction(char *pName)
    {
        for(int i = 0; i < NbFonction; i++)
        {
            if(!strcmp(Fonctions[i]->Name, pName))
                return DelFonction(i);
        }
    };

    //! Retourne une fonction par sa position.
    /*! Permet l'acces à la fonction étant à la position \a iPos.
        \param iPos position de la fonction.
        \return pointeur sur la fonction.
        \sa AddFonction(), DelFonction() et GetNbFonction().
    */
    inline ROUTINE      GetFonction(int iPos)
    {
        if(iPos < NbFonction)
            return Fonctions[iPos]->Fonction;

        return NULL;
    };

    //! Retourne une fonction par son nom.
    /*! Permet l'acces à la fonction ayant le nom \a pName.
        \param pName nom de la fonction.
        \return pointeur sur la fonction.
        \sa AddFonction(), DelFonction() et GetNbFonction().
    */
    inline ROUTINE      GetFonction(char *pName)
    {
        for(int i = 0; i < NbFonction; i++)
        {
            if(!strcmp(Fonctions[i]->Name, pName))
                return Fonctions[i]->Fonction;
        }

        return NULL;
    };

    //! Retourne le nombre de fonction.
    /*! Retourne le nombre de fonction importée.
        \return nombre de fonction importée.
        \sa AddFonction(), DelFonction() et GetFonction().
    */
    inline int      GetNbFonction()
    {
        return NbFonction;
    };

    //! Retourne le fichier.
    /*! Retourne le nom du fichier du module.
        \return pointeur sur \a File.
    */
    inline char     *GetFile()
    {
        return File;
    };

    //! Retourne le nom.
    /*! Retourne le nom donné au module.
        \return pointeur sur \a Name.
    */
    inline char     *GetName()
    {
        return Name;
    };

    //! Retourne le nom réel.
    /*! Retourne le nom réel du module.
        \return pointeur sur \a Realname.
    */
    inline char     *GetRealname()
    {
        return Realname;
    };

    //! Retourne la version.
    /*! Retourne la version du module.
        \return pointeur sur \a Version.
    */
    inline char     *GetVersion()
    {
        return Version;
    };

    //! Retourne l'auteur.
    /*! Retourne l'auteur du module.
        \return pointeur sur \a Autor.
    */
    inline char     *GetAutor()
    {
        return Autor;
    };

    //! Retourne la description.
    /*! Retourne la description du module.
        \return pointeur sur \a Desc.
    */
    inline char     *GetDesc()
    {
        return Desc;
    };
};

#endif

---