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 = 0,
  50                                 UNKNOWN_ERROR,
  51                                 INVALID_TARGET,
  52                                 INVALID_COMMAND,
  53                                 ARGUMENT_MISSING,
  54                                 ALLREADY_EXISTS,
  55                                 CONNECTION_NOT_FOUND,
  56                                 TRANSMISSION_NOT_FOUND,
  57                                 PLANT_NOT_FOUND,
  58                                 ELEMENT_NOT_FOUND,
  59                                 ELEMENT_INPUT_NOT_FOUND,
  60                                 ERROR_STARTING_TRANSMISSION,
  61                                 ERROR_GETING_PLANT_XML,
  62                                 ERROR_CHANGING_ELEMENT_INPUT
  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_document(void);
  87
  88                                         //virtual void on_end_document(void);
  89
  90                                         virtual void on_start_element(const std::string& name,
  91                                                         const AttributeMap& attrs);
  92
  93                                         virtual void on_end_element(const std::string& name);
  94
  95                                         virtual void on_characters(const std::string& chars);
  96
  97                                         //virtual void on_comment(const std::string& text);
  98
  99                                         //virtual void on_warning(const std::string& error);
 100
 101                                         //virtual void on_error(const std::string& error);
 102
 103                                         //virtual void on_fatal_error(const std::string& error);
 104
 105                                         //virtual void on_validity_error(const std::string& error);
 106
 107                                         //virtual void on_validity_warning(const std::string& error);
 108
 109                                 public:
 110
 111                                         /// Destructor.
 112                                         virtual ~Parser(void);
 113
 114                                         /**
 115                                          * Constructor.
 116                                          *
 117                                          * \param resp Respuesta en la cual dejar los datos.
 118                                          */
 119                                         Parser(Response& resp);
 120
 121                         };
 122
 123                 /////////////////////////////////////////////////////////////////////
 124                 // Atributos.
 125
 126                 // FIXME private: hacer get/set y build tipo command.
 127
 128                 public:
 129
 130                         /// Version de la respuesta (del formato XML usado en la respuesta).
 131                         std::string xml_version;
 132
 133                         /// Código de respuesta.
 134                         Code xml_code;
 135
 136                         /// Descripción de la respuesta.
 137                         std::string xml_description;
 138
 139                         /// Cuerpo del mensaje XML.
 140                         std::string xml_body;
 141
 142                 /////////////////////////////////////////////////////////////////////
 143                 // Métodos.
 144
 145                 public:
 146
 147                         /**
 148                          * Destructor.
 149                          */
 150                         virtual ~Response(void);
 151
 152                         /**
 153                          * Constructor.
 154                          */
 155                         Response(const Code& code = OK, const std::string& desc = "");
 156
 157                         /**
 158                          * Constructor.
 159                          */
 160                         Response(const std::string& body, const std::string& desc = "",
 161                                         const Code& code = OK);
 162
 163                         /**
 164                          * Obtiene el cuerpo del mensaje.
 165                          */
 166                         //std::string body(void) const;
 167
 168                         /**
 169                          * Establece el cuerpo del mensaje.
 170                          *
 171                          * \param body_ Cuerpo del mensaje.
 172                          */
 173                         //const std::string& body(const std::string& body_);
 174
 175                         /**
 176                          * Obtiene el cuerpo del mensaje.
 177                          */
 178                         //Code code(void) const;
 179
 180                         /**
 181                          * Establece el código de respuesta.
 182                          *
 183                          * \param _code Código de respuesta nuevo.
 184                          */
 185                         //const Code& code(const Code& code_);
 186
 187                         /**
 188                          * Obtiene los datos de la respuesta HTTP desde un texto.
 189                          */
 190                         friend std::istream& operator>>(std::istream& is, Response& resp)
 191                                 /*throw(HTTPResponse::Error, std::ios::failure, sockerr)*/;
 192
 193                         /**
 194                          * Convierte la respuesta HTTP en texto.
 195                          */
 196                         friend std::ostream& operator<<(std::ostream& os,
 197                                         const Response& resp);
 198
 199         };
 200
 201 }
 202
 203 }
 204
 205 #endif // PLAQUI_RESPONSE_H