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

Référence de la classe XMLObjet

Gestion de fichiers XML. Plus de détails...

#include <XMLObjet.h>

Graphe d'héritage de XMLObjet:

XML Liste de tous les membres

Fonctions membres publiques

 XMLObjet ()
 ~XMLObjet ()
void LogError (char *pDesc)
 Log une erreur.
int Load (int iNoLine=1, int iNoCar=0)
 Charge un fichier.
int Save (int iDec=0)
 Sauve dans un fichier.
int GetNbInstance ()
 Retourne le nombre d'instance.
char * GetFileName ()
 Retourne le nom du fichier.
int Print (FILE *pFile)
 Affiche la structure.
int GetType ()
 Retourne le type de l'objet.
char * GetName ()
 Retourne le nom de l'objet.
char * SetName (char *pName)
 Définie le nom de l'objet.
int GetSize ()
 Retourne Size.
int Print (int iDec=0)
 Affiche la structure.
int AddParam (char *pName, char *pData)
 Ajoute un paramétre.
int DelParam (int iPos)
 Supprime un paramétre.
int DelParam (char *pName)
 Supprime un paramétre.
XMLParam * GetParam (int iPos)
 Retourne un paramétre.
XMLParam * GetParam (char *pName)
 Retourne un paramétre.
int GetNbParam ()
 Retourne le nombre de paramétre.
int Add ()
 Ajoute un objet.
int Del (int iPos)
 Supprime un objet.
int Del (char *pName)
 Supprime un objet.
XMLObjet * GetSousObjet (int iPos)
 Retourne un sous-objet.
XMLObjet * GetSousObjet (char *pName)
 Retourne un sous-objet.
char * GetSpecial (int iPos)
 Retourne un objet spécial.
char * GetData (int iPos)
 Retourne un objet data.
int GetNbObjet ()
 Retourne le nombre de sous objet.

Attributs protégés

char FileName [XML_FILENAME]

Attributs protégés statiques

FILE * File = NULL
int XMLInstance = 0
MUTEX XMLMutex

Description détaillée

Gestion de fichiers XML.

Définition à la ligne 63 du fichier XMLObjet.h.

Documentation des contructeurs et destructeur

XMLObjet::XMLObjet (   ) 
 

Initialise avec des parametres par defaut.

Définition à la ligne 19 du fichier XMLObjet.cpp.

Référencé par XML::XML().

00020 {
00021     Type    = XML_TYPE_OBJET;
00022     *Name   = '\0';
00023     NbParam = 0;
00024     NbObjet = 0;
00025     Data    = NULL;
00026 };

XMLObjet::~XMLObjet (   ) 
 

Libere proprement la mémoire.

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

00029 {
00030     int     i;
00031 
00032     for(i = 0; i < NbParam; i++)
00033         delete Params[i];
00034     Params.clear();
00035 
00036     for(i = 0; i < NbObjet; i++)
00037         delete Objets[i];
00038     Objets.clear();
00039 
00040     if(Data)
00041         free(Data);
00042 }

Documentation des fonctions membres

int XMLObjet::Add (   ) 
 

Ajoute un objet de type XML_OBJET.

Renvoie:
code d'erreur.
Voir également:
Del(), GetSousObjet(), GetSPecial() et GetData().

Définition à la ligne 455 du fichier XMLObjet.cpp.

Référencé par Load().

00456 {
00457     Objets.push_back(new XMLObjet);
00458 
00459     if(!Objets[NbObjet])
00460         return ERROR_C_MEMORY;
00461 
00462     Size++;
00463 
00464     return ERROR_C_NOERROR;
00465 }

int XMLObjet::AddParam (  char *  pName,
char *  pData
) 
 

Ajoute un paramétre avec comme nom pName.

Paramètres:
pName nom du paramétre
pData données du paramétre
Renvoie:
code d'erreur.
Voir également:
DelParam(), GetParam() et GetNbParam().

Définition à la ligne 430 du fichier XMLObjet.cpp.

Référencé par Load().

00431 {
00432     Params.push_back(new XMLParam);
00433 
00434     if(!Params[NbParam])
00435         return ERROR_C_MEMORY;
00436 
00437     NbParam++;
00438 
00439     return ERROR_C_NOERROR;
00440 }

int XMLObjet::Del (  char *  pName  )  [inline]
 

Supprime l'objet étant à la position iPos.

Paramètres:
pName nom de l'objet.
Renvoie:
code d'erreur.
Voir également:
Add(), GetSousObjet(), GetSPecial() et GetData().

Définition à la ligne 297 du fichier XMLObjet.h.

00298     {
00299         for(int i = 0; i < NbObjet; i++)
00300         {
00301             if(Objets[i]->Type == XML_TYPE_OBJET)
00302                 if(!strcmp(Objets[i]->Name, pName))
00303                     return Del(i);
00304         }
00305 
00306         return ERROR_C_NOERROR;
00307     };

int XMLObjet::Del (  int  iPos  ) 
 

Supprime l'objet étant à la position iPos.

Paramètres:
iPos position de l'objet.
Renvoie:
code d'erreur.
Voir également:
Add(), GetSousObjet(), GetSPecial() et GetData().

Définition à la ligne 467 du fichier XMLObjet.cpp.

00468 {
00469     if((NbObjet > 0) && (iPos < NbObjet))
00470     {
00471         Objets.erase(Objets.begin() + iPos);
00472 
00473         Size--;
00474     }
00475 
00476     return ERROR_C_NOERROR;
00477 }

int XMLObjet::DelParam (  char *  pName  )  [inline]
 

Supprime le paramétre ayant le nom pName.

Paramètres:
pName nom du paramétre.
Renvoie:
code d'erreur.
Voir également:
AddParam(), GetParam() et GetNbParam().

Définition à la ligne 223 du fichier XMLObjet.h.

00224     {
00225         for(int i = 0; i < NbParam; i++)
00226         {
00227             if(!strcmp(Params[i]->Name, pName))
00228                 return DelParam(i);
00229         }
00230 
00231         return ERROR_C_NOERROR;
00232     };

int XMLObjet::DelParam (  int  iPos  ) 
 

Supprime le paramétre étant à la position iPos.

Paramètres:
iPos position du paramétre.
Renvoie:
code d'erreur.
Voir également:
AddParam(), GetParam() et GetNbParam().

Définition à la ligne 442 du fichier XMLObjet.cpp.

00443 {
00444     if((NbParam > 0) && (iPos < NbParam))
00445     {
00446         Params.erase(Params.begin() + iPos);
00447 
00448         NbParam--;
00449     }
00450 
00451     return ERROR_C_NOERROR;
00452 }

char* XMLObjet::GetData (  int  iPos  )  [inline]
 

Retourne l'objet data étant à la position iPos.

Paramètres:
iPos position de l'objet data.
Renvoie:
pointeur sur la data de l'objet data Data.
Voir également:
Add() et Del().

Définition à la ligne 363 du fichier XMLObjet.h.

00364     {
00365         if(iPos < NbObjet)
00366             if(Objets[iPos]->Type == XML_TYPE_DATA)
00367                 return Data;
00368 
00369         return NULL;
00370     };

char* XMLObjet::GetFileName (   )  [inline]
 

Retourne le nom du fichier XML FileName.

Renvoie:
un pointeur sur le nom du fichier XML FileName.

Définition à la ligne 136 du fichier XMLObjet.h.

00137     {
00138         return FileName;
00139     };

char* XMLObjet::GetName (   )  [inline]
 

Retourne le nom de l'objet Name.

Renvoie:
un pointeur sur le nom de l'objet Name.
Voir également:
SetName().

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

00164     {
00165         return Name;
00166     };

int XMLObjet::GetNbInstance (   )  [inline]
 

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

Renvoie:
nombre d'instance de la class.

Définition à la ligne 127 du fichier XMLObjet.h.

00128     {
00129         return XMLInstance;
00130     };

int XMLObjet::GetNbObjet (   )  [inline]
 

Retourne le nombre de sous objet de l'objet.

Renvoie:
nombre de sous objet de l'objet.
Voir également:
Add(), Del() et GetSousObjet().

Définition à la ligne 377 du fichier XMLObjet.h.

00378     {
00379         return NbObjet;
00380     };

int XMLObjet::GetNbParam (   )  [inline]
 

Retourne le nombre de paramétre de l'objet.

Renvoie:
nombre de paramétre de l'objet.
Voir également:
AddParam(), DelParam() et GetParam().

Définition à la ligne 270 du fichier XMLObjet.h.

00271     {
00272         return NbParam;
00273     };

XMLParam* XMLObjet::GetParam (  char *  pName  )  [inline]
 

Retourne le paramétre ayant le nom pName.

Paramètres:
pName nom du paramétre.
Renvoie:
pointeur sur la structure du paramétre.
Voir également:
AddParam(), DelParam() et GetNbParam().

Définition à la ligne 254 du fichier XMLObjet.h.

00255     {
00256         for(int i = 0; i < NbParam; i++)
00257         {
00258             if(!strcmp(Params[i]->Name, pName))
00259                 return Params[i];
00260         }
00261 
00262         return NULL;
00263     };

XMLParam* XMLObjet::GetParam (  int  iPos  )  [inline]
 

Retourne le paramétre étant à la position iPos.

Paramètres:
iPos position du paramétre.
Renvoie:
pointeur sur la structure du paramétre.
Voir également:
AddParam(), DelParam() et GetNbParam().

Définition à la ligne 240 du fichier XMLObjet.h.

00241     {
00242         if(iPos < NbParam)
00243             return Params[iPos];
00244 
00245         return NULL;
00246     };

int XMLObjet::GetSize (   )  [inline]
 

Retourne le nombre, Size , d'objet ou la taille de data.

Renvoie:
le nombre, Size , d'objet ou la taille de data.

Définition à la ligne 186 du fichier XMLObjet.h.

00187     {
00188         return Size;
00189     };

XMLObjet* XMLObjet::GetSousObjet (  char *  pName  )  [inline]
 

Retourne le sous-objet ayant le nom pName.

Paramètres:
pName nom du sous-objet.
Renvoie:
pointeur sur la structure du sous-objet.
Voir également:
Add() et Del().

Définition à la ligne 330 du fichier XMLObjet.h.

00331     {
00332         for(int i = 0; i < NbObjet; i++)
00333         {
00334             if(Objets[i]->Type == XML_TYPE_OBJET)
00335                 if(!strcmp(Objets[i]->Name, pName))
00336                     return Objets[i];
00337         }
00338 
00339         return NULL;
00340     };

XMLObjet* XMLObjet::GetSousObjet (  int  iPos  )  [inline]
 

Retourne le sous-objet étant à la position iPos.

Paramètres:
iPos position du sous-objet.
Renvoie:
pointeur sur la structure du sous-objet.
Voir également:
Add() et Del().

Définition à la ligne 315 du fichier XMLObjet.h.

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

00316     {
00317         if(iPos < NbObjet)
00318             if(Objets[iPos]->Type == XML_TYPE_OBJET)
00319                 return Objets[iPos];
00320 
00321         return NULL;
00322     };

char* XMLObjet::GetSpecial (  int  iPos  )  [inline]
 

Retourne l'objet spécial étant à la position iPos.

Paramètres:
iPos position de l'objet spécial.
Renvoie:
pointeur sur la data de l'objet spécial Data.
Voir également:
Add() et Del().

Définition à la ligne 348 du fichier XMLObjet.h.

00349     {
00350         if(iPos < NbObjet)
00351             if(Objets[iPos]->Type == XML_TYPE_SPECIAL)
00352                 return Data;
00353 
00354         return NULL;
00355     };

int XMLObjet::GetType (   )  [inline]
 

Retourne le type de l'objet Type.

Renvoie:
le type de l'objet Type.

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

Référencé par Print().

00154     {
00155         return Type;
00156     };

int XMLObjet::Load (  int  iNoLine = 1,
int  iNoCar = 0
) 
 

Charge un fichier XML en mémoire.

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

Définition à la ligne 59 du fichier XMLObjet.cpp.

Références Add(), AddParam(), BEGIN, CERROR, ENDBEGIN, File, GetSousObjet(), IsAlphaNumCar(), LOC, LogError(), PERROR, TRY, et TRYNIF.

Référencé par XML::Load().

00060 {
00061     char    TempBuffer[XML_BUFFER];
00062     char    TempName[XML_NAME];
00063     char    TempName2[XML_NAME];
00064     char    TempParam[XML_TEMP];
00065     int     iName = 0, iName2 = 0, iParam = 0, iBuffer = 0;
00066     int     GetString = 0;
00067     char    Car = '\0';
00068     int     Mode = 0;
00069 printf("\ndebug\n");
00070 
00071     BEGIN
00072     LOC("XMLObjet::Load");
00073 
00074     TRY if(File)
00075     {
00076         NoLine = iNoLine;
00077         NoCar = iNoCar;
00078 
00079         while(!feof(File) && !CERROR && (Mode != XML_CLOSE_CLOSE))
00080         {
00081             TRYNIF(Mode > XML_SPECIAL, ERROR_C_UNKNOW);
00082 
00083             TRY Car = (char)fgetc(File);
00084 
00085             if(Car == '\n')
00086             {
00087                 NoLine++;
00088                 NoCar = 0;
00089             }
00090             else
00091                 NoCar++;
00092 
00093             TRY
00094             {
00095                 switch(Car)
00096                 {
00097                     case    '<' :
00098                         switch(Mode)
00099                         {
00100                             case    XML_VIERGE      :
00101                                 Mode = XML_OPEN_OPEN;
00102                                 break;
00103                             case    XML_OPEN_OPEN   :
00104                                 LogError(NoLine, NoCar, "'<' found, already opened");
00105                                 break;
00106                             case    XML_OBJET_NAME  :
00107                                 LogError(NoLine, NoCar, "'<' found, '>' homited");
00108                                 break;
00109                             case    XML_PARAM_NAME  :
00110                                 LogError(NoLine, NoCar, "'<' found, parameter value needed");
00111                                 break;
00112                             case    XML_PARAM_FOUND :
00113                                 LogError(NoLine, NoCar, "'<' found, parameter value needed");
00114                                 break;
00115                             case    XML_PARAM_DATA  :
00116                                 LogError(NoLine, NoCar, "'<' found, '>' homited");
00117                                 break;
00118                             case    XML_OPEN_CLOSE  :
00119                                 TRY if(fseek(File, -1, SEEK_CUR))
00120                                 {
00121                                     LogError(NoLine, NoCar, "Repositioning seek for new objet");
00122                                     CERROR = 17;
00123                                 }
00124                                 TRY NoCar--;
00125                                 TRY CERROR = Add();
00126                                 TRY GetSousObjet(NbObjet - 1)->Load(NoLine, NoCar);
00127                                 TRY Mode = XML_DATA;
00128                                 break;
00129                             case    XML_DATA    :
00130                                 if(!GetString)
00131                                 {
00132                                     Type = XML_TYPE_DATA;
00133                                     TempBuffer[iBuffer] = '\0';
00134                                     Size = strlen(TempBuffer);
00135                                     Data = (char *)malloc(sizeof(char) * (Size + 1));
00136                                     strcpy(Data, TempBuffer);
00137                                     Mode = XML_CLOSE_OPEN;
00138                                 }
00139                                 else
00140                                     LogError(NoLine, NoCar, "'<' found, '\"' not closed");
00141                                 break;
00142                             case    XML_CLOSE_OPEN  :
00143                                 LogError(NoLine, NoCar, "'<' found, already opened");
00144                                 break;
00145                             case    XML_CLOSE_FOUND :
00146                                 LogError(NoLine, NoCar, "'<' found, '>' homited");
00147                                 break;
00148                             case    XML_CLOSE_CLOSE :
00149                                 LogError(NoLine, NoCar, "'<' found, parsing error, object not closed");
00150                                 break;
00151                             case    XML_SPECIAL     :
00152                                 LogError(NoLine, NoCar, "'<' found, '>' homited");
00153                                 break;
00154                         }
00155                         break;
00156 
00157                     case    '>' :
00158                         switch(Mode)
00159                         {
00160                             case    XML_VIERGE      :
00161                                 LogError(NoLine, NoCar, "'>' found, '<' homited");
00162                                 break;
00163                             case    XML_OPEN_OPEN   :
00164                                 LogError(NoLine, NoCar, "'>' found, homited object name");
00165                                 break;
00166                             case    XML_OBJET_NAME  :
00167                                 TempName[iName] = '\0';
00168                                 strcpy(Name, TempName);
00169                                 Mode = XML_OPEN_CLOSE;
00170                                 break;
00171                             case    XML_PARAM_NAME  :
00172                                 LogError(NoLine, NoCar, "'>' found, homited parameter value");
00173                                 break;
00174                             case    XML_PARAM_FOUND :
00175                                 LogError(NoLine, NoCar, "'>' found, homited parameter value");
00176                                 break;
00177                             case    XML_PARAM_DATA  :
00178                                 if(!GetString)
00179                                 {
00180                                     TempParam[iParam] = '\0';
00181                                     TempBuffer[iBuffer] = '\0';
00182                                     AddParam(TempParam, TempBuffer);
00183                                     Mode = XML_OPEN_CLOSE;
00184                                 }
00185                                 else
00186                                     LogError(NoLine, NoCar, "'>' found, '\"' not close");
00187                                 break;
00188                             case    XML_OPEN_CLOSE  :
00189                                 LogError(NoLine, NoCar, "'>' found, already closed");
00190                                 break;
00191                             case    XML_DATA    :
00192                                 LogError(NoLine, NoCar, "'>' found, '<' homited");
00193                                 break;
00194                             case    XML_CLOSE_OPEN  :
00195                                 LogError(NoLine, NoCar, "'>' found, homited '/'");
00196                                 break;
00197                             case    XML_CLOSE_FOUND :
00198                                 TempName2[iName2] = '\0';
00199                                 if(!strcmp(TempName2, TempName))
00200                                     Mode = XML_CLOSE_CLOSE;
00201                                 else
00202                                     LogError(NoLine, NoCar, "Objet's name dont match");
00203                                 break;
00204                             case    XML_CLOSE_CLOSE :
00205                                 LogError(NoLine, NoCar, "'>' found, objet not closed");
00206                                 break;
00207                             case    XML_SPECIAL     :
00208                                 Type = XML_TYPE_SPECIAL;
00209                                 TempBuffer[iBuffer] = '\0';
00210                                 Size = strlen(TempBuffer);
00211                                 Data = (char *)malloc(sizeof(char) * (Size + 1));
00212                                 strcpy(Data, TempBuffer);
00213                                 Mode = XML_CLOSE_CLOSE;
00214                                 break;
00215                         }
00216                         break;
00217 
00218                     case    ' ' :
00219                         switch(Mode)
00220                         {
00221                             case    XML_OBJET_NAME  :
00222                                 TempName[iName] = '\0';
00223                                 strcpy(Name, TempName);
00224                                 iParam = 0;
00225                                 Mode = XML_PARAM_NAME;
00226                                 break;
00227                             case    XML_PARAM_DATA  :
00228                                 if(!GetString)
00229                                 {
00230                                     TempParam[iParam] = '\0';
00231                                     TempBuffer[iBuffer] = '\0';
00232                                     AddParam(TempParam, TempBuffer);
00233                                     iParam = 0;
00234                                     Mode = XML_PARAM_NAME;
00235                                 }
00236                                 else
00237                                     TempBuffer[iBuffer++] = Car;
00238                                 break;
00239                             case    XML_DATA        :
00240                                 TempBuffer[iBuffer++] = Car;
00241                                 break;
00242                             case    XML_SPECIAL     :
00243                                 TempBuffer[iBuffer++] = Car;
00244                                 break;
00245                         }
00246                         break;
00247 
00248                     case    '=' :
00249                         if(Mode == XML_PARAM_NAME)
00250                             Mode = XML_PARAM_FOUND;
00251                         else
00252                         {
00253                             if(GetString || (Mode == XML_SPECIAL))
00254                                 TempBuffer[iBuffer++] = Car;
00255                             else
00256                                 LogError(NoLine, NoCar, "'=' found without parameter");
00257                         }
00258                         break;
00259 
00260                     case    '/' :
00261                         switch(Mode)
00262                         {
00263                             case    XML_OBJET_NAME  :
00264                                 Mode = XML_CLOSE_FOUND;
00265                                 break;
00266                             case    XML_PARAM_DATA  :
00267                                 Mode = XML_CLOSE_FOUND;
00268                                 break;
00269                             case    XML_CLOSE_OPEN  :
00270                                 Mode = XML_CLOSE_FOUND;
00271                                 break;
00272                             default     :
00273                                 if(GetString || (Mode == XML_SPECIAL))
00274                                     TempBuffer[iBuffer++] = Car;
00275                                 else
00276                                     LogError(NoLine, NoCar, "'/' found, '<' homited");
00277                                 break;
00278                         }
00279                         break;
00280 
00281                     case    '\"':
00282                         switch(Mode)
00283                         {
00284                             case    XML_PARAM_FOUND :
00285                                 if(!GetString)
00286                                 {
00287                                     iBuffer = 0;
00288                                     GetString = 1;
00289                                 }
00290                                 break;
00291                             case    XML_PARAM_DATA  :
00292                                 if(GetString)
00293                                 {
00294                                     GetString = 0;
00295                                     TempParam[iParam] = '\0';
00296                                     TempBuffer[iBuffer] = '\0';
00297                                     AddParam(TempParam, TempBuffer);
00298                                 }
00299                                 else
00300                                     LogError(NoLine, NoCar, "'\"' found but not opened");
00301                                 break;
00302                             case    XML_OPEN_CLOSE  :
00303                                 iBuffer = 0;
00304                                 TempBuffer[iBuffer++] = Car;
00305                                 Mode = XML_DATA;
00306                                 break;
00307                             case    XML_DATA        :
00308                                 TempBuffer[iBuffer++] = Car;
00309                                 break;
00310                             case    XML_SPECIAL     :
00311                                 TempBuffer[iBuffer++] = Car;
00312                                 break;
00313                             default     :
00314                                 LogError(NoLine, NoCar, "'\"' found");
00315                         }
00316                         break;
00317 
00318                     default     :
00319                         switch(Mode)
00320                         {
00321                             case    XML_VIERGE      :
00322                                 LogError(NoLine, NoCar, "no object opened");
00323                                 break;
00324                             case    XML_OPEN_OPEN   :
00325                                 if(IsAlphaNumCar(Car))
00326                                 {
00327                                     iName = 0;
00328                                     TempName[iName++] = Car;
00329                                     Mode = XML_OBJET_NAME;
00330                                 }
00331                                 else
00332                                 {
00333                                     iBuffer = 0;
00334                                     TempBuffer[iBuffer++] = Car;
00335                                     Mode = XML_SPECIAL;
00336                                 }
00337                                 break;
00338                             case    XML_OBJET_NAME  :
00339                                 if(IsAlphaNumCar(Car) || (Car == ':'))
00340                                     TempName[iName++] = Car;
00341                                 else
00342                                     LogError(NoLine, NoCar, "alphanum char only in name");
00343                                 break;
00344                             case    XML_PARAM_NAME  :
00345                                 if(IsAlphaNumCar(Car))
00346                                     TempParam[iParam++] = Car;
00347                                 else
00348                                     LogError(NoLine, NoCar, "alphanum char only in name");
00349                                 break;
00350                             case    XML_PARAM_FOUND :
00351                                 iBuffer = 0;
00352                                 TempBuffer[iBuffer++] = Car;
00353                                 Mode = XML_PARAM_DATA;
00354                                 break;
00355                             case    XML_PARAM_DATA  :
00356                                 TempBuffer[iBuffer++] = Car;
00357                                 break;
00358                             case    XML_OPEN_CLOSE  :
00359                                 iBuffer = 0;
00360                                 TempBuffer[iBuffer++] = Car;
00361                                 Mode = XML_DATA;
00362                                 break;
00363                             case    XML_DATA        :
00364                                 TempBuffer[iBuffer++] = Car;
00365                                 iName2 = 0;
00366                                 break;
00367                             case    XML_CLOSE_OPEN  :
00368                                 LogError(NoLine, NoCar, "/ homited");
00369                                 break;
00370                             case    XML_CLOSE_FOUND :
00371                                 if(IsAlphaNumCar(Car) || (Car == ':'))
00372                                     TempName2[iName2++] = Car;
00373                                 else
00374                                     LogError(NoLine, NoCar, "alphanum char only in name");
00375                                 break;
00376                             case    XML_CLOSE_CLOSE :
00377                                 LogError(NoLine, NoCar, "objet was closed");
00378                                 break;
00379                             case    XML_SPECIAL     :
00380                                 TempBuffer[iBuffer++] = Car;
00381                                 break;
00382                         }
00383                 } //switch(Car)
00384             } //TRY
00385             else
00386                 LogError(NoLine, NoCar, "Reading char");
00387         } //while(...)
00388     } //if(File)
00389     else
00390         LogError(NoLine, NoCar, "The file descriptor is closed");
00391 
00392     PERROR
00393 
00394     ENDBEGIN
00395 }

void XMLObjet::LogError (  char *  pDesc  ) 
 

Log une erreur de parsage dans le fichier XMLError.log.

Paramètres:
pDesc descryption de l'erreur

Référencé par Load().

int XMLObjet::Print (  int  iDec = 0  ) 
 

Affiche la structure des objets vers le fichier File.

Paramètres:
iDec nombre de tabulation pour l'indentation.
Renvoie:
code d'erreur.
Voir également:
Load().

Définition à la ligne 403 du fichier XMLObjet.cpp.

Références BEGIN, CERROR, ENDBEGIN, File, GetSousObjet(), GetType(), LOC, PERROR, Print(), et TRY.

00404 {
00405     int     i;
00406     BEGIN
00407     LOC("XMLObjet::Print");
00408 
00409     TRY if(File)
00410     {
00411         for(i = 0; i < iDec; i++)
00412             fputc('\t', File);
00413         fprintf(File, "%s\n", Name);
00414 
00415         for(i = 0; i < Size; i++)
00416         {
00417             TRY if(GetSousObjet(i)->GetType() == XML_TYPE_OBJET)
00418             {
00419                 TRY CERROR = GetSousObjet(i)->Print();
00420             }
00421         }
00422     }
00423 
00424     PERROR
00425 
00426     ENDBEGIN
00427 }

int XMLObjet::Print (  FILE *  pFile  ) 
 

Enregistre la structure des objets dans le fichier pFileName.

Paramètres:
pFileName fichier destination.
Renvoie:
code d'erreur.
Voir également:
Load().

Réimplémentée dans XML.

Référencé par Print(), et XML::Print().

int XMLObjet::Save (  int  iDec = 0  ) 
 

Poursuit la sauvegarde vers le fichier.

Paramètres:
iDec nombre de tabulation pour l'indentation.
Renvoie:
code d'erreur.
Voir également:
Load().

Définition à la ligne 397 du fichier XMLObjet.cpp.

Référencé par XML::Save().

00398 {
00399 
00400     return 0;
00401 }

char* XMLObjet::SetName (  char *  pName  )  [inline]
 

Définie le nom de l'objet Name.

Paramètres:
pName nom de l'objet.
Renvoie:
un pointeur sur le nom de l'objet Name.
Voir également:
GetName().

Définition à la ligne 174 du fichier XMLObjet.h.

00175     {
00176         for(int i = 0; (i < (XML_NAME - 1)) && pName[i]; i++)
00177             Name[i] = pName[i];
00178 
00179         return Name;
00180     };

Documentation des données membres

FILE * XMLObjet::File = NULL [static, protected]
 

Descripteur du fichier destination.

Définition à la ligne 14 du fichier XMLObjet.cpp.

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

char XMLObjet::FileName[XML_FILENAME] [protected]
 

Nom du fichier.

Définition à la ligne 87 du fichier XMLObjet.h.

int XMLObjet::XMLInstance = 0 [static, protected]
 

Compte les instance de la class.

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

MUTEX XMLObjet::XMLMutex [static, protected]
 

Utiliser des que l'on accede à un fichier.

Définition à la ligne 14 du fichier XML.cpp.

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