DataBaseTable.cpp

Aller à la documentation de ce fichier.

/*! \file DataBaseTable.cpp
    \brief Gestion base de données.

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

    \author     aerith (www.aerith.fr)
    \version    1.0
    \date       26/07/2007
*/

#include    "DataBaseTable.h"


MUTEX   DataBaseTable::DBMutexTable;
int     DataBaseTable::DBTableCount = 0;

DataBaseTable::DataBaseTable(char *pRepertoire, int iId, int iNbData, char *pName)
{
    strncpy(Repertoire, pRepertoire, DB_REPERTOIRE);
    Id      = iId;
    NbData  = iNbData;
    NbEntry = 0;
    IdMax   = 0;

    for(int i = 0; i < NbData; i++)
    {
        Labels.push_back(new char[5]);
        sprintf(Labels[i], "%i", i);
    }

    if(pName)
        strncpy(Name, pName, DB_NAME);

    if(!DBTableCount)
        MutexInit(&DBMutexTable);

    DBTableCount++;

    LoadEntrys();
}

DataBaseTable::~DataBaseTable()
{
    int     i;

    for(i = 0; i < NbEntry; i++)
        delete Entrys[i];
    Entrys.clear();

    for(i = 0; i < NbData; i++)
        delete [] Labels[i];
    Labels.clear();

    DBTableCount--;

    if(!DBTableCount)
        MutexStop(&DBMutexTable);
}

int     DataBaseTable::LoadEntrys()
{
    FILE    *Fichier;
    int     EntryId;
    int     Size;
    char    Name[DB_BUFFERSIZE];
    int     i, j;
    BEGIN
    LOC("DataBaseTable::LoadEntrys");

    sprintf(Name, "%s/%i.dbt", Repertoire, Id);

    MutexLock(&DBMutexTable);

    Fichier = fopen(Name, "r");
    if(Fichier)
    {
        for(i = 0; i < NbData; i++)
            delete [] Labels[i];
        Labels.clear();

        TRYIF(fread(&NbData, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)

        for(i = 0; (i < NbData) && !CERROR; i++)
        {
            TRYIF(fread(&Size, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)

            if(Size)
            {
                TRYIF(fread(Name, sizeof(char), Size, Fichier), ERROR_C_DATA_FILE)
                TRY Name[Size] = '\0';

                TRY Labels.push_back(new char[Size + 1]);
                TRY strcpy(Labels.back(), Name);
            }
        }

        for(i = 0; i < NbEntry; i++)
            delete Entrys[i];
        Entrys.clear();

        TRYIF(fread(&NbEntry, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)

        i = 0;
        while(!feof(Fichier) && !CERROR)
        {
            TRY if(fread(&EntryId, sizeof(int), 1, Fichier))
            {
                Entrys.push_back(new DataBaseEntry(EntryId, NbData));

                for(j = 0; (j < NbData) && !CERROR; j++)
                {
                    TRYIF(fread(&Size, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)

                    if(Size)
                    {
                        char    Data[Size];

                        TRY if(fread(Data, sizeof(char), Size, Fichier))
                            Entrys.back()->GetData(j)->SetData(Data, Size);
                        ENDTRY(ERROR_C_DATA_FILE)
                    }
                }

                i++;
                IdMax = EntryId;
            }
        }

        TRY if(i != NbEntry)
            CERROR = ERROR_C_UNKNOW;

        fclose(Fichier);
    }
    ENDTRY(ERROR_C_DATA_FILE)

    MutexUnLock(&DBMutexTable);

    PERROR

    ENDBEGIN
}

int     DataBaseTable::SaveEntrys()
{
    FILE    *Fichier;
    char    Buffer[DB_BUFFERSIZE];
    int     i, j;
    int     Size;
    int     EntryId;
    BEGIN

    sprintf(Buffer, "%s/%i.dbt", Repertoire, Id);

    MutexLock(&DBMutexTable);

    Fichier = fopen(Buffer, "w");
    if(Fichier)
    {
        TRYIF(fwrite(&NbData, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)

        for(i = 0; (i < NbData) && !CERROR; i++)
        {
            Size = strlen(Labels[i]);

            TRYIF(fwrite(&Size, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)

            if(Size)
            {
                TRYIF(fwrite(Labels[i], sizeof(char), Size, Fichier), ERROR_C_DATA_FILE)
            }
        }

        TRYIF(fwrite(&NbEntry, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)

        if(NbEntry)
        {
            for(i = 0; i < NbEntry; i++)
            {
                EntryId = Entrys[i]->GetId();

                TRYIF(fwrite(&EntryId, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)

                for(j = 0; j < NbData; j++)
                {
                    Size = Entrys[i]->GetData(j)->GetSize();

                    TRYIF(fwrite(&Size, sizeof(int), 1, Fichier), ERROR_C_DATA_FILE)

                    if(Size)
                    {
                        TRYIF(fwrite(Entrys[i]->GetData(j)->GetData(), sizeof(char), Size, Fichier), ERROR_C_DATA_FILE)
                    }
                }
            }
        }

        fclose(Fichier);
    }
    ENDTRY(ERROR_C_DATA_FILE)

    MutexUnLock(&DBMutexTable);

    ENDBEGIN
}

int     DataBaseTable::AddEntry()
{
    Entrys.push_back(new DataBaseEntry(++IdMax, NbData));

    if(!Entrys[NbEntry])
        return ERROR_C_MEMORY;
        
    NbEntry++;
    
    return ERROR_C_NOERROR;
}

int     DataBaseTable::DelEntry(int iId)
{
    int     i;

    if(NbEntry > 0)
    {
        for(i = 0; i < NbEntry; i++)
        {
            if(Entrys[i]->GetId() == iId)
            {
                Entrys.erase(Entrys.begin() + i);

                NbEntry--;

                return ERROR_C_NOERROR;
            }
        }
    }
    
    return ERROR_C_NOERROR;
}

int     DataBaseTable::AddLabel(char *pName)
{
    int     i, f = 0;
    BEGIN
    
    for(i = 0; (i < NbData) && !f; i++)
        if(!strcmp(pName, Labels[i]))
            f = 1;

    if(!f)
    {
        i = strlen(pName);
        Labels.push_back(new char[i + 1]);
        
        if(!Labels[NbData])
            CERROR = ERROR_C_MEMORY;
        else
        {
            strncpy(Labels.back(), pName, i);

            for(i = 0; (i < NbEntry) && !CERROR; i++)
            {
                TRY CERROR = Entrys[i]->AddData();
            }

            NbData++;
        }
    }

    ENDBEGIN;
}


int     DataBaseTable::DelLabel(char *pName)
{
    int     i, j;

    for(i = 0; i < NbData; i++)
    {
        if(!strcmp(Labels[i], pName))
        {
            Labels.erase(Labels.begin() + i);

            for(j = 0; j < NbEntry; Entrys[j++]->DelData(i));

            NbData--;
        }
    }

    return ERROR_C_NOERROR;
}

char    *DataBaseTable::SetLabel(int iPos, char *pName)
{
    int     i, f = 0;

    if(iPos < NbData)
    {
        for(i = 0; (i < NbData) && !f; i++)
            if((i != iPos) && !strcmp(pName, Labels[i]))
                f = 1;

        if(!f)
        {
            delete [] Labels[iPos];
            Labels[iPos] = new char[strlen(pName) + 1];
            return strcpy(Labels[iPos], pName);
        }
    }

    return NULL;
}

---