Page principale | Liste alphabétique | Liste des classes | Liste des fichiers | Membres de classe | Membres de fichier | Pages associées

Référence de la classe ModuleDynamiqueModule

Gestion de module dynamique. Plus de détails...

#include <ModuleDynamiqueModule.h>

Liste de tous les membres

Fonctions membres publiques

 ModuleDynamiqueModule ()
 ~ModuleDynamiqueModule ()
int Load (char *pName, char *pFile)
 Charge le module.
int UnLoad ()
 Decharge le module.
int AddFonction (char *pName)
 Importe une fonction.
int DelFonction (int iPos)
 Supprime une fonction.
int DelFonction (char *pName)
 Supprime une fonction.
ROUTINE GetFonction (int iPos)
 Retourne une fonction par sa position.
ROUTINE GetFonction (char *pName)
 Retourne une fonction par son nom.
int GetNbFonction ()
 Retourne le nombre de fonction.
char * GetFile ()
 Retourne le fichier.
char * GetName ()
 Retourne le nom.
char * GetRealname ()
 Retourne le nom réel.
char * GetVersion ()
 Retourne la version.
char * GetAutor ()
 Retourne l'auteur.
char * GetDesc ()
 Retourne la description.

Description détaillée

Permet l'utilisation de module dynamique comme simple classe.

Définition à la ligne 39 du fichier ModuleDynamiqueModule.h.

Documentation des contructeurs et destructeur

ModuleDynamiqueModule::ModuleDynamiqueModule (   ) 
 

Initialise avec des valeurs par defaut.

Définition à la ligne 13 du fichier ModuleDynamiqueModule.cpp.

00014 {
00015     *File           = '\0';
00016     *Name           = '\0';
00017     *Realname       = '\0';
00018     *Version        = '\0';
00019     *Autor          = '\0';
00020     *Desc           = '\0';
00021     Fonction        = NULL;
00022     ModuleAdr       = NULL;
00023     NbFonction      = 0;
00024     Loaded          = 0;
00025 }

ModuleDynamiqueModule::~ModuleDynamiqueModule (   ) 
 

Libere proprement la mémoire.

Définition à la ligne 27 du fichier ModuleDynamiqueModule.cpp.

Références UnLoad().

00028 {
00029     UnLoad();
00030 }

Documentation des fonctions membres

int ModuleDynamiqueModule::AddFonction (  char *  pName  ) 
 

Importe la fonction de nom pName .

Paramètres:
pName nom de la fonction
Renvoie:
code d'erreur.
Voir également:
DelFonction(), GetFonction() et GetNbFonction().

Définition à la ligne 143 du fichier ModuleDynamiqueModule.cpp.

Références LOC, ModuleFonction, ModuleImport(), et TRY.

Référencé par Load().

00144 {
00145     BEGIN
00146     LOC("ModuleDynamiqueModule::AddFonction")
00147 
00148     if(Loaded)
00149     {
00150         Fonctions.push_back(new ModuleFonction);
00151         TRY if(ModuleImport(ModuleAdr, &Fonctions.back()->Fonction, pName))
00152         {
00153             strcpy(Fonctions.back()->Name, pName);
00154 
00155             NbFonction++;
00156 
00157             printf("[Module] Import %-54s [  OK  ]\n", pName);
00158         }
00159         else
00160         {
00161             Fonctions.erase(Fonctions.begin() + NbFonction);
00162             printf("[Module] Import %-54s [FAILED]\n", pName);
00163             CERROR = ERROR_C_IMPORT_FUNC;
00164         }
00165     }
00166     ENDTRY(ERROR_C_LOAD_DLL)
00167 
00168     PERROR
00169 
00170     ENDBEGIN
00171 }

int ModuleDynamiqueModule::DelFonction (  char *  pName  )  [inline]
 

Supprime la fonction de nom pName.

Paramètres:
pName nom de la fonction.
Renvoie:
code d'erreur.
Voir également:
AddFonction(), GetFonction() et GetNbFonction().

Définition à la ligne 101 du fichier ModuleDynamiqueModule.h.

00102     {
00103         for(int i = 0; i < NbFonction; i++)
00104         {
00105             if(!strcmp(Fonctions[i]->Name, pName))
00106                 return DelFonction(i);
00107         }
00108     };

int ModuleDynamiqueModule::DelFonction (  int  iPos  ) 
 

Supprime la fonction étant à la position iPos.

Paramètres:
iPos position de la fonction.
Renvoie:
code d'erreur.
Voir également:
AddFonction(), GetFonction() et GetNbFonction().

Définition à la ligne 173 du fichier ModuleDynamiqueModule.cpp.

Références LOC, et TRY.

Référencé par Load(), et UnLoad().

00174 {
00175     BEGIN
00176     LOC("ModuleDynamiqueModule::DelFonction")
00177 
00178     TRY if(Loaded)
00179     {
00180         TRY if(iPos < NbFonction)
00181         {
00182             delete Fonctions[iPos];
00183             Fonctions.erase(Fonctions.begin() + iPos);
00184 
00185             NbFonction--;
00186         }
00187         ENDTRY(ERROR_C_NO_FUNC)
00188     }
00189     ENDTRY(ERROR_C_LOAD_DLL)
00190 
00191     PERROR
00192 
00193     ENDBEGIN
00194 }

char* ModuleDynamiqueModule::GetAutor (   )  [inline]
 

Retourne l'auteur du module.

Renvoie:
pointeur sur Autor.

Définition à la ligne 191 du fichier ModuleDynamiqueModule.h.

00192     {
00193         return Autor;
00194     };

char* ModuleDynamiqueModule::GetDesc (   )  [inline]
 

Retourne la description du module.

Renvoie:
pointeur sur Desc.

Définition à la ligne 200 du fichier ModuleDynamiqueModule.h.

00201     {
00202         return Desc;
00203     };

char* ModuleDynamiqueModule::GetFile (   )  [inline]
 

Retourne le nom du fichier du module.

Renvoie:
pointeur sur File.

Définition à la ligne 155 du fichier ModuleDynamiqueModule.h.

00156     {
00157         return File;
00158     };

ROUTINE ModuleDynamiqueModule::GetFonction (  char *  pName  )  [inline]
 

Permet l'acces à la fonction ayant le nom pName.

Paramètres:
pName nom de la fonction.
Renvoie:
pointeur sur la fonction.
Voir également:
AddFonction(), DelFonction() et GetNbFonction().

Définition à la ligne 130 du fichier ModuleDynamiqueModule.h.

Références ROUTINE.

00131     {
00132         for(int i = 0; i < NbFonction; i++)
00133         {
00134             if(!strcmp(Fonctions[i]->Name, pName))
00135                 return Fonctions[i]->Fonction;
00136         }
00137 
00138         return NULL;
00139     };

ROUTINE ModuleDynamiqueModule::GetFonction (  int  iPos  )  [inline]
 

Permet l'acces à la fonction étant à la position iPos.

Paramètres:
iPos position de la fonction.
Renvoie:
pointeur sur la fonction.
Voir également:
AddFonction(), DelFonction() et GetNbFonction().

Définition à la ligne 116 du fichier ModuleDynamiqueModule.h.

Références ROUTINE.

00117     {
00118         if(iPos < NbFonction)
00119             return Fonctions[iPos]->Fonction;
00120 
00121         return NULL;
00122     };

char* ModuleDynamiqueModule::GetName (   )  [inline]
 

Retourne le nom donné au module.

Renvoie:
pointeur sur Name.

Définition à la ligne 164 du fichier ModuleDynamiqueModule.h.

00165     {
00166         return Name;
00167     };

int ModuleDynamiqueModule::GetNbFonction (   )  [inline]
 

Retourne le nombre de fonction importée.

Renvoie:
nombre de fonction importée.
Voir également:
AddFonction(), DelFonction() et GetFonction().

Définition à la ligne 146 du fichier ModuleDynamiqueModule.h.

00147     {
00148         return NbFonction;
00149     };

char* ModuleDynamiqueModule::GetRealname (   )  [inline]
 

Retourne le nom réel du module.

Renvoie:
pointeur sur Realname.

Définition à la ligne 173 du fichier ModuleDynamiqueModule.h.

00174     {
00175         return Realname;
00176     };

char* ModuleDynamiqueModule::GetVersion (   )  [inline]
 

Retourne la version du module.

Renvoie:
pointeur sur Version.

Définition à la ligne 182 du fichier ModuleDynamiqueModule.h.

00183     {
00184         return Version;
00185     };

int ModuleDynamiqueModule::Load (  char *  pName,
char *  pFile
) 
 

Charge le module de fichier pFile .

Paramètres:
pName nom du module
pFile nom du fichier du module
Renvoie:
code d'erreur.
Voir également:
UnLoad().

Définition à la ligne 32 du fichier ModuleDynamiqueModule.cpp.

Références AddFonction(), AtoI(), DelFonction(), LOC, ModuleImport(), ModuleLoad(), PARAMETRE, ROUTINE, et TRY.

00033 {
00034     int         i = 0, Nb;
00035     ROUTINE     Temp;
00036     BEGIN
00037     LOC("ModuleDynamiqueModule::Load")
00038 
00039     if(!Loaded)
00040     {
00041         strcpy(Name, pName);
00042         strcpy(File, pFile);
00043 
00044         TRY if(ModuleLoad(&ModuleAdr, File))
00045         {
00046             printf("[Module] Load %-56s [  OK  ]\n", Name);
00047 
00048             TRYIF(ModuleImport(ModuleAdr, &Temp, "ModuleInit"), ERROR_C_IMPORT_FUNC)
00049             TRYIF((int)Temp(NULL), ERROR_C_FUNCTION)
00050 
00051             TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleName"))
00052             {
00053                 strcpy(Realname, (char *)Temp(NULL));
00054             }
00055             ENDTRY(ERROR_C_IMPORT_FUNC)
00056 
00057             TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleVersion"))
00058             {
00059                 strcpy(Version, (char *)Temp(NULL));
00060             }
00061             ENDTRY(ERROR_C_IMPORT_FUNC)
00062 
00063             TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleDesc"))
00064             {
00065                 strcpy(Desc, (char *)Temp(NULL));
00066             }
00067             ENDTRY(ERROR_C_IMPORT_FUNC)
00068 
00069             TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleAutor"))
00070             {
00071                 strcpy(Autor, (char *)Temp(NULL));
00072             }
00073             ENDTRY(ERROR_C_IMPORT_FUNC)
00074 
00075             Loaded = 1;
00076 
00077             TRYIF(ModuleImport(ModuleAdr, &Fonction, "ModuleFonction"), 25)
00078 
00079             TRY {
00080                 while(NbFonction)
00081                     DelFonction(NbFonction - 1);
00082                 Fonctions.clear();
00083 
00084                 printf("\t%s V%s by %s\n", Realname, Version, Autor);
00085                 printf("\t%s\n", Desc);
00086             }
00087 
00088             TRY Nb = AtoI((char *)Fonction(0));
00089             TRY if(Nb)
00090             {
00091                 for(i = 0; i < (Nb && !CERROR); i++)
00092                 {
00093                     CERROR = AddFonction((char *)Fonction((PARAMETRE)(i + 1)));
00094                 }
00095             }
00096             ENDTRY(ERROR_C_NO_FUNC)
00097         }
00098         else
00099         {
00100             printf("[Module] Load %-56s [FAILED]\n", pName);
00101             CERROR = ERROR_C_LOAD_DLL;
00102         }
00103     }
00104 
00105     PERROR
00106 
00107     ENDBEGIN
00108 }

int ModuleDynamiqueModule::UnLoad (   ) 
 

Decharge le module.

Renvoie:
code d'erreur.
Voir également:
Load().

Définition à la ligne 110 du fichier ModuleDynamiqueModule.cpp.

Références DelFonction(), LOC, ModuleImport(), ModuleUnload(), et ROUTINE.

Référencé par ~ModuleDynamiqueModule().

00111 {
00112     ROUTINE     Close;
00113     BEGIN
00114     LOC("ModuleDynamiqueModule::UnLoad")
00115 
00116     if(Loaded)
00117     {
00118         if(ModuleImport(ModuleAdr, &Close, "ModuleClose"))
00119             Close(NULL);
00120 
00121         while(NbFonction)
00122             DelFonction(NbFonction - 1);
00123         Fonctions.clear();
00124 
00125         if(!ModuleUnload(&ModuleAdr))
00126         {
00127             printf("[Module] Unload %-54s [  OK  ]\n", Name);
00128 
00129             Loaded = 0;
00130         }
00131         else
00132         {
00133             printf("[Module] Unload %-54s [FAILED]\n", Name);
00134             CERROR = ERROR_C_UNLOAD_DLL;
00135         }
00136     }
00137 
00138     PERROR
00139 
00140     ENDBEGIN
00141 }

La documentation de cette classe a été générée à partir des fichiers suivants:
Généré le Thu Jun 12 09:12:30 2008 pour A.I.F. par  doxygen 1.3.9.1