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 DataBaseTable

Gestion d'une table. Plus de détails...

#include <DataBaseTable.h>

Liste de tous les membres

Fonctions membres publiques

 DataBaseTable (char *pRepertoire, int iId, int iNbData=0, char *pName=NULL)
 ~DataBaseTable ()
int AddEntry ()
 Ajoute une entrée.
int DelEntry (int iId)
 Supprime une entrée.
DataBaseEntry * GetEntry (int iId)
 Retourne une entrée.
DataBaseEntry * GetEntryNo (int iPos)
 Retourne une entrée.
int GetEntryId (int iPos)
 Retourne l'id d'une entrée.
DataBaseData * GetData (int iId, int iPos)
 Retourne une data d'une entrée.
DataBaseData * GetData (int iId, char *pName)
 Retourne une data d'une entrée.
DataBaseData * GetDataNo (int iPos, int iPos2)
 Retourne une data d'une entrée.
DataBaseData * GetDataNo (int iPos, char *pName)
 Retourne une data d'une entrée.
int GetNbEntry ()
 Retourne le nombre d'entrée.
int GetId ()
 Retourne l'id de la table.
char * GetName ()
 Retourne le nom de la table.
char * SetName (char *pName)
 Définie le nom de la table.
int GetNbData ()
 Retourne le nombre de data d'une entrée.
int AddLabel (char *pName)
 Ajoute un label.
int DelLabel (char *pName)
 Supprimse un label.
char * GetLabel (int iPos)
 Retourne le nom d'un champ.
char * SetLabel (int iPos, char *pName)
 Définie le nom d'un champ.
int SaveEntrys ()
 Sauve le fichier des entrées.

Description détaillée

Gestion d'une table dans la base de données DataBase.

Définition à la ligne 27 du fichier DataBaseTable.h.

Documentation des contructeurs et destructeur

DataBaseTable::DataBaseTable (  char *  pRepertoire,
int  iId,
int  iNbData = 0,
char *  pName = NULL
) 
 

Charge la table en mémoire avec des paramétres par defauts.

Paramètres:
pRepertoire repertoire de la base.
iId Id de la table.
iNbData nombre de champs.
pName nom de la table.

Définition à la ligne 17 du fichier DataBaseTable.cpp.

Références DB_NAME, DB_REPERTOIRE, et MutexInit().

00018 {
00019     strncpy(Repertoire, pRepertoire, DB_REPERTOIRE);
00020     Id      = iId;
00021     NbData  = iNbData;
00022     NbEntry = 0;
00023     IdMax   = 0;
00024 
00025     for(int i = 0; i < NbData; i++)
00026     {
00027         Labels.push_back(new char[5]);
00028         sprintf(Labels[i], "%i", i);
00029     }
00030 
00031     if(pName)
00032         strncpy(Name, pName, DB_NAME);
00033 
00034     if(!DBTableCount)
00035         MutexInit(&DBMutexTable);
00036 
00037     DBTableCount++;
00038 
00039     LoadEntrys();
00040 }

DataBaseTable::~DataBaseTable (   ) 
 

Sauve la table dans un fichier.

Définition à la ligne 42 du fichier DataBaseTable.cpp.

Références MutexStop().

00043 {
00044     int     i;
00045 
00046     for(i = 0; i < NbEntry; i++)
00047         delete Entrys[i];
00048     Entrys.clear();
00049 
00050     for(i = 0; i < NbData; i++)
00051         delete [] Labels[i];
00052     Labels.clear();
00053 
00054     DBTableCount--;
00055 
00056     if(!DBTableCount)
00057         MutexStop(&DBMutexTable);
00058 }

Documentation des fonctions membres

int DataBaseTable::AddEntry (   ) 
 

Ajoute une entrée avec un nouvelle Id.

Renvoie:
Code d'erreur.
Voir également:
DelEntry(), GetEntry() et GetNbEntry().

Définition à la ligne 206 du fichier DataBaseTable.cpp.

00207 {
00208     Entrys.push_back(new DataBaseEntry(++IdMax, NbData));
00209 
00210     if(!Entrys[NbEntry])
00211         return ERROR_C_MEMORY;
00212         
00213     NbEntry++;
00214     
00215     return ERROR_C_NOERROR;
00216 }

int DataBaseTable::AddLabel (  char *  pName  ) 
 

Ajoute le label pName à la table.

Paramètres:
pName nom du label.
Renvoie:
Code d'erreur.
Voir également:
DelLabel().

Définition à la ligne 240 du fichier DataBaseTable.cpp.

Références TRY.

00241 {
00242     int     i, f = 0;
00243     BEGIN
00244     
00245     for(i = 0; (i < NbData) && !f; i++)
00246         if(!strcmp(pName, Labels[i]))
00247             f = 1;
00248 
00249     if(!f)
00250     {
00251         i = strlen(pName);
00252         Labels.push_back(new char[i + 1]);
00253         
00254         if(!Labels[NbData])
00255             CERROR = ERROR_C_MEMORY;
00256         else
00257         {
00258             strncpy(Labels.back(), pName, i);
00259 
00260             for(i = 0; (i < NbEntry) && !CERROR; i++)
00261             {
00262                 TRY CERROR = Entrys[i]->AddData();
00263             }
00264 
00265             NbData++;
00266         }
00267     }
00268 
00269     ENDBEGIN;
00270 }

int DataBaseTable::DelEntry (  int  iId  ) 
 

Supprime l'entrée ayant l'id iId.

Paramètres:
iId Id de l'entrée.
Renvoie:
Code d'erreur.
Voir également:
AddEntry() et GetNbEntry().

Définition à la ligne 218 du fichier DataBaseTable.cpp.

00219 {
00220     int     i;
00221 
00222     if(NbEntry > 0)
00223     {
00224         for(i = 0; i < NbEntry; i++)
00225         {
00226             if(Entrys[i]->GetId() == iId)
00227             {
00228                 Entrys.erase(Entrys.begin() + i);
00229 
00230                 NbEntry--;
00231 
00232                 return ERROR_C_NOERROR;
00233             }
00234         }
00235     }
00236     
00237     return ERROR_C_NOERROR;
00238 }

int DataBaseTable::DelLabel (  char *  pName  ) 
 

Supprime le label pName de la table.

Paramètres:
pName nom du label.
Renvoie:
Code d'erreur.
Voir également:
AddLabel().

Définition à la ligne 273 du fichier DataBaseTable.cpp.

00274 {
00275     int     i, j;
00276 
00277     for(i = 0; i < NbData; i++)
00278     {
00279         if(!strcmp(Labels[i], pName))
00280         {
00281             Labels.erase(Labels.begin() + i);
00282 
00283             for(j = 0; j < NbEntry; Entrys[j++]->DelData(i));
00284 
00285             NbData--;
00286         }
00287     }
00288 
00289     return ERROR_C_NOERROR;
00290 }

DataBaseData* DataBaseTable::GetData (  int  iId,
char *  pName
)  [inline]
 

Permet l'acces à la data de label pName de l'entrée ayant l'id iId.

Paramètres:
iId Id de l'entrée.
pName nom du label.
Renvoie:
pointeur sur la classe DataBaseData de la data.
Voir également:
GetDataNo().

Définition à la ligne 148 du fichier DataBaseTable.h.

00149     {
00150         for(int i = 0; i < NbEntry; i++)
00151         {
00152             if(Entrys[i]->GetId() == iId)
00153             {
00154                 for(int j = 0; j < NbData; j++)
00155                 {
00156                     if(!strcmp(Labels[j], pName))
00157                         return Entrys[i]->GetData(j);
00158                 }
00159             }
00160         }
00161 
00162         return NULL;
00163     };

DataBaseData* DataBaseTable::GetData (  int  iId,
int  iPos
)  [inline]
 

Permet l'acces à la data à la position iPos de l'entrée ayant l'id iId.

Paramètres:
iId Id de l'entrée.
iPos position du label.
Renvoie:
pointeur sur la classe DataBaseData de la data.
Voir également:
GetDataNo().

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

Référencé par SaveEntrys().

00128     {
00129         if(iPos < NbData)
00130         {
00131             for(int i = 0; i < NbEntry; i++)
00132             {
00133                 if(Entrys[i]->GetId() == iId)
00134                     return Entrys[i]->GetData(iPos);
00135             }
00136         }
00137 
00138         return NULL;
00139     };

DataBaseData* DataBaseTable::GetDataNo (  int  iPos,
char *  pName
)  [inline]
 

Permet l'acces à la data de label pName de l'entrée étant à la position iPos.

Paramètres:
iPos position de l'entrée.
pName nom du label.
Renvoie:
pointeur sur la classe DataBaseData de la data.
Voir également:
GetData().

Définition à la ligne 187 du fichier DataBaseTable.h.

00188     {
00189         if(iPos < NbEntry)
00190         {
00191             for(int i = 0; i < NbData; i++)
00192             {
00193                 if(!strcmp(Labels[i], pName))
00194                     return Entrys[iPos]->GetData(i);
00195             }
00196         }
00197 
00198         return NULL;
00199     };

DataBaseData* DataBaseTable::GetDataNo (  int  iPos,
int  iPos2
)  [inline]
 

Permet l'acces à la data à la position iPos de l'entrée étant à la position iPos.

Paramètres:
iPos position de l'entrée.
iPos2 position du label.
Renvoie:
pointeur sur la classe DataBaseData de la data.
Voir également:
GetData().

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

00173     {
00174         if((iPos < NbEntry) && (iPos2 < NbData))
00175             return Entrys[iPos]->GetData(iPos2);
00176 
00177         return NULL;
00178     };

DataBaseEntry* DataBaseTable::GetEntry (  int  iId  )  [inline]
 

Permet l'acces à l'entrée ayant l'id iId.

Paramètres:
iId Id de l'entrée.
Renvoie:
pointeur sur la classe DataBaseEntry de l'entrée.
Voir également:
GetEntryNo().

Définition à la ligne 82 du fichier DataBaseTable.h.

00083     {
00084         for(int i = 0; i < NbEntry; i++)
00085         {
00086             if(Entrys[i]->GetId() == iId)
00087                 return Entrys[i];
00088         }
00089 
00090         return NULL;
00091     };

int DataBaseTable::GetEntryId (  int  iPos  )  [inline]
 

Retourne l'id de l'entrée étant a la position iPos.

Paramètres:
iPos position de l'entrée.
Renvoie:
Id de l'entrée.

Définition à la ligne 112 du fichier DataBaseTable.h.

00113     {
00114         if(iPos < NbEntry)
00115             return Entrys[iPos]->GetId();
00116 
00117         return 0;
00118     };

DataBaseEntry* DataBaseTable::GetEntryNo (  int  iPos  )  [inline]
 

Permet l'acces à l'entrée étant a la position iPos.

Paramètres:
iPos position de l'entrée.
Renvoie:
pointeur sur la classe DataBaseEntry de l'entrée.
Voir également:
GetEntry().

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

00100     {
00101         if(iPos < NbEntry)
00102             return Entrys[iPos];
00103 
00104         return NULL;
00105     };

int DataBaseTable::GetId (   )  [inline]
 

Retourne l'id Id de la table.

Renvoie:
l'id Id de la table.
Voir également:
GetNbEntry().

Définition à la ligne 216 du fichier DataBaseTable.h.

00217     {
00218         return Id;
00219     };

char* DataBaseTable::GetLabel (  int  iPos  )  [inline]
 

Retourne le nom du champ à la position iPos.

Paramètres:
iPos position du champ.
Renvoie:
un pointeur sur le nom du champ.
Voir également:
SetLabel().

Définition à la ligne 273 du fichier DataBaseTable.h.

00274     {
00275         if(iPos < NbData)
00276             return Labels[iPos];
00277 
00278         return NULL;
00279     };

char* DataBaseTable::GetName (   )  [inline]
 

Retourne le nom Name de la table.

Renvoie:
un pointeur sur le nom Name de la table.
Voir également:
SetName().

Définition à la ligne 226 du fichier DataBaseTable.h.

00227     {
00228         return Name;
00229     };

int DataBaseTable::GetNbData (   )  [inline]
 

Retourne le nombre de data NbData d'une entrée de la table.

Renvoie:
le nombre de data d'une entrée de la table.

Définition à la ligne 246 du fichier DataBaseTable.h.

00247     {
00248         return NbData;
00249     };

int DataBaseTable::GetNbEntry (   )  [inline]
 

Retourne le nombre d'entrée contenu dans la table.

Renvoie:
nombre d'entrée dans la table.
Voir également:
AddEntry(), DelEntry(), GetEntryNo() et GetEntry().

Définition à la ligne 206 du fichier DataBaseTable.h.

00207     {
00208         return NbEntry;
00209     };

int DataBaseTable::SaveEntrys (   ) 
 

Sauve le fichier "x.dbt", d'info sur les entrées et la table.

Renvoie:
code d'erreur

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

Références GetData(), MutexLock(), et MutexUnLock().

00144 {
00145     FILE    *Fichier;
00146     char    Buffer[DB_BUFFERSIZE];
00147     int     i, j;
00148     int     Size;
00149     int     EntryId;
00150     BEGIN
00151 
00152     sprintf(Buffer, "%s/%i.dbt", Repertoire, Id);
00153 
00154     MutexLock(&DBMutexTable);
00155 
00156     Fichier = fopen(Buffer, "w");
00157     if(Fichier)
00158     {
00159         TRYIF(fwrite(&NbData, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)
00160 
00161         for(i = 0; (i < NbData) && !CERROR; i++)
00162         {
00163             Size = strlen(Labels[i]);
00164 
00165             TRYIF(fwrite(&Size, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)
00166 
00167             if(Size)
00168             {
00169                 TRYIF(fwrite(Labels[i], sizeof(char), Size, Fichier), ERROR_C_DATA_FILE)
00170             }
00171         }
00172 
00173         TRYIF(fwrite(&NbEntry, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)
00174 
00175         if(NbEntry)
00176         {
00177             for(i = 0; i < NbEntry; i++)
00178             {
00179                 EntryId = Entrys[i]->GetId();
00180 
00181                 TRYIF(fwrite(&EntryId, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)
00182 
00183                 for(j = 0; j < NbData; j++)
00184                 {
00185                     Size = Entrys[i]->GetData(j)->GetSize();
00186 
00187                     TRYIF(fwrite(&Size, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)
00188 
00189                     if(Size)
00190                     {
00191                         TRYIF(fwrite(Entrys[i]->GetData(j)->GetData(), sizeof(char), Size, Fichier), ERROR_C_DATA_FILE)
00192                     }
00193                 }
00194             }
00195         }
00196 
00197         fclose(Fichier);
00198     }
00199     ENDTRY(ERROR_C_DATA_FILE)
00200 
00201     MutexUnLock(&DBMutexTable);
00202 
00203     ENDBEGIN
00204 }

char * DataBaseTable::SetLabel (  int  iPos,
char *  pName
) 
 

Définie le nom du champ à la position iPos.

Paramètres:
iPos position du champ.
pName nom du champ.
Renvoie:
un pointeur sur le nom du champ.
Voir également:
GetLabel().

Définition à la ligne 292 du fichier DataBaseTable.cpp.

00293 {
00294     int     i, f = 0;
00295 
00296     if(iPos < NbData)
00297     {
00298         for(i = 0; (i < NbData) && !f; i++)
00299             if((i != iPos) && !strcmp(pName, Labels[i]))
00300                 f = 1;
00301 
00302         if(!f)
00303         {
00304             delete [] Labels[iPos];
00305             Labels[iPos] = new char[strlen(pName) + 1];
00306             return strcpy(Labels[iPos], pName);
00307         }
00308     }
00309 
00310     return NULL;
00311 }

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

Définie le nom Name de la table.

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

Définition à la ligne 237 du fichier DataBaseTable.h.

Références DB_NAME.

00238     {
00239         return strncpy(Name, pName, DB_NAME);
00240     };

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