http_protocol.hpp

Go to the documentation of this file.

 
#ifndef JOIN_SERVICES_HTTP_PROTOCOL_HPP
#define JOIN_SERVICES_HTTP_PROTOCOL_HPP
 
// libjoin.
#include <join/tls_protocol.hpp>
 
namespace join
{
    template <class Protocol>
    class BasicHttpClient;
 
    template <class Protocol>
    class BasicHttpSecureClient;
 
    template <class Protocol>
    class BasicHttpWorker;
 
    template <class Protocol>
    class BasicHttpServer;
 
    template <class Protocol>
    class BasicHttpSecureServer;
 
    class Http
    {
    public:
        using Endpoint = BasicInternetEndpoint<Http>;
        using Socket = BasicStreamSocket<Http>;
        using Stream = BasicSocketStream<Http>;
        using Acceptor = BasicStreamAcceptor<Http>;
        using Client = BasicHttpClient<Http>;
        using Worker = BasicHttpWorker<Http>;
        using Server = BasicHttpServer<Http>;
 
        constexpr explicit Http (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Http& v4 () noexcept
        {
            static Http httpv4 (AF_INET);
            return httpv4;
        }
 
        static inline Http& v6 () noexcept
        {
            static Http httpv6 (AF_INET6);
            return httpv6;
        }
 
        constexpr int family () const noexcept
        {
            return _family;
        }
 
        static constexpr uint16_t defaultPort = 80;
 
        constexpr int type () const noexcept
        {
            return SOCK_STREAM;
        }
 
        constexpr int protocol () const noexcept
        {
            return IPPROTO_TCP;
        }
 
    private:
        int _family;
    };
 
    constexpr bool operator== (const Http& a, const Http& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    class Https
    {
    public:
        using Transport = Tcp;
        using Endpoint = typename Transport::Endpoint;
        using Socket = BasicTlsWrapper<Https>;
        using Stream = BasicTlsStream<Https>;
        using Acceptor = typename Transport::Acceptor;
        using Client = BasicHttpSecureClient<Https>;
        using Worker = BasicHttpWorker<Https>;
        using Server = BasicHttpSecureServer<Https>;
 
        constexpr explicit Https (int family = AF_INET) noexcept
        : _transport (family)
        {
        }
 
        static inline Https& v4 () noexcept
        {
            static Https httpsv4 (AF_INET);
            return httpsv4;
        }
 
        static inline Https& v6 () noexcept
        {
            static Https httpsv6 (AF_INET6);
            return httpsv6;
        }
 
        constexpr int family () const noexcept
        {
            return _transport.family ();
        }
 
        static constexpr uint16_t defaultPort = 443;
 
    private:
        Transport _transport;
    };
 
    constexpr bool operator== (const Https& a, const Https& b) noexcept
    {
        return a.family () == b.family ();
    }
}
 
#endif