ParserRule.h

Aller à la documentation de ce fichier.

/*! \file ParserRule.h
    \brief Structures pour parser.

    Structures de données utilisées par le parser.

    \author     aerith (http://aerith.fr)
    \version    1.0
    \date       20/04/2008
*/

#ifndef INCLUDE_RSRC_PARSER_RULE
#define INCLUDE_RSRC_PARSER_RULE

#include    "../Tools/Tools.h"
#include    <vector>
#include    <string>

using namespace std;


//! Data des paramétres.
/*! Data des paramétres passé à la routine d'une règle.
*/
class ParserRuleData
{
public  :
    string          label;      /*!< Nom du paramètre.                          */
    string          data;       /*!< valeur du paramètre.                       */

    /*! Initialise avec des paramétres par defaut.
        \param pLabel nom du paramètre
        \param pData valeur du paramètre
    */
    ParserRuleData(const char *pLabel, const char *pData)
    {
        label =  pLabel;
        data = pData;
    };
};

//! Parametre pour une règle.
/*! Parametre passé à la routine d'une règle.
*/
template<class T>
class ParserRuleParameter
{
private :
    std::vector<ParserRuleData *>   parameters;     /*!< Chaque ligne est un paramétre.             */
    T                               *obj;           /*!< Classe ou structure à passer aux routines. */
    char                            none[1];        /*!< Valeur d'un get non trouvé.                */

public  :
    /*! Initialise avec des paramétres par defaut.
    */
    inline  ParserRuleParameter(T *pObj)
    {
        obj = pObj;
        *none   = '\0';
    };

    /*! Libère la mémoire proprement
    */
    inline  ~ParserRuleParameter()
    {
        unsigned int    i;

        for(i = 0; i < parameters.size(); i++)
            delete parameters[i];
        parameters.clear();
    };

    //! Ajoute un parametre.
    /*! Ajoute un parametre à la règle.
        \param pLabel pointeur sur le label.
        \param pData pointeur sur la data.
    */
    inline void     Add(const char *pLabel, const char *pData)
    {
        parameters.push_back(new ParserRuleData(pLabel, pData));
    };

    //! Retourne un parametre.
    /*! Retourne un parametre de la règle.
        \param pLabel nom du parametre.
        \return un pointeur sur le parametre.
    */
    inline const char   *Get(const char *pLabel)
    {
        unsigned int    i;

        for(i = 0; i < parameters.size(); i++)
            if(parameters[i]->label.compare(pLabel) == 0)
                return parameters[i]->data.data();

        return none;
    };

    //! Retourne la taille d'un parametre.
    /*! Retourne la taille d'un parametre de la règle.
        \param pLabel nom du parametre.
        \return la taille du parametre.
    */
    inline unsigned int     GetSize(const char *pLabel)
    {
        unsigned int    i;

        for(i = 0; i < parameters.size(); i++)
            if(parameters[i]->label.compare(pLabel) == 0)
                return parameters[i]->data.size();

        return 0;
    };

    //! Retourne une data \a int.
    /*! Retourne une data de type \a int.
        \param pLabel nom du parametre.
        \return le parametre sous forme d'entier.
    */
    inline int      GetAsInt(const char *pLabel)
    {
        return atoi(Get(pLabel));
    };

    //! Retourne une data \a float.
    /*! Retourne une data de type \a float.
        \param pLabel nom du parametre.
        \return le parametre sous forme de réel.
    */
    inline float    GetAsFloat(const char *pLabel)
    {
        return atol(Get(pLabel));
    };

    //! Retourne une data \a char.
    /*! Retourne une data de type \a char.
        \param pLabel nom du parametre.
        \return le parametre sous forme de carractère.
    */
    inline char     GetAsChar(const char *pLabel)
    {
        return *Get(pLabel);
    };

    //! Retourne le nombre de datas.
    /*! Retourne le nombre de datas du paramétre.
        \return nombre de requette du parser.
    */
    inline int      GetNbParameter()
    {
        return parameters.size();
    };

    //! Retourne un pointeur sur l'objet passé aux routine.
    /*! Retourne un pointeur sur l'objet passé aux routine.
        \return Pointeur sur \a obj .
    */
    inline T        *GetObj()
    {
        return obj;
    };
};


#endif

---