Header.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_Header_hpp
#define anna_http_Header_hpp

#include <anna/core/RuntimeException.hpp>
#include <anna/core/Allocator.hpp>

namespace anna {

namespace http {

class Token;
class Message;

class Header {
public:
  struct Type {
    enum _v {
      None,
      /* Generales */
      CacheControl, Connection, Date, Pragma, Trailer, TransferEncoding, Upgrade, Via,
      Warning,
      /* Request  */
      Accept, AcceptCharset, AcceptEncoding, AcceptLanguage, Authorization, Expect, From,
      Host, IfMatch, IfModifiedSince, IfNoneMatch, IfRange, IfUnmodifiedSince, MaxForwards,
      ProxyAuthorization, Range, Referer, TE, UserAgent,
      /* Entity Header */
      Allow, ContentEncoding, ContentLanguage, ContentLength, ContentLocation, ContentMD5,
      ContentRange, ContentType, Expires, LastModified,
      /* Response Header */
      AcceptRanges, Age, ETAG, Location, ProxyAuthenticate, RetryAfter, Server, Vary,
      WWWAuthenticate,
      /* Uso interno */
      Unknown, End, Begin = 1
    };
  };

  struct Category { enum _v { General, Response, Request, Entity, Extension }; };

  struct Compare { enum _v { Exact = 0, RightTrim = 1, LeftTrim = 2, NoCase = 4, FullMode = 7 }; };

  ~Header() { delete a_extensionName; }

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

  Category::_v getCategory() const { return a_category; }

  const std::string* getExtensionName() const { return a_extensionName; }

  const std::string& getStringValue() const { return a_value; }

  const int getIntegerValue() const ;

  void setValue(const Token* token) ;

  void setValue(const std::string& value) { a_value = value; }

  void setValue(const int value) ;

  Header& operator = (const Header& other) ;

  int compare(const char* str, const int flags = Compare::LeftTrim | Compare::NoCase) const ;

  bool match(const char* str, const int flags = Compare::LeftTrim | Compare::NoCase) const {
    return compare(str, flags) == 0;
  }

  std::string asString() const ;

  static Type::_v asType(const Token* token) ;

  static const char* asLiteral(const Type::_v type) ;

private:
  Type::_v a_type;
  Category::_v a_category;
  std::string* a_extensionName;
  std::string a_value;
  static const char* st_names [Type::End];

  Header() : a_extensionName(NULL), a_category(Category::Extension) {;}
  Header* initialize(const Type::_v type) noexcept(false);
  Header* initialize(const std::string& name) noexcept(false);
  std::string code() const ;

  friend class Message;
  friend class Allocator<Header>;
};


}
}

#endif