Server/include/plaqui/server/response.h

   1 // vim: set noexpandtab tabstop=4 shiftwidth=4:
   2 //----------------------------------------------------------------------------
   3 //                                  PlaQui
   4 //----------------------------------------------------------------------------
   5 // This file is part of PlaQui.
   6 //
   7 // PlaQui is free software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the Free Software
   9 // Foundation; either version 2 of the License, or (at your option) any later
  10 // version.
  11 //
  12 // PlaQui is distributed in the hope that it will be useful, but WITHOUT ANY
  13 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  15 // details.
  16 //
  17 // You should have received a copy of the GNU General Public License along
  18 // with PlaQui; if not, write to the Free Software Foundation, Inc., 59 Temple
  19 // Place, Suite 330, Boston, MA  02111-1307  USA
  20 //----------------------------------------------------------------------------
  21 // Creado:  lun nov 17 20:35:08 ART 2003
  22 // Autores: Leandro Lucarella <llucare@fi.uba.ar>
  23 //----------------------------------------------------------------------------
  24 //
  25 // $Id$
  26 //
  27
  28 #ifndef PLAQUI_RESPONSE_H
  29 #define PLAQUI_RESPONSE_H
  30
  31 #include "plaqui/server/httpresponse.h"
  32 #include <libxml++/libxml++.h>
  33 #include <string>
  34
  35 namespace PlaQui {
  36
  37 namespace Server {
  38
  39         /// Respuesta del servidor.
  40         class Response: private HTTPResponse {
  41
  42                 /////////////////////////////////////////////////////////////////////
  43                 // Tipos.
  44
  45                 public:
  46
  47                         /// Código de respuesta.
  48                         typedef enum {
  49                                 OK,                ///< Comando ejecutado con éxito.
  50                                 UNKNOWN_ERROR,      ///< Error desconocido.
  51                                 INVALID_TARGET,      ///< Destino del comando inválido.
  52                                 INVALID_COMMAND,      ///< Comando inválido para el destino.
  53                                 ARGUMENT_MISSING,      ///< Faltan argumentos para el comando.
  54                                 ALLREADY_EXISTS,        ///< Ya existe la transmisión.
  55                                 CONNECTION_NOT_FOUND,    ///< Conexión no encontrada.
  56                                 TRANSMISSION_NOT_FOUND,   ///< Transmisión no encontrada.
  57                                 PLANT_NOT_FOUND,           ///< Planta no encontrada.
  58                                 ELEMENT_NOT_FOUND,          ///< Elemento no encontrado.
  59                                 ELEMENT_INPUT_NOT_FOUND,     ///< No existe la entrada para el elemento.
  60                                 ERROR_STARTING_TRANSMISSION, ///< No se pudo empezar la transmisión.
  61                                 ERROR_GETING_PLANT_XML,      ///< No se pudo obtener el XML de la planta.
  62                                 ERROR_CHANGING_ELEMENT_INPUT ///< No se pudo cambiar la entrada del elemento.
  63                         } Code;
  64
  65                 private:
  66
  67                         /// Parser XML.
  68                         class Parser: public xmlpp::SaxParser {
  69
  70                                 /////////////////////////////////////////////////////////////
  71                                 // Atributos.
  72
  73                                 private:
  74
  75                                         /// Respuesta en la cual se dejan los datos.
  76                                         Response* response;
  77
  78                                         /// Indica si está en el nivel raíz del XML.
  79                                         bool root;
  80
  81                                 /////////////////////////////////////////////////////////////
  82                                 // Métodos.
  83
  84                                 protected:
  85
  86                                         virtual void on_start_element(const std::string& name,
  87                                                         const AttributeMap& attrs);
  88
  89                                         virtual void on_end_element(const std::string& name);
  90
  91                                         virtual void on_characters(const std::string& chars);
  92
  93                                 public:
  94
  95                                         /// Destructor.
  96                                         virtual ~Parser(void);
  97
  98                                         /**
  99                                          * Constructor.
 100                                          *
 101                                          * \param resp Respuesta en la cual dejar los datos.
 102                                          */
 103                                         Parser(Response& resp);
 104
 105                         };
 106
 107                 /////////////////////////////////////////////////////////////////////
 108                 // Atributos.
 109
 110                 private:
 111
 112                         /// Version de la respuesta (del formato XML usado en la respuesta).
 113                         std::string xml_version;
 114
 115                         /// Código de respuesta.
 116                         Code xml_code;
 117
 118                         /// Descripción de la respuesta.
 119                         std::string xml_description;
 120
 121                         /// Contenido del mensaje XML.
 122                         std::string xml_contents;
 123
 124                 /////////////////////////////////////////////////////////////////////
 125                 // Métodos.
 126
 127                 private:
 128
 129                         /**
 130                          * Construye la respuesta XML dentro del mensaje HTTP.
 131                          */
 132                         void build(void);
 133
 134                 public:
 135
 136                         /**
 137                          * Destructor.
 138                          */
 139                         virtual ~Response(void);
 140
 141                         /**
 142                          * Constructor.
 143                          */
 144                         Response(const Code& code = OK, const std::string& desc = "");
 145
 146                         /**
 147                          * Constructor.
 148                          */
 149                         Response(const std::string& contents, const std::string& desc = "",
 150                                         const Code& code = OK);
 151
 152                         /**
 153                          * Obtiene la versión de la respuesta.
 154                          */
 155                         const std::string& get_version(void) const;
 156
 157                         /**
 158                          * Establece la versión de la respuesta.
 159                          *
 160                          * \param version_ Versión de la respuesta.
 161                          */
 162                         const std::string& set_version(const std::string& version_);
 163
 164                         /**
 165                          * Obtiene el cuerpo del mensaje.
 166                          */
 167                         const Code& get_code(void) const;
 168
 169                         /**
 170                          * Establece el código de respuesta.
 171                          *
 172                          * \param _code Código de respuesta nuevo.
 173                          */
 174                         const Code& set_code(const Code& code_);
 175
 176                         /**
 177                          * Obtiene la descripción de la respuesta.
 178                          */
 179                         const std::string& get_description(void) const;
 180
 181                         /**
 182                          * Establece la descripción de la respuesta.
 183                          *
 184                          * \param description_ Descripción de la respuesta.
 185                          */
 186                         const std::string& set_description(const std::string& description_);
 187
 188                         /**
 189                          * Obtiene el contenido del mensaje.
 190                          */
 191                         const std::string& get_contents(void) const;
 192
 193                         /**
 194                          * Establece el contenido del mensaje.
 195                          *
 196                          * \param contents_ Contenido del mensaje.
 197                          */
 198                         const std::string& set_contents(const std::string& contents_);
 199
 200                         /**
 201                          * Obtiene los datos de la respuesta HTTP desde un texto.
 202                          */
 203                         friend std::istream& operator>>(std::istream& is, Response& resp)
 204                                 throw(HTTPResponse::Error, std::ios::failure, sockerr,
 205                                                 xmlpp::parse_error);
 206
 207                         /**
 208                          * Convierte la respuesta HTTP en texto.
 209                          */
 210                         friend std::ostream& operator<<(std::ostream& os,
 211                                         const Response& resp);
 212
 213         };
 214
 215 }
 216
 217 }
 218
 219 #endif // PLAQUI_RESPONSE_H