ResourceStream.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 "Forward.hpp"
 
#include "ResourceHandle.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/IO/Stream.hpp"
#include "CeresEngine/Foundation/Threading/AsyncMutex.hpp"
 
namespace CeresEngine {
 
    struct ResourceStreamID : public UUID {
        using UUID::UUID;
 
        explicit ResourceStreamID(const UUID& uuid) : UUID(uuid) {}
 
        static const ResourceStreamID null;
    };
 
    const inline ResourceStreamID ResourceStreamID::null = ResourceStreamID();
 
    enum class ResourceStreamFlag {
        Seekable = (1u << 0u),
 
        Compressible = (1u << 1u),
 
        Default = 0,
    };
 
    using ResourceStreamFlags = Flags<ResourceStreamFlag>;
    CE_FLAGS_OPERATORS(ResourceStreamFlag)
 
    enum class ResourceStreamReadFlag {
        Buffered,
 
    };
 
    using ResourceStreamReadFlags = Flags<ResourceStreamReadFlag>;
    CE_FLAGS_OPERATORS(ResourceStreamReadFlag)
 
    enum class ResourceStreamWriteFlag {
        Buffered,
 
        Truncate,
    };
 
    using ResourceStreamWriteFlags = Flags<ResourceStreamWriteFlag>;
    CE_FLAGS_OPERATORS(ResourceStreamWriteFlag)
 
    // ---------------------------------------------------------------------------------------------
 
    
    struct ResourceStreamDescriptor {
        bool isSeekable : 1 = false;
 
        bool allowCompression : 1 = true;
 
        UInt64 sizeHint = 0;
    };
 
    using ResourceStreamLockMutex = TAsyncSharedMutex<AnyExecutor>;
 
    class ResourceStreamLock {
    private:
        using ScopedLock = ResourceStreamLockMutex::Lock;
 
        ScopedLock mScopedLock;
 
        ResourceStreamDataPtr mData;
 
    public:
        ResourceStreamLock(ResourceStreamData& data, ScopedLock&& lock) : mScopedLock(std::move(lock)), mData(&data) {}
 
    public:
        [[nodiscard]] bool isExclusive() const noexcept { return mScopedLock.isExclusive(); }
 
        [[nodiscard]] ResourceStreamData& getStreamData() const noexcept {
            CE_ASSERT(mData != nullptr);
            return *mData;
        }
    };
 
    class ResourceStreamData : public RefCounted<ResourceStreamData> {
    public:
        ResourceData& resourceData;
 
        const ResourceStreamID streamID;
 
        const ResourceStreamFlags flags;
 
    private:
        ResourceStreamLockMutex mMutex;
 
    public:
        explicit ResourceStreamData(ResourceData& resourceData, const ResourceStreamID& streamID, const ResourceStreamFlags& flags);
 
        virtual ~ResourceStreamData() noexcept = default;
 
    public:
        [[nodiscard]] virtual Async<ResourceInputStream> openInputStream() = 0;
 
        [[nodiscard]] virtual Async<ResourceOutputStream> openOutputStream() = 0;
 
    public:
        [[nodiscard]] bool isSeekable() const noexcept { return flags.isSet(ResourceStreamFlag::Seekable); }
 
        [[nodiscard]] bool isCompressible() const noexcept { return flags.isSet(ResourceStreamFlag::Compressible); }
 
    protected:
        [[nodiscard]] auto acquireReadLock() {
            using super = ResourceStreamLockMutex::LockOperation;
            struct Awaitable : public super {
                ResourceStreamData& streamData;
 
                explicit Awaitable(super&& other, ResourceStreamData& streamData) : super(std::move(other)), streamData(streamData) {
                }
 
                [[nodiscard]] ResourceStreamLock await_resume() noexcept { return ResourceStreamLock{streamData, super::await_resume()}; }
            };
            return Awaitable{mMutex.lock_shared(), *this};
        }
 
        [[nodiscard]] auto acquireWriteLock() {
            using super = ResourceStreamLockMutex::LockOperation;
            struct Awaitable : public super {
                ResourceStreamData& streamData;
 
                explicit Awaitable(super&& other, ResourceStreamData& streamData) : super(std::move(other)), streamData(streamData) {
                }
 
                [[nodiscard]] ResourceStreamLock await_resume() noexcept { return ResourceStreamLock{streamData, super::await_resume()}; }
            };
            return Awaitable{mMutex.lock(), *this};
        }
    };
 
    using ResourceStreamDataPtr = RC<ResourceStreamData>;
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    class ResourceStream : public virtual IStream {
    private:
        ResourceStreamLock mStreamLock;
 
    public:
        explicit ResourceStream(ResourceStreamLock&& lock) : mStreamLock(std::move(lock)) {}
 
    public:
        [[nodiscard]] HResource getResource() const;
 
        [[nodiscard]] ResourceManager* getResourceManager() const;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class IResourceInputStream : public virtual ResourceStream, public virtual IInputStream {
        using super = ResourceStream;
 
    public:
        using super::super;
    };
 
    class ResourceInputStream : public Poly<IResourceInputStream, sizeof(void*), false> {
        using super = Poly<IResourceInputStream, sizeof(void*), false>;
 
    public:
        using super::super;
        ResourceInputStream(ResourceStreamLock&& lock, InputStream&& stream);
 
        explicit operator InputStream() { return InputStream(dynamic_cast<IInputStream*>(get())); }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class IResourceOutputStream : public virtual ResourceStream, public virtual IOutputStream {
        using super = ResourceStream;
 
    private:
        OutputStream mStream;
 
    public:
        using super::super;
    };
 
    class ResourceOutputStream : public Poly<IResourceOutputStream, sizeof(void*), false> {
        using super = Poly<IResourceOutputStream, sizeof(void*), false>;
 
    public:
        using super::super;
        ResourceOutputStream(ResourceStreamLock&& lock, OutputStream&& stream);
 
        explicit operator OutputStream() { return OutputStream(dynamic_cast<IOutputStream*>(get())); }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class WrappedResourceInputStream final : public IResourceInputStream {
    private:
        InputStream mStream;
 
    public:
        explicit WrappedResourceInputStream(ResourceStreamLock&& lock, InputStream&& stream) : ResourceStream(std::move(lock)), IResourceInputStream(std::move(lock)), mStream(std::move(stream)) {}
 
    public:
        InputStream& getInputStream() noexcept { return mStream; }
 
        const InputStream& getInputStream() const noexcept { return mStream; }
 
    public: // IDataStream interface
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept override {
            CE_ASSERT(mStream != nullptr);
            return mStream->isSeekable(mode);
        }
 
        void seek(const std::streamsize position, const Seek mode = Seek::Start) override {
            CE_ASSERT(mStream != nullptr);
            mStream->seek(position, mode);
        }
 
        [[nodiscard]] bool isTellable() const noexcept override {
            CE_ASSERT(mStream != nullptr);
            return mStream->isTellable();
        }
 
        [[nodiscard]] size_t tell() override {
            CE_ASSERT(mStream != nullptr);
            return mStream->tell();
        }
 
        [[nodiscard]] bool isSizeKnown() const noexcept override {
            CE_ASSERT(mStream != nullptr);
            return mStream->isSizeKnown();
        }
 
        [[nodiscard]] size_t size() override {
            CE_ASSERT(mStream != nullptr);
            return mStream->size();
        }
 
    public:
        [[nodiscard]] bool isReadable() const noexcept override {
            CE_ASSERT(mStream != nullptr);
            return mStream->isReadable();
        }
 
        [[nodiscard]] size_t read(void* data, const size_t n) override {
            CE_ASSERT(mStream != nullptr);
            return mStream->read(data, n);
        }
 
        [[nodiscard]] bool invalidate() override {
            CE_ASSERT(mStream != nullptr);
            return mStream->invalidate();
        }
    };
 
    class WrappedResourceOutputStream : public IResourceOutputStream {
    private:
        OutputStream mStream;
 
    public:
        explicit WrappedResourceOutputStream(ResourceStreamLock&& lock, OutputStream&& stream) : ResourceStream(std::move(lock)), IResourceOutputStream(std::move(lock)), mStream(std::move(stream)) {}
 
    public:
        OutputStream& getDataStream() noexcept { return mStream; }
 
        const OutputStream& getDataStream() const noexcept { return mStream; }
 
    public: // IDataStream interface
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept override {
            CE_ASSERT(mStream != nullptr);
            return mStream->isSeekable(mode);
        }
 
        void seek(const std::streamsize position, const Seek mode = Seek::Start) override {
            CE_ASSERT(mStream != nullptr);
            mStream->seek(position, mode);
        }
 
        [[nodiscard]] bool isTellable() const noexcept override {
            CE_ASSERT(mStream != nullptr);
            return mStream->isTellable();
        }
 
        [[nodiscard]] size_t tell() override {
            CE_ASSERT(mStream != nullptr);
            return mStream->tell();
        }
 
        [[nodiscard]] bool isSizeKnown() const noexcept override {
            CE_ASSERT(mStream != nullptr);
            return mStream->isSizeKnown();
        }
 
        [[nodiscard]] size_t size() override {
            CE_ASSERT(mStream != nullptr);
            return mStream->size();
        }
 
    public:
        [[nodiscard]] bool isWritable() const noexcept override {
            CE_ASSERT(mStream != nullptr);
            return mStream->isWritable();
        }
 
        [[nodiscard]] size_t write(const void* data, const size_t n) override {
            CE_ASSERT(mStream != nullptr);
            return mStream->write(data, n);
        }
 
        [[nodiscard]] bool flush() override {
            CE_ASSERT(mStream != nullptr);
            return mStream->flush();
        }
    };
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    class HResourceStream {
        friend class Resource;
        friend class ResourceManager;
 
    private:
        ResourceStreamDataPtr mData = nullptr;
 
    public:
        HResourceStream() = default;
 
        HResourceStream(const HResourceStream&) = delete;
        HResourceStream& operator=(const HResourceStream&) = delete;
 
        HResourceStream(HResourceStream&&) noexcept = default;
        HResourceStream& operator=(HResourceStream&&) noexcept = default;
 
    private:
        explicit HResourceStream(const ResourceStreamDataPtr& streamData);
        explicit HResourceStream(ResourceStreamData& streamData) : HResourceStream(&streamData) {}
 
    public:
        [[nodiscard]] Async<ResourceInputStream> openInputStream() const;
 
        [[nodiscard]] Async<ResourceOutputStream> openOutputStream();
 
    public:
        explicit operator bool() const noexcept { return mData != nullptr; }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class InMemoryResourceStreamData : public ResourceStreamData {
    private:
        MemoryDataStream mStream;
 
    public:
        explicit InMemoryResourceStreamData(ResourceData& resourceData, const ResourceStreamID& streamID, const ResourceStreamFlags& flags) : ResourceStreamData(resourceData, streamID, flags) {}
        ~InMemoryResourceStreamData() noexcept override = default;
 
    public:
        [[nodiscard]] Async<ResourceInputStream> openInputStream() override;
 
        [[nodiscard]] Async<ResourceOutputStream> openOutputStream() override;
    };
 
} // namespace CeresEngine
 
template<> struct std::hash<CeresEngine::ResourceStreamID> : std::hash<CeresEngine::UUID> {};