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 ModuleDynamique

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

#include <ModuleDynamique.h>

Liste de tous les membres

Fonctions membres publiques

 ModuleDynamique ()
 ~ModuleDynamique ()
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.
ModuleDynamiqueModule * GetModule (int iPos)
 Retourne un module par sa position.
ModuleDynamiqueModule * 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 41 du fichier ModuleDynamique.h.

Documentation des contructeurs et destructeur

ModuleDynamique::ModuleDynamique (   ) 
 

Initialise.

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

Références MutexInit().

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

ModuleDynamique::~ModuleDynamique (   ) 
 

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

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

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

00027 {
00028     ModuleInstance--;
00029 
00030     if(!ModuleInstance)
00031     {
00032         UnLoadModules();
00033 
00034         MutexStop(&ModuleMutex);
00035 
00036         Modules.clear();
00037     }
00038 }

Documentation des fonctions membres

int ModuleDynamique::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 105 du fichier ModuleDynamique.cpp.

Références LOC, et TRY.

Référencé par LoadModules().

00106 {
00107     BEGIN
00108     LOC("ModuleDynamique::AddModules")
00109 
00110     Modules.push_back(new ModuleDynamiqueModule);
00111     
00112     if(!Modules[NbModule])
00113         CERROR = ERROR_C_MEMORY;
00114     else
00115     {
00116         CERROR = Modules.back()->Load(pName, pFile);
00117 
00118         TRY NbModule++;
00119         else
00120             Modules.erase(Modules.begin() + NbModule);
00121     }
00122     
00123     PERROR
00124 
00125     ENDBEGIN
00126 }

int ModuleDynamique::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 97 du fichier ModuleDynamique.h.

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

int ModuleDynamique::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 128 du fichier ModuleDynamique.cpp.

Références LOC, et TRY.

Référencé par UnLoadModules().

00129 {
00130     BEGIN
00131     LOC("ModuleDynamique::DelModules")
00132 
00133     if(iPos < NbModule)
00134     {
00135         CERROR = Modules[iPos]->UnLoad();
00136 
00137         TRY {
00138             delete Modules[iPos];
00139             Modules.erase(Modules.begin() + iPos);
00140 
00141             NbModule--;
00142         }
00143     }
00144     ENDTRY(ERROR_C_UNLOAD_DLL)
00145 
00146     PERROR
00147 
00148     ENDBEGIN
00149 }

ModuleDynamiqueModule* ModuleDynamique::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 126 du fichier ModuleDynamique.h.

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

ModuleDynamiqueModule* ModuleDynamique::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 112 du fichier ModuleDynamique.h.

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

int ModuleDynamique::GetNbInstance (   )  [inline]
 

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

Renvoie:
nombre d'instance de la class.

Définition à la ligne 151 du fichier ModuleDynamique.h.

00152     {
00153         return ModuleInstance;
00154     };

int ModuleDynamique::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 142 du fichier ModuleDynamique.h.

00143     {
00144         return NbModule;
00145     };

int ModuleDynamique::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 40 du fichier ModuleDynamique.cpp.

Références AddModule(), LOC, MutexLock(), MutexUnLock(), et TRY.

00041 {
00042     char    OS[] = "WIN";
00043     char    Section[12];
00044     char    ModuleName[MODULE_NAME];
00045     char    ModuleFile[MODULE_FILE];
00046     int     i;
00047     BEGIN
00048     LOC("ModuleDynamique::LoadModules")
00049 
00050     Ini     Fichier(pFile);
00051 
00052     MutexLock(&ModuleMutex);
00053 
00054 #ifndef WIN32
00055     strcpy(OS, "NUX");
00056 #endif
00057 
00058     sprintf(Section, "module%s", OS);
00059     printf("[Module] OS detected : %s\n", OS);
00060 
00061     TRY if(Fichier.GetSection(Section))
00062     {
00063         for(i = 0; i < Fichier.GetSection(Section)->GetNbItem(); i++)
00064         {
00065             TRY strcpy(ModuleName, Fichier.GetSection(Section)->GetItemName(i));
00066             TRYIF(ModuleName, ERROR_C_CONF_FILE)
00067             TRY strcpy(ModuleFile, Fichier.GetSection(Section)->GetItem(i)->GetData());
00068             TRYIF(ModuleFile, ERROR_C_CONF_FILE)
00069 
00070             CERROR = AddModule(ModuleName, ModuleFile);
00071         }
00072     }
00073     else
00074     {
00075         CERROR = ERROR_C_LOAD_DLL;
00076         printf("[Module] No module to load in conf file\n");
00077     }
00078 
00079     MutexUnLock(&ModuleMutex);
00080 
00081     PERROR
00082 
00083     ENDBEGIN
00084 }

int ModuleDynamique::UnLoadModules (   ) 
 

Decharge tous les modules.

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

Définition à la ligne 86 du fichier ModuleDynamique.cpp.

Références DelModule(), LOC, MutexLock(), et MutexUnLock().

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

00087 {
00088     BEGIN
00089     LOC("ModuleDynamique::UnLoadModules")
00090 
00091     MutexLock(&ModuleMutex);
00092 
00093     while(NbModule)
00094     {
00095         CERROR = DelModule(NbModule - 1);
00096     }
00097 
00098     MutexUnLock(&ModuleMutex);
00099 
00100     PERROR
00101 
00102     ENDBEGIN
00103 }

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