DataBaseTable.h

Aller à la documentation de ce fichier.

/*! \file DataBaseTable.h
    \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       01/11/2007
*/

#ifndef INCLUDE_RSRC_DB_TABLE
#define INCLUDE_RSRC_DB_TABLE

#include    "../Tools/Tools.h"
#include    "../Surcouche/SurcoucheMultitache.h"
#include    "DataBaseEntry.h"
#include    <stdio.h>
#include    <stdlib.h>

#define     DB_BUFFERSIZE   10240   /*!< Taille buffer de travaille.                            */
#define     DB_REPERTOIRE   256     /*!< Taille max du nom du repertoire de la base.            */
#define     DB_NAME         32      /*!< Taille max du nom de la table.                         */

//! Gestion d'une table.
/*! Gestion d'une table dans la base de données \a DataBase.
*/
class DataBaseTable
{
private :
    char                            Repertoire[DB_REPERTOIRE];  /*!< Repertoire où ce trouve la base.           */
    int                             Id;             /*!< Id de la table.                                        */
    char                            Name[DB_NAME];  /*!< Nom de la table.                                       */
    int                             NbData;         /*!< Nombre de data dans une entrée.                        */
    std::vector<char *>             Labels;         /*!< Chaque ligne est un label.                             */
    int                             NbEntry;        /*!< Nombre d'entrée dans la table.                         */
    std::vector<DataBaseEntry *>    Entrys;         /*!< Chaque ligne est une entrée.                           */
    int                             IdMax;          /*!< Id maximum des entrée de la table.                     */
    int                             AllocSize;      /*!< Nombre d'entrée allouée.                               */
    static int                      DBTableCount;   /*!< Compte les instance de la class.                       */
    static MUTEX                    DBMutexTable;   /*!< Utiliser des que l'on accede à un fichier "DB.sys".    */

    //! Charge le fichier des entrées.
    /*! Charge le fichier "x.dbt", d'info sur les entrées et la table.
        \return code d'erreur
    */
    int     LoadEntrys();

public  :
    /*! Charge la table en mémoire avec des paramétres par defauts.
        \param pRepertoire repertoire de la base.
        \param iId Id de la table.
        \param iNbData nombre de champs.
        \param pName nom de la table.
    */
    DataBaseTable(char *pRepertoire, int iId, int iNbData = 0, char *pName = NULL);

    /*! Sauve la table dans un fichier.
    */
    ~DataBaseTable();

    //! Ajoute une entrée.
    /*! Ajoute une entrée avec un nouvelle Id.
        \return Code d'erreur.
        \sa DelEntry(), GetEntry() et GetNbEntry().
    */
    int     AddEntry();

    //! Supprime une entrée.
    /*! Supprime l'entrée ayant l'id \a iId.
        \param iId Id de l'entrée.
        \return Code d'erreur.
        \sa AddEntry() et GetNbEntry().
    */
    int     DelEntry(int iId);

    //! Retourne une entrée.
    /*! Permet l'acces à l'entrée ayant l'id \a iId.
        \param iId Id de l'entrée.
        \return pointeur sur la classe \a DataBaseEntry de l'entrée.
        \sa GetEntryNo().
    */
    inline DataBaseEntry    *GetEntry(int iId)
    {
        for(int i = 0; i < NbEntry; i++)
        {
            if(Entrys[i]->GetId() == iId)
                return Entrys[i];
        }

        return NULL;
    };

    //! Retourne une entrée.
    /*! Permet l'acces à l'entrée étant a la position \a iPos.
        \param iPos position de l'entrée.
        \return pointeur sur la classe \a DataBaseEntry de l'entrée.
        \sa GetEntry().
    */
    inline DataBaseEntry    *GetEntryNo(int iPos)
    {
        if(iPos < NbEntry)
            return Entrys[iPos];

        return NULL;
    };

    //! Retourne l'id d'une entrée.
    /*! Retourne l'id de l'entrée étant a la position \a iPos.
        \param iPos position de l'entrée.
        \return Id de l'entrée.
    */
    inline int      GetEntryId(int iPos)
    {
        if(iPos < NbEntry)
            return Entrys[iPos]->GetId();

        return 0;
    };

    //! Retourne une data d'une entrée.
    /*! Permet l'acces à la data à la position \a iPos de l'entrée ayant l'id \a iId.
        \param iId Id de l'entrée.
        \param iPos position du label.
        \return pointeur sur la classe \a DataBaseData de la data.
        \sa GetDataNo().
    */
    inline DataBaseData     *GetData(int iId, int iPos)
    {
        if(iPos < NbData)
        {
            for(int i = 0; i < NbEntry; i++)
            {
                if(Entrys[i]->GetId() == iId)
                    return Entrys[i]->GetData(iPos);
            }
        }

        return NULL;
    };

    //! Retourne une data d'une entrée.
    /*! Permet l'acces à la data de label \a pName de l'entrée ayant l'id \a iId.
        \param iId Id de l'entrée.
        \param pName nom du label.
        \return pointeur sur la classe \a DataBaseData de la data.
        \sa GetDataNo().
    */
    inline DataBaseData     *GetData(int iId, char *pName)
    {
        for(int i = 0; i < NbEntry; i++)
        {
            if(Entrys[i]->GetId() == iId)
            {
                for(int j = 0; j < NbData; j++)
                {
                    if(!strcmp(Labels[j], pName))
                        return Entrys[i]->GetData(j);
                }
            }
        }

        return NULL;
    };

    //! Retourne une data d'une entrée.
    /*! Permet l'acces à la data à la position \a iPos de l'entrée étant à la position \a iPos.
        \param iPos position de l'entrée.
        \param iPos2 position du label.
        \return pointeur sur la classe \a DataBaseData de la data.
        \sa GetData().
    */
    inline DataBaseData     *GetDataNo(int iPos, int iPos2)
    {
        if((iPos < NbEntry) && (iPos2 < NbData))
            return Entrys[iPos]->GetData(iPos2);

        return NULL;
    };

    //! Retourne une data d'une entrée.
    /*! Permet l'acces à la data de label \a pName de l'entrée étant à la position \a iPos.
        \param iPos position de l'entrée.
        \param pName nom du label.
        \return pointeur sur la classe \a DataBaseData de la data.
        \sa GetData().
    */
    inline DataBaseData     *GetDataNo(int iPos, char *pName)
    {
        if(iPos < NbEntry)
        {
            for(int i = 0; i < NbData; i++)
            {
                if(!strcmp(Labels[i], pName))
                    return Entrys[iPos]->GetData(i);
            }
        }

        return NULL;
    };

    //! Retourne le nombre d'entrée.
    /*! Retourne le nombre d'entrée contenu dans la table.
        \return nombre d'entrée dans la table.
        \sa AddEntry(), DelEntry(), GetEntryNo() et GetEntry().
    */
    inline int      GetNbEntry()
    {
        return NbEntry;
    };

    //! Retourne l'id de la table.
    /*! Retourne l'id \a Id de la table.
        \return l'id \a Id de la table.
        \sa GetNbEntry().
    */
    inline int      GetId()
    {
        return Id;
    };

    //! Retourne le nom de la table.
    /*! Retourne le nom \a Name de la table.
        \return un pointeur sur le nom \a Name de la table.
        \sa SetName().
    */
    inline char     *GetName()
    {
        return Name;
    };

    //! Définie le nom de la table.
    /*! Définie le nom \a Name de la table.
        \param pName nom de la table.
        \return un pointeur sur le nom \a Name de la table.
        \sa GetName().
    */
    inline char     *SetName(char *pName)
    {
        return strncpy(Name, pName, DB_NAME);
    };

    //! Retourne le nombre de data d'une entrée.
    /*! Retourne le nombre de data \a NbData d'une entrée de la table.
        \return le nombre de data d'une entrée de la table.
    */
    inline int      GetNbData()
    {
        return NbData;
    };

    //! Ajoute un label.
    /*! Ajoute le label \a pName à la table.
        \param pName nom du label.
        \return Code d'erreur.
        \sa DelLabel().
    */
    int     AddLabel(char *pName);

    //! Supprimse un label.
    /*! Supprime le label \a pName de la table.
        \param pName nom du label.
        \return Code d'erreur.
        \sa AddLabel().
    */
    int     DelLabel(char *pName);

    //! Retourne le nom d'un champ.
    /*! Retourne le nom du champ à la position \a iPos.
        \param iPos position du champ.
        \return un pointeur sur le nom du champ.
        \sa SetLabel().
    */
    inline char     *GetLabel(int iPos)
    {
        if(iPos < NbData)
            return Labels[iPos];

        return NULL;
    };

    //! Définie le nom d'un champ.
    /*! Définie le nom du champ à la position \a iPos.
        \param iPos position du champ.
        \param pName nom du champ.
        \return un pointeur sur le nom du champ.
        \sa GetLabel().
    */
    char    *SetLabel(int iPos, char *pName);

    //! Sauve le fichier des entrées.
    /*! Sauve le fichier "x.dbt", d'info sur les entrées et la table.
        \return code d'erreur
    */
    int     SaveEntrys();
};

#endif

---