URLSession.HTTP.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "URLSession.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Threading/Threading.hpp"
 
#if defined(CURL_FOUND)
#define CE_HAS_HTTP_URL_PROTOCOL 1
#endif
 
#if defined(CE_HAS_HTTP_URL_PROTOCOL)
 
namespace CeresEngine {
 
    struct HTTPRequestMethod {
        String raw;
 
        HTTPRequestMethod() noexcept = default;
 
        HTTPRequestMethod(const StringView raw) noexcept : raw(raw) {}
 
        HTTPRequestMethod(const char* raw) noexcept : raw(raw) {}
 
    public:
        [[nodiscard]] StringView toString() const noexcept { return raw; }
 
        friend std::ostream& operator<<(std::ostream&, HTTPRequestMethod code);
 
    public:
        friend bool operator==(const HTTPRequestMethod& lhs, const HTTPRequestMethod& rhs) { return lhs.raw == rhs.raw; }
 
        friend bool operator!=(const HTTPRequestMethod& lhs, const HTTPRequestMethod& rhs) { return lhs.raw != rhs.raw; }
 
    public:
        static const HTTPRequestMethod Get;
 
        static const HTTPRequestMethod Head;
 
        static const HTTPRequestMethod Post;
 
        static const HTTPRequestMethod Put;
 
        static const HTTPRequestMethod Delete;
 
        static const HTTPRequestMethod Connect;
 
        static const HTTPRequestMethod Options;
 
        static const HTTPRequestMethod Trace;
 
        static const HTTPRequestMethod Patch;
    };
 
    struct HTTPStatusCode {
        UInt16 raw = 0;
 
        constexpr HTTPStatusCode() noexcept = default;
 
        constexpr HTTPStatusCode(const UInt16 raw) noexcept : raw(raw) {}
 
    public:
        [[nodiscard]] constexpr bool isUndefined() const noexcept { return raw == 0; }
 
        [[nodiscard]] constexpr bool isInformational() const noexcept { return raw >= 100 && raw <= 199; }
 
        [[nodiscard]] constexpr bool isSuccess() const noexcept { return raw >= 200 && raw <= 299; }
 
        [[nodiscard]] constexpr bool isRedirection() const noexcept { return raw >= 300 && raw <= 399; }
 
        [[nodiscard]] constexpr bool isClientError() const noexcept { return raw >= 400 && raw <= 499; }
 
        [[nodiscard]] constexpr bool isServerError() const noexcept { return raw >= 500 && raw <= 599; }
 
        [[nodiscard]] StringView toString() const noexcept;
 
        friend std::ostream& operator<<(std::ostream&, HTTPStatusCode code);
 
        explicit constexpr operator bool() const noexcept { return isSuccess(); }
 
    public:
        friend bool operator==(const HTTPStatusCode lhs, const HTTPStatusCode rhs) { return lhs.raw == rhs.raw; }
 
        friend bool operator!=(const HTTPStatusCode lhs, const HTTPStatusCode rhs) { return lhs.raw != rhs.raw; }
 
    public: // Information responses
        static const HTTPStatusCode Continue;
 
        static const HTTPStatusCode SwitchingProtocols;
 
        static const HTTPStatusCode Processing;
 
        static const HTTPStatusCode EarlyHints;
 
    public: // Successful responses
        static const HTTPStatusCode OK;
 
        static const HTTPStatusCode Created;
 
        static const HTTPStatusCode Accepted;
 
        static const HTTPStatusCode NonAuthoritativeInformation;
 
        static const HTTPStatusCode NoContent;
 
        static const HTTPStatusCode ResetContent;
 
        static const HTTPStatusCode PartialContent;
 
    public: // Redirection messages
        static const HTTPStatusCode MultipleChoice;
 
        static const HTTPStatusCode MovedPermanently;
 
        static const HTTPStatusCode Found;
 
        static const HTTPStatusCode SeeOther;
 
        static const HTTPStatusCode NotModified;
 
        static const HTTPStatusCode TemporaryRedirect;
 
        static const HTTPStatusCode PermanentRedirect;
 
    public: // Client error responses
        static const HTTPStatusCode BadRequest;
 
        static const HTTPStatusCode Unauthorized;
 
        static const HTTPStatusCode Forbidden;
 
        static const HTTPStatusCode NotFound;
 
        static const HTTPStatusCode MethodNotAllowed;
 
        static const HTTPStatusCode NotAcceptable;
 
        static const HTTPStatusCode ProxyAuthenticationRequired;
 
        static const HTTPStatusCode RequestTimeout;
 
        static const HTTPStatusCode Conflict;
 
        static const HTTPStatusCode Gone;
 
        static const HTTPStatusCode LengthRequired;
 
        static const HTTPStatusCode PreconditionFailed;
 
        static const HTTPStatusCode PayloadTooLarge;
 
        static const HTTPStatusCode URITooLong;
 
        static const HTTPStatusCode UnsupportedMediaType;
 
        static const HTTPStatusCode RangeNotSatisfiable;
 
        static const HTTPStatusCode ExpectationFailed;
 
        static const HTTPStatusCode MisdirectedRequest;
 
        static const HTTPStatusCode TooEarly;
 
        static const HTTPStatusCode UpgradeRequired;
 
        static const HTTPStatusCode PreconditionRequired;
 
        static const HTTPStatusCode TooManyRequests;
 
        static const HTTPStatusCode RequestHeaderFieldsTooLarge;
 
        static const HTTPStatusCode UnavailableForLegalReasons;
 
    public: // Server error responses
        static const HTTPStatusCode InternalServerError;
 
        static const HTTPStatusCode NotImplemented;
 
        static const HTTPStatusCode BadGateway;
 
        static const HTTPStatusCode ServiceUnavailable;
 
        static const HTTPStatusCode GatewayTimeout;
 
        static const HTTPStatusCode HTTPVersionNotSupported;
 
        static const HTTPStatusCode VariantAlsoNegotiates;
 
        static const HTTPStatusCode NotExtended;
 
        static const HTTPStatusCode NetworkAuthenticationRequired;
    };
 
    class HTTPURLProtocol final : public TURLProtocol<HTTPURLProtocol, "HTTP"> {
    private:
        struct Pimpl;
        const UPtr<Pimpl> m;
 
        class Connection;
 
    public:
        class Request : public IURLRequest {
        public:
            HTTPRequestMethod method = HTTPRequestMethod::Get;
 
            Map<CiString, String> headers;
 
            bool withResponseBody = true;
 
            bool withResponseHeaders = true;
 
        public:
            explicit Request(const IURLRequest& other) : IURLRequest(other) {}
 
            explicit Request(const Request& other, const URL& url)
                    : IURLRequest(other, url), method(other.method), headers(other.headers), withResponseBody(other.withResponseBody),
                      withResponseHeaders(other.withResponseHeaders) {}
 
            explicit Request(const URL& url, const CachePolicy& cachePolicy = CachePolicy::Default) : IURLRequest(url, cachePolicy) {}
        };
 
        class AsyncStream;
 
        class Stream;
 
        class Response : public IURLResponse {
            friend class Connection;
 
            const RC<Connection> mConnection;
 
        public:
            HTTPStatusCode statusCode;
 
            Map<CiString, String> headers;
 
        public:
            explicit Response(const RC<Connection>& connection);
 
        public:
            [[nodiscard]] Optional<StringView> getHeader(StringView name) const;
 
            [[nodiscard]] Optional<StringView> getContentType() const;
 
            [[nodiscard]] bool isJSON() const;
 
        public:
            [[nodiscard]] URLInputStream openInputStream() override;
        };
 
    public:
        HTTPURLProtocol(URLSession& session);
 
        ~HTTPURLProtocol() noexcept override;
 
    public:
        [[nodiscard]] bool isRequestSupported(const URLRequest& request) final;
 
        [[nodiscard]] Async<URLResponse> execute(Task& connection) final;
    };
 
    using HTTPURLRequest = HTTPURLProtocol::Request;
 
    using HTTPURLResponse = HTTPURLProtocol::Response;
 
    class IPFSURLProtocol final : public TURLProtocol<IPFSURLProtocol, "IPFS"> {
    public:
        using Request = HTTPURLProtocol::Request;
 
        using Response = HTTPURLProtocol::Response;
        
        enum class Gateway {
            IPFS_IO,
            
            Cloudflare,
        };
 
    private:
        URL mGatewayURL;
 
    public:
        IPFSURLProtocol(URLSession& session);
        
        IPFSURLProtocol(URLSession& session, const URL& gatewayURL);
 
        IPFSURLProtocol(URLSession& session, Gateway gateway);
 
        ~IPFSURLProtocol() noexcept override;
 
    public:
        [[nodiscard]] bool isRequestSupported(const URLRequest& request) final;
 
        [[nodiscard]] Async<URLResponse> execute(Task& connection) final;
    };
 
    using IPFSURLRequest = IPFSURLProtocol::Request;
 
    using IPFSURLResponse = IPFSURLProtocol::Response;
 
} // namespace CeresEngine
 
#endif