/// Código de respuesta.
typedef enum {
- OK = 0,
+ OK,
UNKNOWN_ERROR,
INVALID_TARGET,
INVALID_COMMAND,
protected:
- //virtual void on_start_document(void);
-
- //virtual void on_end_document(void);
-
virtual void on_start_element(const std::string& name,
const AttributeMap& attrs);
virtual void on_characters(const std::string& chars);
- //virtual void on_comment(const std::string& text);
-
- //virtual void on_warning(const std::string& error);
-
- //virtual void on_error(const std::string& error);
-
- //virtual void on_fatal_error(const std::string& error);
-
- //virtual void on_validity_error(const std::string& error);
-
- //virtual void on_validity_warning(const std::string& error);
-
public:
/// Destructor.
/////////////////////////////////////////////////////////////////////
// Atributos.
- // FIXME private: hacer get/set y build tipo command.
-
- public:
+ private:
/// Version de la respuesta (del formato XML usado en la respuesta).
std::string xml_version;
/// Descripción de la respuesta.
std::string xml_description;
- /// Cuerpo del mensaje XML.
- std::string xml_body;
+ /// Contenido del mensaje XML.
+ std::string xml_contents;
/////////////////////////////////////////////////////////////////////
// Métodos.
+ private:
+
+ /**
+ * Construye la respuesta XML dentro del mensaje HTTP.
+ */
+ void build(void);
+
public:
/**
/**
* Constructor.
*/
- Response(const std::string& body, const std::string& desc = "",
+ Response(const std::string& contents, const std::string& desc = "",
const Code& code = OK);
/**
- * Obtiene el cuerpo del mensaje.
+ * Obtiene la versión de la respuesta.
*/
- //std::string body(void) const;
+ const std::string& get_version(void) const;
/**
- * Establece el cuerpo del mensaje.
+ * Establece la versión de la respuesta.
*
- * \param body_ Cuerpo del mensaje.
+ * \param version_ Versión de la respuesta.
*/
- //const std::string& body(const std::string& body_);
+ const std::string& set_version(const std::string& version_);
/**
* Obtiene el cuerpo del mensaje.
*/
- //Code code(void) const;
+ const Code& get_code(void) const;
/**
* Establece el código de respuesta.
*
* \param _code Código de respuesta nuevo.
*/
- //const Code& code(const Code& code_);
+ const Code& set_code(const Code& code_);
+
+ /**
+ * Obtiene la descripción de la respuesta.
+ */
+ const std::string& get_description(void) const;
+
+ /**
+ * Establece la descripción de la respuesta.
+ *
+ * \param description_ Descripción de la respuesta.
+ */
+ const std::string& set_description(const std::string& description_);
+
+ /**
+ * Obtiene el contenido del mensaje.
+ */
+ const std::string& get_contents(void) const;
+
+ /**
+ * Establece el contenido del mensaje.
+ *
+ * \param contents_ Contenido del mensaje.
+ */
+ const std::string& set_contents(const std::string& contents_);
/**
* Obtiene los datos de la respuesta HTTP desde un texto.
error_received(e);
continue;
}
- switch (response.xml_code) {
+ switch (response.get_code()) {
case Response::OK:
- ok_received(response.xml_body);
+ ok_received(response.get_contents());
break;
default:
- error_received(response.xml_code);
+ error_received(response.get_code());
break;
}
}
// Agrego fin de string porque el readsome no lo hace.
buf2[size] = '\0';
m.set_body(buf2);
-#ifdef DEBUG
- } else {
- // TODO dar error?
- cerr << __FILE__ << "(" << __LINE__ << ")"
- << ": operator>>() ERROR!!! Caracteres extraidos: "
- << n << endl;
-#endif // DEBUG
- }
+ } // TODO else dar error?
delete []buf2;
}
// Después de una línea vacía, haya obtenido el body o no, sale del
<< endl;
#endif // DEBUG
headers["Content-Type"] = "text/xml; charset=iso-8859-1";
- status_code = HTTPMessage::OK;
+ build();
}
-Response::Response(const string& body, const string& desc, const Code& code):
+Response::Response(const string& contents, const string& desc, const Code& code):
xml_version("1.0"), xml_code(code), xml_description(desc),
- xml_body(body) {
+ xml_contents(contents) {
#ifdef DEBUG
cerr << __FILE__ << "(" << __LINE__ << ")"
- << ": constructor(body.length = " << body.length()
+ << ": constructor(body.length = " << contents.length()
<< ", desc = " << desc << ", code = " << code << ");" << endl;
#endif // DEBUG
headers["Content-Type"] = "text/xml; charset=iso-8859-1";
- status_code = HTTPMessage::OK;
+ build();
+}
+
+void Response::build(void) {
+ String b;
+ b.from(xml_code);
+ b = string("<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>\n"
+ "<plaqui-response code=\"") + b + "\" version=\""
+ + xml_version + "\" ";
+ if (xml_description.length()) {
+ b += "description=\"" + xml_description + "\" ";
+ }
+ if (xml_contents.length()) {
+ b += ">\n" + xml_contents + "\n</plaqui-response>\n";
+ } else {
+ b += "/>\n";
+ }
+ set_body(b);
+ switch (xml_code) {
+ case OK:
+ status_code = HTTPMessage::OK;
+ break;
+ case INVALID_TARGET:
+ case INVALID_COMMAND:
+ case CONNECTION_NOT_FOUND:
+ case TRANSMISSION_NOT_FOUND:
+ case PLANT_NOT_FOUND:
+ case ELEMENT_NOT_FOUND:
+ case ELEMENT_INPUT_NOT_FOUND:
+ status_code = HTTPMessage::INTERNAL_SERVER_ERROR;
+ break;
+ case ALLREADY_EXISTS:
+ case ARGUMENT_MISSING:
+ status_code = HTTPMessage::CONFLICT;
+ break;
+ case UNKNOWN_ERROR:
+ case ERROR_STARTING_TRANSMISSION:
+ case ERROR_GETING_PLANT_XML:
+ case ERROR_CHANGING_ELEMENT_INPUT:
+ status_code = HTTPMessage::INTERNAL_SERVER_ERROR;
+ break;
+ default:
+ status_code = HTTPMessage::INTERNAL_SERVER_ERROR;
+ break;
+ }
+}
+
+const string& Response::get_version(void) const {
+ return xml_version;
+}
+
+const string& Response::set_version(const string& version_) {
+ xml_version = version_;
+ build();
+ return version_;
+}
+
+const Response::Code& Response::get_code(void) const {
+ return xml_code;
+}
+
+const Response::Code& Response::set_code(const Response::Code& code_) {
+ xml_code = code_;
+ build();
+ return code_;
+}
+
+const string& Response::get_description(void) const {
+ return xml_description;
+}
+
+const string& Response::set_description(const string& description_) {
+ xml_description = description_;
+ build();
+ return description_;
+}
+
+const string& Response::get_contents(void) const {
+ return xml_contents;
+}
+
+const string& Response::set_contents(const string& contents_) {
+ xml_contents = contents_;
+ build();
+ return contents_;
}
istream& operator>>(istream& is, Response& resp)
if (resp.get_body().length()) {
Response::Parser(resp).parse_memory(resp.get_body());
}
+ resp.build();
return is;
}
#ifdef DEBUG
cerr << __FILE__ << "(" << __LINE__ << ")" << ": operator<<()" << endl;
#endif // DEBUG
- String b;
- b.from(resp.xml_code);
- b = string("<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>\n"
- "<plaqui-response code=\"") + b + "\" version=\""
- + resp.xml_version + "\" ";
- if (resp.xml_description.length()) {
- b += "description=\"" + resp.xml_description + "\" ";
- }
- if (resp.xml_body.length()) {
- b += ">\n" + resp.xml_body + "\n</plaqui-response>\n";
- } else {
- b += "/>\n";
- }
- HTTPResponse r(resp);
- r.set_body(b);
- os << static_cast<const HTTPResponse&>(r);
+ os << static_cast<const HTTPResponse&>(resp);
return os;
}
}
// Si no es el elemento raíz, lo agrego al body.
} else {
- response->xml_body += "<";
- response->xml_body += name + " ";
+ response->xml_contents += "<";
+ response->xml_contents += name + " ";
for (AttributeMap::const_iterator i = attrs.begin();
i != attrs.end(); i++) {
- response->xml_body += i->first + " = \"" + i->second + "\" ";
+ response->xml_contents += i->first + " = \"" + i->second + "\" ";
}
- response->xml_body += ">";
+ response->xml_contents += ">";
}
}
root = true;
// Si no, agrega al cuerpo.
} else {
- response->xml_body += "</";
- response->xml_body += name + ">";
+ response->xml_contents += "</";
+ response->xml_contents += name + ">";
}
}
#endif // DEBUG
// Sólo nos importa el contenido, lo agregamos.
if (!root) {
- response->xml_body += chars;
+ response->xml_contents += chars;
}
}
projects / z.facultad / 75.42 / plaqui.git / commitdiff