httpmessage.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_HTTP_MESSAGE_HPP__
#define __JOIN_HTTP_MESSAGE_HPP__
 
// libjoin.
#include <join/error.hpp>
#include <join/utils.hpp>
 
// C++.
#include <system_error>
#include <iostream>
#include <sstream>
#include <string>
#include <map>
 
namespace join
{
    enum class HttpErrc
    {
        BadRequest = 1,     
        Unauthorized,       
        Forbidden,          
        NotFound,           
        Unsupported,        
        LengthRequired,     
        PayloadTooLarge,    
        UriTooLong,         
        HeaderTooLarge,     
        ServerError,        
        NotImplemented,     
        BadGateway,         
    };
 
    class HttpCategory : public std::error_category
    {
    public:
        virtual const char* name () const noexcept;
 
        virtual std::string message (int code) const;
 
        virtual bool equivalent (const std::error_code& code, int condition) const noexcept;
    };
 
    const std::error_category& httpCategory ();
 
    std::error_code make_error_code (HttpErrc code);
 
    std::error_condition make_error_condition (HttpErrc code);
 
    enum HttpMethod
    {
        Head    = 1L << 0,  
        Get     = 1L << 1,  
        Put     = 1L << 2,  
        Post    = 1L << 3,  
        Delete  = 1L << 4,  
    };
 
    __inline__ HttpMethod operator& (HttpMethod __a, HttpMethod __b)
    { return HttpMethod (static_cast <int> (__a) & static_cast <int> (__b)); }
 
    __inline__ HttpMethod operator| (HttpMethod __a, HttpMethod __b)
    { return HttpMethod (static_cast <int> (__a) | static_cast <int> (__b)); }
 
    __inline__ HttpMethod operator^ (HttpMethod __a, HttpMethod __b)
    { return HttpMethod (static_cast <int> (__a) ^ static_cast <int> (__b)); }
 
    __inline__ HttpMethod operator~ (HttpMethod __a)
    { return HttpMethod (~static_cast <int> (__a)); }
 
    __inline__ const HttpMethod& operator&= (HttpMethod& __a, HttpMethod __b)
    { return __a = __a & __b; }
 
    __inline__ const HttpMethod& operator|= (HttpMethod& __a, HttpMethod __b)
    { return __a = __a | __b; }
 
    __inline__ const HttpMethod& operator^= (HttpMethod& __a, HttpMethod __b)
    { return __a = __a ^ __b; }
 
    class HttpMessage
    {
    public:
        // headers map.
        using HeaderMap = std::map <std::string, std::string, details::lessNoCase>;
 
        HttpMessage ();
 
        HttpMessage (const HttpMessage& other);
 
        HttpMessage& operator= (const HttpMessage& other);
 
        HttpMessage (HttpMessage&& other);
 
        HttpMessage& operator= (HttpMessage&& other);
 
        virtual ~HttpMessage () = default;
 
        const std::string& version () const;
 
        void version (const std::string& v);
 
        bool hasHeader (const std::string& name) const;
 
        std::string header (const std::string& name) const;
 
        void header (const std::string& name, const std::string& val);
 
        void header (const HeaderMap::value_type& h);
 
        const HeaderMap& headers () const;
 
        void headers (const HeaderMap& heads);
 
        std::string dumpHeaders () const;
 
        size_t contentLength () const;
 
        virtual void clear ();
 
        virtual int readHeaders (std::istream& in);
 
        virtual int writeHeaders (std::ostream& out) const = 0;
 
    protected:
        virtual int parseFirstLine (const std::string& line) = 0;
 
        virtual int parseHeader (const std::string& head);
 
        static const std::streamsize _maxHeaderLen = 2048;
 
        std::string _version;
 
        HeaderMap _headers;
    };
 
    class HttpRequest : public HttpMessage
    {
    public:
        // parameters map.
        using ParameterMap = std::map <std::string, std::string>;
 
        HttpRequest ();
 
        HttpRequest (HttpMethod method);
 
        HttpRequest (const HttpRequest& other);
 
        HttpRequest& operator= (const HttpRequest& other);
 
        HttpRequest (HttpRequest&& other);
 
        HttpRequest& operator= (HttpRequest&& other);
 
        virtual ~HttpRequest () = default;
 
        HttpMethod method () const;
 
        std::string methodString () const;
 
        void method (HttpMethod meth);
 
        const std::string& path () const;
 
        void path (const std::string& p);
 
        bool hasParameter (const std::string& name) const;
 
        std::string parameter (const std::string& name) const;
 
        void parameter (const std::string& name, const std::string& val);
 
        void parameter (const ParameterMap::value_type& param);
 
        const ParameterMap& parameters () const;
 
        void parameters (const ParameterMap& params);
 
        std::string dumpParameters () const;
 
        std::string query () const;
 
        std::string urn () const;
 
        std::string host () const;
 
        std::string auth () const;
 
        std::string credentials () const;
 
        virtual void clear () override;
 
        virtual int writeHeaders (std::ostream& out) const override;
 
    protected:
        virtual int parseFirstLine (const std::string& line) override;
 
        std::string& decodeUrl (std::string &url);
 
        std::string& normalize (std::string& path);
 
        void store (const std::string &query);
 
        HttpMethod _method = Get;
 
        std::string _path;
 
        ParameterMap _parameters;
    };
 
    class HttpResponse : public HttpMessage
    {
    public:
        HttpResponse () = default;
 
        HttpResponse (const HttpResponse& other);
 
        HttpResponse& operator= (const HttpResponse& other);
 
        HttpResponse (HttpResponse&& other);
 
        HttpResponse& operator= (HttpResponse&& other);
 
        virtual ~HttpResponse () = default;
 
        const std::string& status () const;
 
        const std::string& reason () const;
 
        void response (const std::string& status, const std::string& reason = {});
 
        virtual void clear () override;
 
        virtual int writeHeaders (std::ostream& out) const override;
 
    protected:
        virtual int parseFirstLine (const std::string& line) override;
 
        std::string _status;
 
        std::string _reason;
    };
}
 
namespace std
{
    template <> struct is_error_condition_enum <join::HttpErrc> : public true_type {};
}
 
#endif