Message.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_http_Message_hpp
#define anna_http_Message_hpp

#include <anna/core/util/Recycler.hpp>

#include <anna/comm/Message.hpp>

#include <anna/http/Header.hpp>
#include <anna/http/Version.hpp>

namespace anna {

namespace http {

namespace parser {
class Abstract;
}

class Message : public comm::Message {
public:
  typedef Recycler <Header>::iterator header_iterator;
  typedef Recycler <Header>::const_iterator const_header_iterator;

  using comm::Message::setBody;

  struct Type {
    enum _v {
      Request, 
      Response 
    };
  };

  Type::_v getType() const { return a_type; }

  const std::string& getVersion() const { return a_version; }

  /*
   * Devuelve el enumerado que identifica la versión HTTP usada en el mensaje.
   * \return el enumerado que identifica la versión HTTP usada en el mensaje.
   */
  Version::_v getVersionAsEnum() const { return Version::asEnum(a_version); }

  const std::string& getExtraParameters() const { return a_extraParameters;  }

  void setVersion(const std::string& version) { a_version = version; }

  void setVersion(const Version::_v version) { a_version = Version::asCString(version); }

  comm::Message* setBody(const xml::Node* node) noexcept(false);

  Header* createHeader(const Header::Type::_v type)
  noexcept(false) {
    return a_headers.create()->initialize(type);
  }

  Header* createHeader(const std::string& name)
  noexcept(false) {
    return a_headers.create()->initialize(name);
  }

  const Header* find(const Header::Type::_v type) const {
    return const_cast <Message*>(this)->find(type);
  }

  Header* find(const Header::Type::_v type) ;

  Header* find(const char* name) ;

  void clear() { a_headers.clear(); clearBody(); a_extraParameters.clear();}

  header_iterator header_begin() { return a_headers.begin(); }

  header_iterator header_end() { return a_headers.end(); }

  const_header_iterator header_begin() const { return a_headers.begin(); }

  const_header_iterator header_end() const { return a_headers.end(); }

  const DataBlock& code() noexcept(false);

  virtual std::string asString() const  = 0;

  static Header* header(header_iterator& ii) { return Recycler<Header>::data(ii); }

  static const Header* header(const_header_iterator& ii) { return Recycler<Header>::data(ii); }

protected:
  Message(const Type::_v type) : comm::Message(StatusCodeBuffer::Reserve),
    a_type(type), a_version("HTTP/1.1")
  {;}

private:
  const Type::_v a_type;
  std::string a_version;
  Recycler <Header> a_headers;
  std::string a_extraParameters;

  void codeLine(const std::string& line) noexcept(false);

  void appendExtraParameter(const std::string& extraParameter) {
    a_extraParameters += ' ';
    a_extraParameters += extraParameter;
  }

  virtual std::string codeStartLine() const noexcept(false) = 0;

  friend class parser::Abstract;
};


}
}

#endif