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

Référence de la classe ModuleModule

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

#include <ModuleModule.h>

Liste de tous les membres

Fonctions membres publiques

 ModuleModule ()
 ~ModuleModule ()
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 47 du fichier ModuleModule.h.

Documentation des contructeurs et destructeur

ModuleModule::ModuleModule (   ) 
 

Initialise avec des valeurs par defaut.

Définition à la ligne 13 du fichier ModuleModule.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     Fonctions       = NULL;
00025     Loaded          = 0;
00026 }

ModuleModule::~ModuleModule (   ) 
 

Libere proprement la mémoire.

Définition à la ligne 28 du fichier ModuleModule.cpp.

Références UnLoad().

00029 {
00030     int     i;
00031 
00032     UnLoad();
00033 
00034     for(i = 0; i < NbFonction; i++)
00035     {
00036         if(Fonctions[i])
00037             free(Fonctions[i]);
00038         Fonctions[i] = NULL;
00039     }
00040     if(Fonctions)
00041         free(Fonctions);
00042     Fonctions = NULL;
00043 }

Documentation des fonctions membres

int ModuleModule::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 175 du fichier ModuleModule.cpp.

Références BEGIN, CERROR, ENDBEGIN, ENDTRY, _ModuleFonction::Fonction, LOC, ModuleFonction, ModuleImport(), PERROR, et TRY.

Référencé par Load().

00176 {
00177     ModuleFonction  *Fonction;
00178     BEGIN
00179     LOC("ModuleModule::AddFonction")
00180 
00181     TRY if(Loaded)
00182     {
00183         Fonction = new ModuleFonction;
00184 
00185         printf("[Module] Import %34s ", pName);
00186         TRY if(ModuleImport(ModuleAdr, &Fonction->Fonction, pName))
00187         {
00188             Fonctions = (ModuleFonction **)realloc(Fonctions, (NbFonction + 1) * sizeof(ModuleFonction *));
00189 
00190             Fonctions[NbFonction] = Fonction;
00191             strcpy(Fonctions[NbFonction]->Name, pName);
00192 
00193             NbFonction++;
00194 
00195             printf("[  OK  ]\n");
00196         }
00197         else
00198         {
00199             printf("[FAILED]\n");
00200             CERROR = 25;
00201         }
00202     }
00203     ENDTRY(23)
00204 
00205     PERROR
00206 
00207     ENDBEGIN
00208 }

int ModuleModule::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 109 du fichier ModuleModule.h.

00110     {
00111         for(int i = 0; i < NbFonction; i++)
00112         {
00113             if(!strcmp(Fonctions[i]->Name, pName))
00114                 return DelFonction(i);
00115         }
00116     };

int ModuleModule::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 210 du fichier ModuleModule.cpp.

Références BEGIN, ENDBEGIN, ENDTRY, LOC, ModuleFonction, PERROR, et TRY.

00211 {
00212     int     i = 0;
00213     BEGIN
00214     LOC("ModuleModule::DelFonction")
00215 
00216     TRY if(Loaded)
00217     {
00218         TRY if(iPos < NbFonction)
00219         {
00220             if(Fonctions[iPos])
00221                 free(Fonctions[iPos]);
00222             Fonctions[iPos] = NULL;
00223 
00224             for(i = iPos; i < (NbFonction - 1); Fonctions[i] = Fonctions[i++]);
00225             Fonctions = (ModuleFonction **)realloc(Fonctions, (NbFonction - 1) * sizeof(ModuleFonction *));
00226 
00227             NbFonction--;
00228         }
00229         ENDTRY(26)
00230     }
00231     ENDTRY(23)
00232 
00233     PERROR
00234 
00235     ENDBEGIN
00236 }

char* ModuleModule::GetAutor (   )  [inline]
 

Retourne l'auteur du module.

Renvoie:
pointeur sur Autor.

Définition à la ligne 199 du fichier ModuleModule.h.

00200     {
00201         return Autor;
00202     };

char* ModuleModule::GetDesc (   )  [inline]
 

Retourne la description du module.

Renvoie:
pointeur sur Desc.

Définition à la ligne 208 du fichier ModuleModule.h.

00209     {
00210         return Desc;
00211     };

char* ModuleModule::GetFile (   )  [inline]
 

Retourne le nom du fichier du module.

Renvoie:
pointeur sur File.

Définition à la ligne 163 du fichier ModuleModule.h.

00164     {
00165         return File;
00166     };

ROUTINE ModuleModule::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 138 du fichier ModuleModule.h.

Références _ModuleFonction::Fonction, et ROUTINE.

00139     {
00140         for(int i = 0; i < NbFonction; i++)
00141         {
00142             if(!strcmp(Fonctions[i]->Name, pName))
00143                 return Fonctions[i]->Fonction;
00144         }
00145 
00146         return NULL;
00147     };

ROUTINE ModuleModule::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 124 du fichier ModuleModule.h.

Références _ModuleFonction::Fonction, et ROUTINE.

00125     {
00126         if(iPos < NbFonction)
00127             return Fonctions[iPos]->Fonction;
00128 
00129         return NULL;
00130     };

char* ModuleModule::GetName (   )  [inline]
 

Retourne le nom donné au module.

Renvoie:
pointeur sur Name.

Définition à la ligne 172 du fichier ModuleModule.h.

00173     {
00174         return Name;
00175     };

int ModuleModule::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 154 du fichier ModuleModule.h.

00155     {
00156         return NbFonction;
00157     };

char* ModuleModule::GetRealname (   )  [inline]
 

Retourne le nom réel du module.

Renvoie:
pointeur sur Realname.

Définition à la ligne 181 du fichier ModuleModule.h.

00182     {
00183         return Realname;
00184     };

char* ModuleModule::GetVersion (   )  [inline]
 

Retourne la version du module.

Renvoie:
pointeur sur Version.

Définition à la ligne 190 du fichier ModuleModule.h.

00191     {
00192         return Version;
00193     };

int ModuleModule::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 45 du fichier ModuleModule.cpp.

Références AddFonction(), AtoD(), BEGIN, CERROR, DtoA(), ENDBEGIN, ENDTRY, LOC, ModuleFonction, ModuleImport(), ModuleLoad(), PERROR, ROUTINE, TRY, et TRYIF.

Référencé par Module::AddModule().

00046 {
00047     int         i = 0, Nb;
00048     char        Nbr[12];
00049     ROUTINE     Temp;
00050     BEGIN
00051     LOC("ModuleModule::Load")
00052 
00053     if(!Loaded)
00054     {
00055         strcpy(Name, pName);
00056         strcpy(File, pFile);
00057 
00058         TRY if(ModuleLoad(&ModuleAdr, pFile))
00059         {
00060             printf("[Module] Load %36s [  OK  ]\n", pName);
00061 
00062             TRYIF(ModuleImport(ModuleAdr, &Temp, "ModuleInit"), 25)
00063             TRYIF((int)Temp(NULL), 27)
00064 
00065             TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleName"))
00066             {
00067                 strcpy(Realname, (char *)Temp(NULL));
00068             }
00069             ENDTRY(25)
00070 
00071             TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleVersion"))
00072             {
00073                 strcpy(Version, (char *)Temp(NULL));
00074             }
00075             ENDTRY(25)
00076 
00077             TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleDesc"))
00078             {
00079                 strcpy(Desc, (char *)Temp(NULL));
00080             }
00081             ENDTRY(25)
00082 
00083             TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleAutor"))
00084             {
00085                 strcpy(Autor, (char *)Temp(NULL));
00086             }
00087             ENDTRY(25)
00088 
00089             Loaded = 1;
00090 
00091             TRYIF(ModuleImport(ModuleAdr, &Fonction, "ModuleFonction"), 25)
00092 
00093             TRY {
00094                 for(i = 0; i < NbFonction; i++)
00095                 {
00096                     if(Fonctions[i])
00097                         free(Fonctions[i]);
00098                     Fonctions[i] = NULL;
00099                 }
00100                 if(Fonctions)
00101                     free(Fonctions);
00102                 Fonctions = NULL;
00103 
00104                 printf("\t%s V%s by %s\n", Realname, Version, Autor);
00105                 printf("\t%s\n", Desc);
00106             }
00107 
00108             TRY Nb = AtoD((char *)Fonction(NULL));
00109             TRY if(Nb)
00110             {
00111                 Fonctions = (ModuleFonction **)realloc(Fonctions, Nb * sizeof(ModuleFonction *));
00112 
00113                 for(i = 0; i < (Nb && !CERROR); i++)
00114                 {
00115                     Fonctions[i] = new ModuleFonction;
00116 
00117                     DtoA(i + 1, Nbr);
00118                     CERROR = AddFonction((char *)Fonction(Nbr));
00119                 }
00120             }
00121             ENDTRY(26)
00122         }
00123         else
00124         {
00125             printf("[Module] Load %36s [FAILED]\n", pName);
00126             CERROR = 23;
00127         }
00128     }
00129 
00130     PERROR
00131 
00132     ENDBEGIN
00133 }

int ModuleModule::UnLoad (   ) 
 

Decharge le module.

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

Définition à la ligne 135 du fichier ModuleModule.cpp.

Références BEGIN, CERROR, ENDBEGIN, LOC, ModuleImport(), ModuleUnload(), PERROR, ROUTINE, et TRY.

Référencé par Module::DelModule(), et ~ModuleModule().

00136 {
00137     int         i = 0;
00138     ROUTINE     Close;
00139     BEGIN
00140     LOC("ModuleModule::UnLoad")
00141 
00142     if(Loaded)
00143     {
00144         if(ModuleImport(ModuleAdr, &Close, "ModuleClose"))
00145             Close(NULL);
00146 
00147         TRY if(!ModuleUnload(&ModuleAdr))
00148         {
00149             printf("[Module] Unload %34s [  OK  ]\n", Name);
00150 
00151             for(i = 0; i < NbFonction; i++)
00152             {
00153                 if(Fonctions[i])
00154                     free(Fonctions[i]);
00155                 Fonctions[i] = NULL;
00156             }
00157             if(Fonctions)
00158                 free(Fonctions);
00159             Fonctions = NULL;
00160             NbFonction = 0;
00161             Loaded = 0;
00162         }
00163         else
00164         {
00165             printf("[Module] Unload %34s [FAILED]\n", Name);
00166             CERROR = 24;
00167         }
00168     }
00169 
00170     PERROR
00171 
00172     ENDBEGIN
00173 }

La documentation de cette classe a été générée à partir des fichiers suivants:
Généré le Thu Oct 12 01:00:45 2006 pour GestionAsso par  doxygen 1.3.9.1