Stream.Buffered.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 "Stream.Filtered.hpp"
 
namespace CeresEngine {
 
    class BufferedInputStream final : public FilteredInputStream {
        using super = FilteredInputStream;
 
    private: // Read Buffer
        ByteMemoryView mBuffer;
        ByteMemoryView mBufferData;
 
    public:
        explicit BufferedInputStream(InputStream&& inputStream, size_t bufferSize = 1024);
 
        BufferedInputStream(const BufferedInputStream&) = delete;
        BufferedInputStream(BufferedInputStream&&) noexcept;
 
        ~BufferedInputStream() final;
 
    public: // IInputStream interface
        void seek(std::streamsize position, Seek mode = Seek::Start) final;
 
        [[nodiscard]] size_t tell() final;
 
        [[nodiscard]] size_t read(void* data, size_t n) final;
 
        [[nodiscard]] bool invalidate() final;
 
    private:
        void invalidateReadBuffer();
    };
 
    class BufferedOutputStream final : public FilteredOutputStream {
        using super = FilteredOutputStream;
 
    private: // Write Buffer
        ByteMemoryView mBuffer;
        size_t mBufferPosition;
 
    public:
        explicit BufferedOutputStream(OutputStream&& outputStream, size_t bufferSize = 1024);
 
        BufferedOutputStream(const BufferedOutputStream&) = delete;
        BufferedOutputStream(BufferedOutputStream&&) noexcept;
 
        ~BufferedOutputStream() final;
 
    public: // IOutputStream interface
        void seek(std::streamsize position, Seek mode = Seek::Start) final;
 
        [[nodiscard]] size_t tell() final;
 
        [[nodiscard]] size_t write(const void* data, size_t n) final;
 
        [[nodiscard]] bool flush() final;
 
    private:
        void flushWriteBuffer();
    };
 
    class BufferedDataStream final : public FilteredDataStream {
        using super = FilteredDataStream;
 
    private:
        size_t mPosition = 0;
 
    private: // Read Buffer
        void* mReadBuffer = nullptr;
 
        const size_t mReadBufferSize = 0;
 
        TRange<size_t> mReadBufferRange;
 
    private: // Write Buffer
        void* mWriteBuffer = nullptr;
 
        const size_t mWriteBufferSize = 0;
 
        TRange<size_t> mWriteBufferRange;
 
    public:
        explicit BufferedDataStream(DataStream&& dataStream, size_t readBufferSize = 1024, size_t writeBufferSize = 1024);
 
        BufferedDataStream(const BufferedDataStream&) = delete;
        BufferedDataStream(BufferedDataStream&&) noexcept;
 
        static BufferedDataStream createReadBufferedStream(DataStream&& dataStream, const size_t readBufferSize = 1024) {
            return BufferedDataStream(std::move(dataStream), readBufferSize, 0);
        }
 
        static BufferedDataStream createWriteBufferedStream(DataStream&& dataStream, const size_t writeBufferSize = 1024) {
            return BufferedDataStream(std::move(dataStream), 0, writeBufferSize);
        }
 
        ~BufferedDataStream() final;
 
    public: // IDataStream interface
        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]] size_t read(void* data, size_t n) final;
 
        [[nodiscard]] bool invalidate() final;
 
        [[nodiscard]] size_t write(const void* data, size_t n) final;
 
        [[nodiscard]] bool flush() final;
 
    private:
        void invalidateReadBuffer();
        void flushWriteBuffer();
    };
 
} // namespace CeresEngine