httpmessage.hpp

Go to the documentation of this file.

 
#ifndef JOIN_SERVICES_HTTPMESSAGE_HPP
#define JOIN_SERVICES_HTTPMESSAGE_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