NetRequest.h

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

    Structures utilisé par les parser de protocol programmable.

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

#ifndef INCLUDE_RSRC_NET_REQUEST
#define INCLUDE_RSRC_NET_REQUEST


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

//! Information sur une requette.
/*! Information sur une requette du protocol reseau.
*/
typedef struct _NetRequest
{
public  :
    char    *Name;              /*!< Nom de la requette.                        */
    int     Pos;                /*!< Position du nom \a Name dans la requette.  */
    ROUTINE Function;           /*!< Nom de la fonction à éxécuté.              */
    char    *Mask;              /*!< Syntax de la requette.\n                   */
    int     Complet;            /*!< Exige que \a Mask soit complement parser   */
    char    *Toks;              /*!< Tokens utiliser pour rechercher \a Name.   */
} NetRequest;

//! Data des paramétres.
/*! Data des paramétres passé à la fonction d'une requette du protocol reseau.
*/
typedef struct _NetRequestData
{
    char    *Label;             /*!< Label du paramtre.                         */
    char    *Data;              /*!< Data.                                      */
    int     Size;               /*!< Taille de la data.                         */
} NetRequestData;

//! Parametre pour une requette.
/*! Parametre passé à la fonction d'une requette du protocol reseau.
*/
class NetRequestParameter
{
private :
    char                            Name[NET_NAME]; /*!< Nom de la requette.                        */
    int                             Pos;            /*!< Position de \a Name dans la requette.      */
    int                             NbParameter;    /*!< Nombre de paramétre.                       */
    std::vector<NetRequestData *>   Parameters;     /*!< Chaque ligne est un paramétre.             */
    NetConnect                      *Connect;       /*!< Classe d'info sur la connection.           */

public  :
    /*! Initialise avec des paramétres par defaut.
    */
    NetRequestParameter(NetConnect *pConnect);

    /*! Libère la mémoire proprement
    */
    ~NetRequestParameter();

    //! Définit le nom de la requette.
    /*! Définit le nom \a Name et la position \a Pos de la requette.
        \param pName nom de la requette.
        \param iPos position du nom
    */
    void    SetName(char *pName, int iPos);

    //! Retourne le nom de la requette.
    /*! Retourne le nom \a Name de la requette.
        \return pointeur sur le nom
    */
    char    *GetName()
    {
        return Name;
    };

    //! Retourne la position du nom de la requette.
    /*! Retourne la position \a Pos du nom de la requette.
        \return positin du nom
    */
    int     GetPos()
    {
        return Pos;
    };

    //! Ajoute un parametre.
    /*! Ajoute un parametre de la requette.
        \param pLabel pointeur sur le label.
        \param pData pointeur sur la data.
        \return Code d'erreur.
        \sa Get(), GetAsInt(), GetAsFloat() et GetAsChar().
    */
    int     Add(char *pLabel, char *pData);

    //! Retourne un parametre.
    /*! Retourne un parametre de la requette.
        \param pLabel nom du parametre.
        \return un pointeur sur le parametre.
        \sa GetAsInt(), GetAsFloat() et GetChar().
    */
    inline char     *Get(char *pLabel)
    {
        for(int i = 0; i < NbParameter; i++)
            if(!strcmp(Parameters[i]->Label, pLabel))
                return Parameters[i]->Data;

        return NULL;
    };

    //! Retourne la taille d'un parametre.
    /*! Retourne la taille d'un parametre de la requette.
        \param pLabel nom du parametre.
        \return la taille du parametre.
        \sa Get().
    */
    inline int      GetSize(char *pLabel)
    {
        for(int i = 0; i < NbParameter; i++)
            if(!strcmp(Parameters[i]->Label, pLabel))
                return Parameters[i]->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.
        \sa Get(), GetAsFloat() et GetAsChar().
    */
    inline int      GetAsInt(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.
        \sa Get(), GetAsInt() et GetAsChar().
    */
    inline float    GetAsFloat(char *pLabel)
    {
        return AtoF(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.
        \sa Get(), GetAsInt() et GetAsFloat().
    */
    inline char     GetAsChar(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 NbParameter;
    };

    //! Retourne un pointeur sur les infos de la connection.
    /*! Retourne ub pointeur sur les info de la connection \a Connect .
        \return Pointeur sur \a Connect .
    */
    inline NetConnect   *GetConnect()
    {
        return Connect;
    };

    //! Retourne l'ip.
    /*! Retourne l'ip de la connection.
        \return Pointeur sur l'ip.
    */
    inline char     *GetIp()
    {
        return Connect->Ip;
    };

    //! Retourne le port.
    /*! Retourne le port de la connection.
        \return port de la connection.
    */
    inline int      GetPort()
    {
        return Connect->Port;
    };

    //! Envoie les données.
    /*! Envoie les données \a Buffer à \a Ip.
        \param pBuffer chaine construite comme pour printf.
        \param ... argument pour construire la chaine
        \return Code d'erreur.
    */
    int     Send(char *pBuffer, ...);
};


#endif

---