URLSession.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2023 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Async.hpp"
#include "CeresEngine/Foundation/Exception.hpp"
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/JSONForward.hpp"
#include "CeresEngine/Foundation/Poly.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/StructEnum.hpp"
#include "CeresEngine/Foundation/URI.hpp"
#include "CeresEngine/Foundation/UUID.hpp"
#include "CeresEngine/Foundation/Container/List.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
#include "CeresEngine/Foundation/IO/Stream.hpp"
#include "CeresEngine/Foundation/Threading/ExecutionContext.hpp"
#include "CeresEngine/Foundation/Threading/Threading.hpp"
 
namespace CeresEngine {
 
    CE_EXCEPTION_DECL2(URLException, IOException);
    CE_EXCEPTION_DECL2(URLNotSupportedException, URLException);
    CE_EXCEPTION_DECL2(URLNotFoundException, URLException);
    CE_EXCEPTION_DECL2(URLInternalErrorException, URLException);
 
    class URLRequest;
    class URLResponse;
    class URLSession;
 
    using URL = URI;
 
    using URLInputStream = InputStream;
    
    using URLOutputStream = OutputStream;
    
    using URLDataStream = DataStream;
 
    enum class URLRequestMode {
        Read = (1u << 0u),
        
        Write = (1u << 1u),
        
        Create = (1u << 2u),
        
        Truncate = (1u << 3u),
        
        ReadWrite = Read | Write,
        
        Default = 0,
    };
    
    using URLRequestModeFlags = Flags<URLRequestMode>;
    CE_FLAGS_OPERATORS(URLRequestMode)
    
    
    class IURLRequest {
    public:
        struct CachePolicy : StructEnum<CachePolicy> {
            enum : UnderlyingType {
                None = 0,
 
                Default = None,
            } raw;
 
            CE_STRUCT_ENUM_DECL(CachePolicy);
        };
        
        using Mode = URLRequestMode;
 
    public:
        const URL url;
 
        URLRequestModeFlags mode = URLRequestMode::Read;
 
        CachePolicy cachePolicy = CachePolicy::Default;
 
    public:
        explicit IURLRequest(const URL& url, const CachePolicy cachePolicy = CachePolicy::Default) : url(url), cachePolicy(cachePolicy) {}
 
        explicit IURLRequest(const IURLRequest& request, const URL& url) : url(url), mode(request.mode), cachePolicy(request.cachePolicy) {}
 
        virtual ~IURLRequest() noexcept = default;
    };
 
    class URLRequest : public Poly<IURLRequest, sizeof(IURLRequest)> {
    public:
        using CachePolicy = IURLRequest::CachePolicy;
        using Mode = IURLRequest::Mode;
        using Poly::Poly;
 
        CE_EXPLICIT(false) URLRequest(URL url) : Poly(std::move(url)) {}
 
        CE_EXPLICIT(false) URLRequest(const StringView url) : URLRequest(URL(url)) {}
 
        explicit URLRequest(const URLRequest& request, const URL& url) : Poly(url) {
            get()->mode = request->mode;
            get()->cachePolicy = request->cachePolicy;
        }
    };
 
    class IURLResponse {
    public:
        const URLRequest request;
 
        UInt64 expectedContentLength = ~0ul;
 
        String suggestedFileName = "";
 
        String mimeType = "";
 
        String textEncodingName = "";
 
        UUID contentID;
 
    public:
        explicit IURLResponse(URLRequest request) : request(std::move(request)) {}
 
        virtual ~IURLResponse() noexcept = default;
 
    public:
        [[nodiscard]] virtual URLInputStream openInputStream() = 0;
        
        [[nodiscard]] virtual URLOutputStream openOutputStream() { return nullptr; }
        
        [[nodiscard]] virtual URLDataStream openDataStream() { return nullptr; }
 
        [[nodiscard]] JSON asJSON();
    };
 
    class URLResponse : public Poly<IURLResponse, sizeof(IURLResponse)> {
    public:
        using Poly::Poly;
 
    public:
        friend std::ostream& operator<<(std::ostream& stream, const URLResponse& response);
    };
 
    class URLProtocol {
    protected:
        URLSession& mSession;
 
    protected:
        friend class URLSession;
 
        class Task final {
        public:
            URLSession& session;
 
            URLProtocol& protocol;
 
            const URLRequest request;
 
            // TODO: Implement progress tracking.
 
        public:
            explicit Task(URLSession& session, URLProtocol& protocol, URLRequest&& request)
                    : session(session), protocol(protocol), request(std::move(request)) {}
 
            ~Task() noexcept = default;
 
        public:
            using URLGetter = StringView (URL::*)() const;
 
            [[nodiscard]] URL parseURL(const StringView url) const noexcept;
 
            [[nodiscard]] URL parseURL(const URLGetter& getter) const noexcept { return parseURL((request->url.*getter)()); }
 
            [[nodiscard]] Async<URLResponse> subRequest(URLRequest baseRequest);
 
            [[nodiscard]] Async<URLResponse> subRequest(URL url) { return subRequest(URLRequest(request, std::move(url))); }
 
            [[nodiscard]] Async<URLResponse> subRequest(const URLGetter& getter) {
                URL baseURL = parseURL(getter);
                if(baseURL.empty()) {
                    throw URLNotFoundException("No source URL for protocol.");
                }
                return subRequest(std::move(baseURL));
            }
 
        public: // Request casting
            template<typename T> const T& as() const { return request.as<T>(); }
        };
 
    public:
        explicit URLProtocol(URLSession& session) noexcept : mSession(session) {}
 
        virtual ~URLProtocol() noexcept = default;
 
    public:
        [[nodiscard]] virtual bool isRequestSupported(const URLRequest& request) = 0;
 
        [[nodiscard]] virtual URLRequest prepareRequest(URLRequest&& request) { return std::move(request); }
 
        [[nodiscard]] virtual Async<URLResponse> execute(Task& connection) = 0;
 
        [[nodiscard]] virtual StringView getName() const noexcept = 0;
    };
 
    template<typename T, StringLiteral N> class TURLProtocol : public URLProtocol {
    public:
        using URLProtocol::URLProtocol;
 
    public:
        [[nodiscard]] URLRequest prepareRequest(URLRequest&& request) override {
            if(request.is<typename T::Request>()) {
                return std::move(request);
            }
            return typename T::Request(*request);
        }
 
        [[nodiscard]] StringView getName() const noexcept final { return N.value; }
    };
 
    using URLProtocolPtr = UPtr<URLProtocol>;
 
    class URLSession {
    private:
        ExecutionContext& mExecutionContext;
 
        LockedObject<Vector<URLProtocolPtr>> mProtocols;
 
        LockedObject<List<UPtr<URLProtocol::Task>>> mConnections;
 
    public:
        explicit URLSession(ExecutionContext& executionContext);
 
        ~URLSession() noexcept;
 
    public:
        Async<URLResponse> execute(URLRequest request);
 
    public:
        template<typename T, typename... Args> T& registerProtocol(Args&&... args) {
            URLProtocolPtr protocolPtr = ce_unique_new<T>(*this, std::forward<Args>(args)...);
            URLProtocol& protocol = *protocolPtr;
            registerProtocol(std::move(protocolPtr));
            return static_cast<T&>(protocol);
        }
 
        template<typename T> void unregisterProtocol() {}
 
    public:
        ExecutionContext& getExecutionContext() { return mExecutionContext; }
 
    private:
        void registerProtocol(URLProtocolPtr&& protocol);
    };
 
    class URLCache {
        // TODO: Implement this.
    };
 
} // namespace CeresEngine