Stream.Filtered.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.hpp"
 
namespace CeresEngine {
 
    class FilteredInputStream : public IInputStream {
    protected:
        InputStream mInputStream;
 
    public:
        explicit FilteredInputStream(InputStream&& inputStream) : mInputStream(std::move(inputStream)) {}
 
        FilteredInputStream(FilteredInputStream&&) noexcept = default;
        ~FilteredInputStream() override = default;
 
    public:
        InputStream& getInputStream() noexcept { return mInputStream; }
 
        const InputStream& getInputStream() const noexcept { return mInputStream; }
 
    public: // IInputStream interface
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept override {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->isSeekable(mode);
        }
 
        void seek(const std::streamsize position, const Seek mode = Seek::Start) override {
            CE_ASSERT(mInputStream != nullptr);
            mInputStream->seek(position, mode);
        }
 
        [[nodiscard]] bool isTellable() const noexcept override {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->isTellable();
        }
 
        [[nodiscard]] size_t tell() override {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->tell();
        }
 
        [[nodiscard]] bool isSizeKnown() const noexcept override {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->isSizeKnown();
        }
 
        [[nodiscard]] size_t size() override {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->size();
        }
 
        [[nodiscard]] bool isReadable() const noexcept override {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->isReadable();
        }
 
        [[nodiscard]] size_t read(void* data, const size_t n) override {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->read(data, n);
        }
 
        [[nodiscard]] bool invalidate() override {
            CE_ASSERT(mInputStream != nullptr);
            return mInputStream->invalidate();
        }
    };
 
    class FilteredOutputStream : public IOutputStream {
    protected:
        OutputStream mOutputStream;
 
    public:
        explicit FilteredOutputStream(OutputStream&& outputStream) : mOutputStream(std::move(outputStream)) {}
 
        FilteredOutputStream(FilteredOutputStream&&) noexcept = default;
        ~FilteredOutputStream() override = default;
 
    public:
        OutputStream& getOutputStream() noexcept { return mOutputStream; }
 
        const OutputStream& getOutputStream() const noexcept { return mOutputStream; }
 
    public: // IOutputStream interface
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept override {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->isSeekable(mode);
        }
 
        void seek(const std::streamsize position, const Seek mode = Seek::Start) override {
            CE_ASSERT(mOutputStream != nullptr);
            mOutputStream->seek(position, mode);
        }
 
        [[nodiscard]] bool isTellable() const noexcept override {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->isTellable();
        }
 
        [[nodiscard]] size_t tell() override {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->tell();
        }
 
        [[nodiscard]] bool isSizeKnown() const noexcept override {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->isSizeKnown();
        }
 
        [[nodiscard]] size_t size() override {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->size();
        }
 
        [[nodiscard]] bool isWritable() const noexcept override {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->isWritable();
        }
 
        using IOutputStream::write;
 
        [[nodiscard]] size_t write(const void* data, const size_t n) override {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->write(data, n);
        }
 
        [[nodiscard]] bool flush() override {
            CE_ASSERT(mOutputStream != nullptr);
            return mOutputStream->flush();
        }
    };
 
    class FilteredDataStream : public IDataStream {
    protected:
        DataStream mDataStream;
 
    public:
        explicit FilteredDataStream(DataStream&& dataStream) : mDataStream(std::move(dataStream)) {}
 
        FilteredDataStream(FilteredDataStream&&) noexcept = default;
        ~FilteredDataStream() override = default;
 
    public:
        DataStream& getDataStream() noexcept { return mDataStream; }
 
        const DataStream& getDataStream() const noexcept { return mDataStream; }
 
    public: // IDataStream interface
        [[nodiscard]] bool isSeekable(const Seek mode = Seek::Start) const noexcept override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isSeekable(mode);
        }
 
        void seek(const std::streamsize position, const Seek mode = Seek::Start) override {
            CE_ASSERT(mDataStream != nullptr);
            mDataStream->seek(position, mode);
        }
 
        [[nodiscard]] bool isTellable() const noexcept override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isTellable();
        }
 
        [[nodiscard]] size_t tell() override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->tell();
        }
 
        [[nodiscard]] bool isSizeKnown() const noexcept override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isSizeKnown();
        }
 
        [[nodiscard]] size_t size() override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->size();
        }
 
        [[nodiscard]] bool isReadable() const noexcept override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isReadable();
        }
 
        [[nodiscard]] size_t read(void* data, const size_t n) override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->read(data, n);
        }
 
        [[nodiscard]] bool invalidate() override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->invalidate();
        }
 
        [[nodiscard]] bool isWritable() const noexcept override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->isWritable();
        }
 
        [[nodiscard]] size_t write(const void* data, const size_t n) override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->write(data, n);
        }
 
        [[nodiscard]] bool flush() override {
            CE_ASSERT(mDataStream != nullptr);
            return mDataStream->flush();
        }
    };
 
} // namespace CeresEngine