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 Module

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

#include <Module.h>

Liste de tous les membres

Fonctions membres publiques

 Module ()
 ~Module ()
int LoadModules (char *pFile)
 Charge les modules.
int UnLoadModules ()
 Decharge tous les modules.
int AddModule (char *pName, char *pFile)
 Ajoute un module.
int DelModule (int iPos)
 Supprime un module.
int DelModule (char *pName)
 Supprime un module.
ModuleModule * GetModule (int iPos)
 Retourne un module par sa position.
ModuleModule * GetModule (char *pName)
 Retourne un module par son nom.
int GetNbModule ()
 Retourne le nombre de module.
int GetNbInstance ()
 Retourne le nombre d'instance.

Description détaillée

Permet l'utilisation de module dynamique comme simple classe.

Définition à la ligne 43 du fichier Module.h.

Documentation des contructeurs et destructeur

Module::Module (   ) 
 

Initialise.

Définition à la ligne 18 du fichier Module.cpp.

Références MutexInit().

00019 {
00020     if(!ModuleInstance)
00021         MutexInit(&ModuleMutex);
00022 
00023     ModuleInstance++;
00024 }

Module::~Module (   ) 
 

Libere proprement la mémoire, décharge les modules.

Définition à la ligne 26 du fichier Module.cpp.

Références MutexStop(), et UnLoadModules().

00027 {
00028     int     i;
00029 
00030     ModuleInstance--;
00031 
00032     if(!ModuleInstance)
00033     {
00034         UnLoadModules();
00035 
00036         MutexStop(&ModuleMutex);
00037 
00038         for(i = 0; i < NbModule; i++)
00039         {
00040             if(Modules[i])
00041                 free(Modules[i]);
00042             Modules[i] = NULL;
00043         }
00044         if(Modules)
00045             free(Modules);
00046         Modules = NULL;
00047     }
00048 }

Documentation des fonctions membres

int Module::AddModule (  char *  pName,
char *  pFile
) 
 

Ajoute un module de fichier pFile .

Paramètres:
pName nom du module
pFile fichier du module
Renvoie:
code d'erreur.
Voir également:
DelModule(), GetModule() et GetNbModule().

Définition à la ligne 139 du fichier Module.cpp.

Références BEGIN, CERROR, ENDBEGIN, ModuleModule::Load(), LOC, PERROR, et TRY.

Référencé par LoadModules().

00140 {
00141     ModuleModule    *ModuleTemp;
00142     BEGIN
00143     LOC("Module::AddModules")
00144 
00145     ModuleTemp = new ModuleModule;
00146 
00147     CERROR = ModuleTemp->Load(pName, pFile);
00148 
00149     TRY {
00150         Modules = (ModuleModule **)realloc(Modules, (NbModule + 1) * sizeof(ModuleModule *));
00151         Modules[NbModule] = ModuleTemp;
00152         NbModule++;
00153     }
00154     else
00155     {
00156         if(ModuleTemp)
00157             free(ModuleTemp);
00158         ModuleTemp = NULL;
00159     }
00160 
00161     PERROR
00162 
00163     ENDBEGIN
00164 }

int Module::DelModule (  char *  pName  )  [inline]
 

Supprime le module de nom pName.

Paramètres:
pName nom du module.
Renvoie:
code d'erreur.
Voir également:
AddModule(), GetModule() et GetNbModule().

Définition à la ligne 99 du fichier Module.h.

00100     {
00101         for(int i = 0; i < NbModule; i++)
00102         {
00103             if(!strcmp(Modules[i]->GetName(), pName))
00104                 return DelModule(i);
00105         }
00106     };

int Module::DelModule (  int  iPos  ) 
 

Supprime le module étant à la position iPos.

Paramètres:
iPos position du module.
Renvoie:
code d'erreur.
Voir également:
AddModule(), GetModule() et GetNbModule().

Définition à la ligne 166 du fichier Module.cpp.

Références BEGIN, CERROR, ENDBEGIN, ENDTRY, LOC, PERROR, TRY, et ModuleModule::UnLoad().

Référencé par UnLoadModules().

00167 {
00168     int     i;
00169     BEGIN
00170     LOC("Module::DelModules")
00171 
00172     if(iPos < NbModule)
00173     {
00174         CERROR = Modules[iPos]->UnLoad();
00175 
00176         TRY {
00177             if(Modules[iPos])
00178                 free(Modules[iPos]);
00179             Modules[iPos] = NULL;
00180 
00181             for(i = iPos; i < (NbModule - 1); Modules[i] = Modules[i++]);
00182             Modules = (ModuleModule **)realloc(Modules, (NbModule - 1) * sizeof(ModuleModule *));
00183 
00184             NbModule--;
00185         }
00186     }
00187     ENDTRY(24)
00188 
00189     PERROR
00190 
00191     ENDBEGIN
00192 }

ModuleModule* Module::GetModule (  char *  pName  )  [inline]
 

Permet l'acces au module ayant le nom pName que l'on a donnée.

Paramètres:
pName nom du module.
Renvoie:
pointeur sur la class du module.
Voir également:
AddModule(), DelModule() et GetNbModule().

Définition à la ligne 128 du fichier Module.h.

00129     {
00130         for(int i = 0; i < NbModule; i++)
00131         {
00132             if(!strcmp(Modules[i]->GetName(), pName))
00133                 return Modules[i];
00134         }
00135 
00136         return NULL;
00137     };

ModuleModule* Module::GetModule (  int  iPos  )  [inline]
 

Permet l'acces au module étant a la position iPos.

Paramètres:
iPos position du module.
Renvoie:
pointeur sur la class du module.
Voir également:
AddModule(), DelModule() et GetNbModule().

Définition à la ligne 114 du fichier Module.h.

00115     {
00116         if(iPos < NbModule)
00117             return Modules[iPos];
00118 
00119         return NULL;
00120     };

int Module::GetNbInstance (   )  [inline]
 

Retourne le nombre d'instance de la class (pour multitache).

Renvoie:
nombre d'instance de la class.

Définition à la ligne 153 du fichier Module.h.

00154     {
00155         return ModuleInstance;
00156     };

int Module::GetNbModule (   )  [inline]
 

Retourne le nombre de module géré.

Renvoie:
nombre de module géré.
Voir également:
AddModule(), DelModule() et GetModule().

Définition à la ligne 144 du fichier Module.h.

00145     {
00146         return NbModule;
00147     };

int Module::LoadModules (  char *  pFile  ) 
 

Efectue une mise à jour, charge les modules depuis le fichier de configuration pFile et
décharge ceux avec le paramètre 'u'.

Paramètres:
pFile fichier de configuration
Renvoie:
code d'erreur.
Voir également:
UnLoadModules().

Définition à la ligne 50 du fichier Module.cpp.

Références AddModule(), BEGIN, CERROR, ENDBEGIN, LOC, MutexLock(), MutexUnLock(), PERROR, TRY, et TRYIF.

00051 {
00052     FILE    *OSInfo;
00053     char    OS[] = "WIN";
00054     char    Section[12];
00055     char    ModuleName[MODULE_NAME];
00056     char    ModuleFile[MODULE_FILE];
00057     int     i;
00058     BEGIN
00059     LOC("Module::LoadModules")
00060 
00061     Ini     Fichier(pFile);
00062 
00063     MutexLock(&ModuleMutex);
00064 
00065 #ifndef WIN32
00066     system("uname -a > tmp.txt");
00067 
00068     OSInfo = fopen("tmp.txt", "r");
00069     if(OSInfo)
00070     {
00071         while(!feof(OSInfo))
00072         {
00073             if(fgets(ModuleFile, MODULE_FILE, OSInfo))
00074             {
00075                 if(strstr(ModuleFile, "Linux"))
00076                     strcpy(OS, "NUX");
00077                 else if(strstr(ModuleFile, "BSD"))
00078                     strcpy(OS, "BSD");
00079                 else if(strstr(ModuleFile, "SOLARIS"))
00080                     strcpy(OS, "SOL");
00081                 else if(strstr(ModuleFile, "Unix"))
00082                     strcpy(OS, "NIX");
00083             }
00084         }
00085         fclose(OSInfo);
00086     }
00087 
00088     system("rm tmp.txt");
00089 #endif
00090 
00091     sprintf(Section, "module%s", OS);
00092     printf("[Module] OS detected : %s\n", OS);
00093 
00094     TRY if(Fichier.GetSection(Section))
00095     {
00096         for(i = 0; i < Fichier.GetSection(Section)->GetNbItem(); i++)
00097         {
00098             TRY strcpy(ModuleName, Fichier.GetSection(Section)->GetItemName(i));
00099             TRYIF(ModuleName, 17)
00100             TRY strcpy(ModuleFile, Fichier.GetSection(Section)->GetItem(i)->GetData());
00101             TRYIF(ModuleFile, 17)
00102 
00103             CERROR = AddModule(ModuleName, ModuleFile);
00104         }
00105     }
00106     else
00107     {
00108         CERROR = 23;
00109         printf("[Module] No module to load in conf file\n");
00110     }
00111 
00112     MutexUnLock(&ModuleMutex);
00113 
00114     PERROR
00115 
00116     ENDBEGIN
00117 }

int Module::UnLoadModules (   ) 
 

Decharge tous les modules.

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

Définition à la ligne 119 du fichier Module.cpp.

Références BEGIN, CERROR, DelModule(), ENDBEGIN, LOC, MutexLock(), MutexUnLock(), et PERROR.

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

00120 {
00121     int     i;
00122     BEGIN
00123     LOC("Module::UnLoadModules")
00124 
00125     MutexLock(&ModuleMutex);
00126 
00127     for(i = 0; (i < NbModule) && (!CERROR); i++)
00128         CERROR = DelModule(i);
00129 
00130     delete [] Modules;
00131 
00132     MutexUnLock(&ModuleMutex);
00133 
00134     PERROR
00135 
00136     ENDBEGIN
00137 }

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