Stream.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 "FilePath.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Async.hpp"
#include "CeresEngine/Foundation/Forward.hpp"
#include "CeresEngine/Foundation/Poly.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/MemoryView.hpp"
#include "CeresEngine/Foundation/Container/Optional.hpp"
#include "CeresEngine/Foundation/Container/Pair.hpp"
 
#include "CeresEngine/Math/Range.hpp"
 
#include <bit>
#include <cstddef>
#include <type_traits>
 
namespace CeresEngine {
 
    class DataStream;
    class AsyncDataStream;
 
    CE_EXCEPTION_DECL2(StreamException, IOException);
    CE_EXCEPTION_DECL2(StreamReadException, StreamException);
    CE_EXCEPTION_DECL2(StreamWriteException, StreamException);
 
#if CE_COMPILER_MSVC
    inline constexpr std::size_t kStreamPolySize = sizeof(void*) * 16;
#else
    inline constexpr std::size_t kStreamPolySize = sizeof(void*) * 8;
#endif
 
    class IStream {
    public:
        IStream() = default;
 
        IStream(const IStream&) noexcept = delete;
        IStream& operator=(const IStream&) noexcept = delete;
 
        IStream(IStream&&) noexcept = default;
        IStream& operator=(IStream&&) noexcept = default;
 
        virtual ~IStream() noexcept = default;
 
    public: // Seeking & Telling
        enum class Seek {
            Start = SEEK_SET,
            Current = SEEK_CUR,
            End = SEEK_END,
        };
 
        [[nodiscard]] virtual bool isSeekable(Seek mode = Seek::Start) const noexcept { return false; }
 
        virtual void seek(std::streamsize position, Seek mode = Seek::Start);
 
        void skip(const size_t n) {
            CE_ASSERT(isSeekable(Seek::Current));
            seek(std::streamsize(n), Seek::Current);
        }
 
        [[nodiscard]] virtual bool isTellable() const noexcept { return false; }
 
        [[nodiscard]] virtual size_t tell();
 
        [[nodiscard]] virtual bool isSizeKnown() const noexcept;
 
        [[nodiscard]] virtual size_t size();
    };
 
    class Stream final : public Poly<IStream, kStreamPolySize, false, IStream> {
    public:
        using Seek = IStream::Seek;
 
    public:
        using Poly::Poly;
    };
 
    class IInputStream : public virtual IStream {
    public: // Reading
        [[nodiscard]] virtual bool isReadable() const noexcept { return false; }
 
        [[nodiscard]] virtual size_t read(void* data, size_t n);
 
        template<typename T> [[nodiscard]] size_t read(const MemoryView<T>& memoryView) {
            const ByteMemoryView byteMemoryView = memoryView.template as<Byte>();
            return read(byteMemoryView.data(), byteMemoryView.size());
        }
 
        template<typename T> [[nodiscard]] size_t read(const StridedMemoryView<T>& memoryView) {
            size_t totalBytesRead = 0;
            for(const size_t index : indices<std::size_t>(memoryView)) {
                const size_t bytesRead = read(&memoryView[index], sizeof(T));
                totalBytesRead += bytesRead;
 
                if(bytesRead != sizeof(T)) {
                    break;
                }
            }
            return totalBytesRead;
        }
 
        [[nodiscard]] Optional<String> readString() {
            CE_ASSERT(isReadable());
 
            String string;
            size_t length;
            String::value_type buffer[1024];
 
            while((length = read(buffer, sizeof(buffer))) != 0) {
                string += StringView(buffer, length);
            }
 
            return string;
        }
 
        template<typename T>
        requires std::is_trivially_copyable_v<T>
        [[nodiscard]] Optional<T> read() {
            T value;
 
            const size_t bytes = read(&value, sizeof(T));
            if(bytes != sizeof(T)) {
                return nullopt;
            }
            return byteswap<std::endian::little>(value);
        }
 
        [[nodiscard]] virtual bool invalidate();
    };
 
    class InputStream final : public Poly<IInputStream, kStreamPolySize, false, IStream> {
    public:
        using Seek = IStream::Seek;
 
    public:
        using Poly::Poly;
 
        InputStream(InputStream&&) noexcept = default;
        InputStream& operator=(InputStream&&) noexcept = default;
 
        explicit InputStream(const FilePath& path);
 
        explicit InputStream(const ByteMemoryView& buffer, bool freeOnClose = false);
    };
 
    class IOutputStream : public virtual IStream {
    public: // Writing
        [[nodiscard]] virtual bool isWritable() const noexcept { return false; }
 
        [[nodiscard]] virtual size_t write(const void* data, size_t n);
 
        template<typename T> [[nodiscard]] size_t write(const MemoryView<const T>& memoryView) {
            const MemoryView<const Byte> byteMemoryView = memoryView.template as<const Byte>();
            return write(byteMemoryView.data(), byteMemoryView.size());
        }
 
        template<typename T> [[nodiscard]] size_t write(const StridedMemoryView<const T>& memoryView) {
            size_t totalBytesWritten = 0;
            for(const size_t index : indices<std::size_t>(memoryView)) {
                const size_t bytesWritten = write(&memoryView[index], sizeof(T));
                totalBytesWritten += bytesWritten;
 
                if(bytesWritten != sizeof(T)) {
                    break;
                }
            }
            return totalBytesWritten;
        }
 
        [[nodiscard]] size_t writeString(const StringView string) { return write(string.data(), string.length()); }
 
        template<typename T>
        requires std::is_trivially_copyable_v<T>
        [[nodiscard]] bool write(T value) {
#if 0
            value = byteswap<std::endian::little>(value);
#endif
            return write(&value, sizeof(T)) == sizeof(T);
        }
 
        [[nodiscard]] virtual bool flush();
    };
 
    class OutputStream final : public Poly<IOutputStream, kStreamPolySize, false, IStream> {
    public:
        using Seek = IStream::Seek;
 
    public:
        using Poly::Poly;
 
        explicit OutputStream(const FilePath& path);
 
        explicit OutputStream(const ByteMemoryView& buffer, bool freeOnClose = false);
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class IAsyncStream {
    public:
        virtual ~IAsyncStream() = default;
 
    public: // Seeking & Telling
        using Seek = IStream::Seek;
 
        [[nodiscard]] virtual bool isSeekable(Seek mode = Seek::Start) const noexcept { return false; }
 
        virtual Async<> seek(std::streamsize position, Seek mode = Seek::Start);
 
        Async<> skip(const size_t n) {
            CE_ASSERT(isSeekable(Seek::Current));
            return seek(std::streamsize(n), Seek::Current);
        }
 
        [[nodiscard]] virtual bool isTellable() const noexcept { return false; }
 
        [[nodiscard]] virtual Async<size_t> tell();
 
        [[nodiscard]] virtual bool isSizeKnown() const noexcept;
 
        [[nodiscard]] virtual Async<size_t> size();
 
    public:
        [[nodiscard]] virtual Async<> wait() = 0;
    };
 
    class AsyncStream final : public Poly<IAsyncStream, kStreamPolySize, false> {
    public:
        using Poly::Poly;
    };
 
    class IAsyncInputStream : public virtual IAsyncStream {
    public: // Reading
        [[nodiscard]] virtual bool isReadable() const noexcept { return false; }
 
        [[nodiscard]] virtual Async<size_t> read(void* data, size_t n);
 
        [[nodiscard]] virtual Async<size_t> readExactly(void* data, size_t n);
    };
 
    class AsyncInputStream final : public Poly<IAsyncInputStream, kStreamPolySize, false> {
    public:
        using Poly::Poly;
    };
 
    class IAsyncOutputStream : public virtual IAsyncStream {
    public: // Writing
        [[nodiscard]] virtual bool isWritable() const noexcept { return false; }
 
        [[nodiscard]] virtual Async<size_t> write(const void* data, size_t n);
 
        [[nodiscard]] virtual Async<size_t> writeExactly(void* data, size_t n);
    };
 
    class AsyncOutputStream final : public Poly<IAsyncOutputStream, kStreamPolySize, false> {
    public:
        using Poly::Poly;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class DataStream;
 
    class IDataStream : public IInputStream, public IOutputStream {};
 
    class DataStream final : public Poly<IDataStream, kStreamPolySize, false, IStream> {
    public:
        using Poly::Poly;
 
        explicit DataStream(AsyncDataStream asyncDataStream);
 
        explicit DataStream(const FilePath& path);
 
        explicit DataStream(size_t size);
 
        explicit DataStream(const ByteMemoryView& buffer, bool freeOnClose = false);
 
    public:
        [[nodiscard]] static size_t copy(InputStream input, OutputStream output, size_t buffer = 16 * 1024);
    };
 
    class IAsyncDataStream : public IAsyncInputStream, public IAsyncOutputStream {};
 
    class AsyncDataStream final : public Poly<IAsyncDataStream, kStreamPolySize, false> {
    public:
        using Poly::Poly;
 
        explicit AsyncDataStream(DataStream dataStream, ExecutionContext& executionContext);
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class AsyncDataStreamAdapter final : public IDataStream {
    private:
        AsyncDataStream mDataStream;
 
    public:
        explicit AsyncDataStreamAdapter(AsyncDataStream dataStream);
 
        AsyncDataStreamAdapter(AsyncDataStreamAdapter&&) noexcept = default;
 
        ~AsyncDataStreamAdapter() noexcept final;
 
    public:
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept final {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isSeekable(mode);
        }
 
        void seek(std::streamsize position, Seek mode = Seek::Start) final;
 
        [[nodiscard]] bool isTellable() const noexcept final {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isTellable();
        }
 
        [[nodiscard]] size_t tell() final;
 
        [[nodiscard]] bool isSizeKnown() const noexcept final {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isSizeKnown();
        }
 
        [[nodiscard]] size_t size() final;
 
    public: // Reading
        [[nodiscard]] bool isReadable() const noexcept final {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isReadable();
        }
 
        [[nodiscard]] size_t read(void* data, size_t n) final;
 
    public: // Writing
        [[nodiscard]] bool isWritable() const noexcept final {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isWritable();
        }
 
        [[nodiscard]] size_t write(const void* data, size_t n) final;
    };
 
    class SyncDataStreamAdapter : public IAsyncDataStream {
    private:
        DataStream mDataStream;
        ExecutionContext& mExecutionContext;
 
    public:
        explicit SyncDataStreamAdapter(DataStream dataStream, ExecutionContext& executionContext);
 
    public:
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept final {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isSeekable(mode);
        }
 
        Async<> seek(std::streamsize position, Seek mode = Seek::Start) final;
 
        [[nodiscard]] bool isTellable() const noexcept final {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isTellable();
        }
 
        [[nodiscard]] Async<size_t> tell() final;
 
        [[nodiscard]] bool isSizeKnown() const noexcept final {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isSizeKnown();
        }
 
        [[nodiscard]] Async<size_t> size() final;
 
    public: // Reading
        [[nodiscard]] bool isReadable() const noexcept final {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isReadable();
        }
 
        [[nodiscard]] Async<size_t> read(void* data, size_t n) final;
 
    public: // Writing
        [[nodiscard]] bool isWritable() const noexcept final {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isWritable();
        }
 
        [[nodiscard]] Async<size_t> write(const void* data, size_t n) final;
 
    public:
        [[nodiscard]] Async<> wait() final;
    };
 
    class FileDataStream final : public IDataStream {
    private:
        FilePath path;
 
        FILE* stream = nullptr;
 
    public:
        explicit FileDataStream(const FilePath& path, bool writing = false);
 
        FileDataStream(const FileDataStream& other);
 
        FileDataStream(FileDataStream&& other) noexcept;
 
        ~FileDataStream() final;
 
    public:
        [[nodiscard]] const FilePath& getPath() const noexcept { return path; }
 
        [[nodiscard]] FILE* getStream() const noexcept { return stream; }
 
    public: // IDataStream interface
        [[nodiscard]] bool isSeekable(Seek mode = Seek::Start) const noexcept final { return true; }
 
        void seek(std::streamsize position, Seek mode = Seek::Start) final;
 
        [[nodiscard]] bool isTellable() const noexcept final { return true; }
 
        [[nodiscard]] size_t tell() final;
 
        [[nodiscard]] bool isSizeKnown() const noexcept final { return true; }
 
        [[nodiscard]] size_t size() final;
 
        [[nodiscard]] bool isReadable() const noexcept final { return true; }
 
        [[nodiscard]] size_t read(void* data, size_t n) final;
 
        [[nodiscard]] bool isWritable() const noexcept final { return true; }
 
        [[nodiscard]] size_t write(const void* data, size_t n) final;
    };
 
    class MemoryDataStream final : public IDataStream {
        ByteMemoryView mBuffer;
        std::size_t mSize = 0;
        std::size_t mPosition = 0;
        bool mOwnsBuffer = true;
 
    public:
        explicit MemoryDataStream();
 
        explicit MemoryDataStream(size_t size);
 
        MemoryDataStream(Byte* memory, size_t size, bool freeOnClose = false);
 
        MemoryDataStream(const ByteMemoryView& buffer, bool freeOnClose = false);
 
        explicit MemoryDataStream(DataStream& stream);
 
        MemoryDataStream(const MemoryDataStream&);
        MemoryDataStream(MemoryDataStream&&) noexcept;
 
        ~MemoryDataStream() final;
 
    public:
        [[nodiscard]] MemoryView<const Byte> getData() const { return MemoryView<const Byte>(mBuffer.slice(0, mSize)); }
 
        [[nodiscard]] MemoryView<Byte> getData() { return mBuffer.slice(0, mSize); }
 
        [[nodiscard]] bool isGrowable() const { return mOwnsBuffer; }
 
    public: // IDataStream interface
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept final {
            switch(mode) {
            case Seek::Start:
            case Seek::Current:
            case Seek::End: return true;
            default: return false;
            }
        }
 
        void seek(std::streamsize position, Seek mode = Seek::Start) final;
 
        [[nodiscard]] bool isTellable() const noexcept final { return true; }
 
        [[nodiscard]] size_t tell() final { return mPosition; }
 
        [[nodiscard]] bool isSizeKnown() const noexcept final { return true; }
 
        [[nodiscard]] size_t size() final { return mSize; }
 
        [[nodiscard]] bool isReadable() const noexcept final { return true; }
 
        [[nodiscard]] size_t read(void* data, size_t n) final;
        using IDataStream::read;
 
        [[nodiscard]] bool isWritable() const noexcept final { return true; }
 
        [[nodiscard]] size_t write(const void* data, size_t n) final;
        using IDataStream::write;
 
    private:
        [[nodiscard]] bool growIfNeeded(std::size_t desiredSize);
    };
 
    class DataStreamBuffer final : public std::streambuf {
    private:
        DataStream mDataStream;
 
        size_t mBufferLength;
 
        char* mBuffer = nullptr;
 
    public:
        explicit DataStreamBuffer(DataStream dataStream, size_t bufferLength = 1024);
 
        ~DataStreamBuffer() final;
 
    protected:
        int underflow() override;
    };
 
    class InputStreamBuffer final : public std::streambuf {
    private:
        InputStream mInputStream;
 
        size_t mBufferLength;
 
        char* mBuffer = nullptr;
 
    public:
        explicit InputStreamBuffer(InputStream inputStream, size_t bufferLength = 1024);
 
        ~InputStreamBuffer() final;
 
    protected:
        int underflow() override;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> struct BinaryCodec;
 
    template<typename T, typename... Args> T binaryRead(InputStream& stream, Args&&... args) {
        return BinaryCodec<T>::read(*stream, std::forward<Args>(args)...);
    }
 
    template<typename T, typename S, typename... Args> T binaryRead(S& stream, Args&&... args) {
        return BinaryCodec<T>::read(stream, std::forward<Args>(args)...);
    }
 
    template<typename T, typename... Args> Async<T> asyncBinaryRead(AsyncInputStream& stream, Args&&... args) {
        return BinaryCodec<T>::asyncRead(*stream, std::forward<Args>(args)...);
    }
 
    template<typename T, typename S, typename... Args> Async<T> asyncBinaryRead(S& stream, Args&&... args) {
        return BinaryCodec<T>::asyncRead(stream, std::forward<Args>(args)...);
    }
 
    template<typename T, typename... Args> void binaryWrite(OutputStream& stream, const T& value, Args&&... args) {
        return BinaryCodec<T>::write(*stream, value, std::forward<Args>(args)...);
    }
 
    template<typename T, typename S, typename... Args> void binaryWrite(S& stream, const T& value, Args&&... args) {
        return BinaryCodec<T>::write(stream, value, std::forward<Args>(args)...);
    }
 
    template<typename T, typename... Args> Async<> asyncBinaryWrite(AsyncOutputStream& stream, const T& value, Args&&... args) {
        return BinaryCodec<T>::asyncWrite(*stream, value, std::forward<Args>(args)...);
    }
 
    template<typename T, typename S, typename... Args> Async<> asyncBinaryWrite(S& stream, const T& value, Args&&... args) {
        return BinaryCodec<T>::asyncWrite(stream, value, std::forward<Args>(args)...);
    }
 
    template<typename T>
    requires(std::is_trivially_copyable_v<T>) struct BinaryCodec<T> {
        template<typename S> [[nodiscard]] static T read(S& stream) {
            T value;
            if(stream.read(&value, sizeof(T)) == sizeof(T)) {
                return value;
            }
 
            throw StreamReadException("Could not read {0} bytes from the stream.", sizeof(T));
        }
 
        template<typename S> [[nodiscard]] static Async<T> asyncRead(S& stream) {
            T value;
            if(co_await stream.read(&value, sizeof(T)) == sizeof(T)) {
                co_return value;
            }
 
            throw StreamReadException("Could not read {0} bytes from the stream.", sizeof(T));
        }
 
        template<typename S> static void write(S& stream, const T& value) {
            if(stream.write(&value, sizeof(T)) == sizeof(T))
                CE_LIKELY { return; }
 
            throw StreamWriteException("Could not write {0} bytes to the stream.", sizeof(T));
        }
 
        template<typename S> static Async<> asyncWrite(S& stream, T value) {
            if(co_await stream.write(&value, sizeof(T)) == sizeof(T))
                CE_LIKELY { co_return; }
 
            throw StreamWriteException("Could not write {0} bytes to the stream.", sizeof(T));
        }
    };
 
    template<typename T, typename RawAllocator> struct BinaryCodec<BasicString<T, RawAllocator>> {
        using Type = BasicString<T, RawAllocator>;
 
        template<typename S, typename... Args> [[nodiscard]] static Type read(S& stream, Args&&... args) {
            const UInt32 length = binaryRead<UInt32>(stream);
 
            Type value(std::forward<Args>(args)...);
            value.resize(length);
 
            if(stream.read(&value, length * sizeof(T)) == length * sizeof(T)) {
                return value;
            }
 
            throw StreamReadException("Could not read {0} bytes from the stream.", length * sizeof(T));
        }
 
        template<typename S, typename... Args> [[nodiscard]] static Async<Type> asyncRead(S& stream, Args&&... args) {
            const UInt32 length = co_await binaryRead<UInt32>(stream);
 
            Type value(std::forward<Args>(args)...);
            value.resize(length);
 
            if(co_await stream.read(&value, length * sizeof(T)) == length * sizeof(T)) {
                co_return value;
            }
 
            throw StreamReadException("Could not read {0} bytes from the stream.", length * sizeof(T));
        }
 
        template<typename S> static void write(S& stream, const Type& value) {
            binaryWrite<UInt32>(stream, UInt32(value.size()));
            if(stream.write(value.data(), value.size() * sizeof(T)) == value.size() * sizeof(T)) {
                return value.size() * sizeof(T);
            }
 
            throw StreamWriteException("Could not write {0} bytes to the stream.", value.size() * sizeof(T));
        }
 
        template<typename S> static Async<> asyncWrite(S& stream, const Type& value) {
            co_await binaryWrite<UInt32>(stream, UInt32(value.size()));
            if(stream.write(value.data(), value.size() * sizeof(T)) == value.size() * sizeof(T)) {
                co_return value.size() * sizeof(T);
            }
 
            throw StreamWriteException("Could not write {0} bytes to the stream.", value.size() * sizeof(T));
        }
    };
 
    template<typename T> struct BinaryCodec<BasicStringView<T>> {
        using Type = BasicStringView<T>;
 
        static void write(IOutputStream& stream, const Type& value) {
            binaryWrite<UInt32>(stream, UInt32(value.size()));
            if(stream.write(value.data(), value.size() * sizeof(T)) == value.size() * sizeof(T)) {
                return;
            }
 
            throw StreamWriteException("Could not write {0} bytes to the stream.", value.size() * sizeof(T));
        }
    };
 
    class BinaryReader final {
    private:
        InputStream mInputStream;
 
    public:
        explicit BinaryReader(InputStream inputStream) : mInputStream(std::move(inputStream)) {}
        explicit BinaryReader(IInputStream& inputStream) : mInputStream(&inputStream) {}
 
    public:
        template<typename T, typename... Args> T read(Args&&... args) { return binaryRead<T>(mInputStream, std::forward<Args>(args)...); }
 
        template<typename T, typename... Args> Optional<T> tryRead(Args&&... args) {
            try {
                return read<T>(std::forward<Args>(args)...);
            } catch(const StreamReadException&) {
                return nullopt;
            }
        }
 
        [[nodiscard]] size_t read(void* data, const size_t n) {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->read(data, n);
        }
 
    public: // Seeking & Telling
        using Seek = Stream::Seek;
 
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->isSeekable(mode);
        }
 
        void seek(const std::streamsize position, const Seek mode = Seek::Start) {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->seek(position, mode);
        }
 
        void skip(const size_t n) {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->skip(n);
        }
 
        [[nodiscard]] bool isTellable() const noexcept {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->isTellable();
        }
 
        [[nodiscard]] size_t tell() {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->tell();
        }
 
        [[nodiscard]] bool isSizeKnown() const noexcept {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->isSizeKnown();
        }
 
        [[nodiscard]] size_t size() {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->size();
        }
 
    public:
        InputStream& getInputStream() { return mInputStream; }
 
        const InputStream& getInputStream() const { return mInputStream; }
    };
 
    class AsyncBinaryReader final {
    private:
        AsyncInputStream mInputStream;
 
    public:
        explicit AsyncBinaryReader(AsyncInputStream inputStream) : mInputStream(std::move(inputStream)) {}
        explicit AsyncBinaryReader(IAsyncInputStream& inputStream) : mInputStream(&inputStream) {}
 
    public:
        template<typename T, typename... Args> Async<T> read(Args&&... args) { return asyncBinaryRead<T>(mInputStream, std::forward<Args>(args)...); }
 
        template<typename T, typename... Args> Async<Optional<T>> tryRead(Args&&... args) {
            try {
                co_return read<T>(std::forward<Args>(args)...);
            } catch(const StreamReadException&) {
                co_return nullopt;
            }
        }
 
        [[nodiscard]] Async<size_t> read(void* data, const size_t n) {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->read(data, n);
        }
 
    public: // Seeking & Telling
        using Seek = Stream::Seek;
 
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->isSeekable(mode);
        }
 
        Async<> seek(const std::streamsize position, const Seek mode = Seek::Start) {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->seek(position, mode);
        }
 
        Async<> skip(const size_t n) {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->skip(n);
        }
 
        [[nodiscard]] bool isTellable() const noexcept {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->isTellable();
        }
 
        [[nodiscard]] Async<size_t> tell() {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->tell();
        }
 
        [[nodiscard]] bool isSizeKnown() const noexcept {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->isSizeKnown();
        }
 
        [[nodiscard]] Async<size_t> size() {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->size();
        }
 
    public:
        AsyncInputStream& getInputStream() { return mInputStream; }
 
        const AsyncInputStream& getInputStream() const { return mInputStream; }
    };
 
    class BinaryWriter final {
    private:
        OutputStream mOutputStream;
 
    public:
        explicit BinaryWriter(OutputStream outputStream) : mOutputStream(std::move(outputStream)) {}
        explicit BinaryWriter(IOutputStream& outputStream) : mOutputStream(&outputStream) {}
 
    public:
        template<typename T, typename... Args> void write(const T& value, Args&&... args) {
            return binaryWrite<T>(mOutputStream, value, std::forward<Args>(args)...);
        }
 
        template<typename T, typename... Args> bool tryWrite(const T& value, Args&&... args) {
            try {
                write<T>(value, std::forward<Args>(args)...);
                return true;
            } catch(const StreamWriteException&) {
                return false;
            }
        }
 
        [[nodiscard]] size_t write(const void* data, const size_t n) {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->write(data, n);
        }
 
    public: // Seeking & Telling
        using Seek = Stream::Seek;
 
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->isSeekable(mode);
        }
 
        void seek(const std::streamsize position, const Seek mode = Seek::Start) {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->seek(position, mode);
        }
 
        void skip(const size_t n) {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->skip(n);
        }
 
        [[nodiscard]] bool isTellable() const noexcept {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->isTellable();
        }
 
        [[nodiscard]] size_t tell() {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->tell();
        }
 
        [[nodiscard]] bool isSizeKnown() const noexcept {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->isSizeKnown();
        }
 
        [[nodiscard]] size_t size() {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->size();
        }
 
    public:
        [[nodiscard]] OutputStream& getOutputStream() { return mOutputStream; }
 
        [[nodiscard]] const OutputStream& getOutputStream() const { return mOutputStream; }
    };
 
    class AsyncBinaryWriter final {
    private:
        AsyncOutputStream mOutputStream;
 
    public:
        explicit AsyncBinaryWriter(AsyncOutputStream outputStream) : mOutputStream(std::move(outputStream)) {}
        explicit AsyncBinaryWriter(IAsyncOutputStream& outputStream) : mOutputStream(&outputStream) {}
 
    public:
        template<typename T, typename... Args> Async<> write(const T& value, Args&&... args) {
            return asyncBinaryWrite<T>(mOutputStream, value, std::forward<Args>(args)...);
        }
 
        template<typename T, typename... Args> Async<bool> tryWrite(const T& value, Args&&... args) {
            try {
                co_await write<T>(value, std::forward<Args>(args)...);
                co_return true;
            } catch(const StreamWriteException&) {
                co_return false;
            }
        }
 
        [[nodiscard]] Async<size_t> write(const void* data, const size_t n) {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->write(data, n);
        }
 
    public: // Seeking & Telling
        using Seek = Stream::Seek;
 
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->isSeekable(mode);
        }
 
        Async<> seek(const std::streamsize position, const Seek mode = Seek::Start) {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->seek(position, mode);
        }
 
        Async<> skip(const size_t n) {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->skip(n);
        }
 
        [[nodiscard]] bool isTellable() const noexcept {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->isTellable();
        }
 
        [[nodiscard]] Async<size_t> tell() {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->tell();
        }
 
        [[nodiscard]] bool isSizeKnown() const noexcept {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->isSizeKnown();
        }
 
        [[nodiscard]] Async<size_t> size() {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->size();
        }
 
    public:
        [[nodiscard]] AsyncOutputStream& getOutputStream() { return mOutputStream; }
 
        [[nodiscard]] const AsyncOutputStream& getOutputStream() const { return mOutputStream; }
    };
 
} // namespace CeresEngine