external.hxx

#pragma once
 
#include <StormByte/buffer/generic.hxx>
#include <StormByte/clonable.hxx>
 
#include <functional>
 
namespace StormByte::Buffer {
    class STORMBYTE_BUFFER_PUBLIC ExternalReader: public Clonable<ExternalReader, std::unique_ptr<ExternalReader>> {
        public:
            ExternalReader() noexcept                                               = default;
 
            ExternalReader(const ExternalReader& other)                             = default;
 
            ExternalReader(ExternalReader&& other) noexcept                         = default;
 
            virtual ~ExternalReader() noexcept                                      = default;
 
            ExternalReader& operator=(const ExternalReader& other)                  = default;
 
            ExternalReader& operator=(ExternalReader&& other) noexcept              = default;
 
            virtual bool                                                            Read(std::size_t bytes, DataType& out) const noexcept = 0;
 
            virtual bool                                                            Read(std::size_t bytes, DataType& out) noexcept = 0;
    };
 
    class STORMBYTE_BUFFER_PUBLIC ExternalBufferReader final: public ExternalReader {
        public:
            inline ExternalBufferReader(ReadOnly& buffer) noexcept:
                m_buffer(buffer) {}
 
            ExternalBufferReader(const ExternalBufferReader& other)                 = default;
 
            ExternalBufferReader(ExternalBufferReader&& other) noexcept             = default;
 
            ~ExternalBufferReader() noexcept                                        = default;
 
            ExternalBufferReader& operator=(const ExternalBufferReader& other)      = default;
 
            ExternalBufferReader& operator=(ExternalBufferReader&& other) noexcept  = default;
 
            inline PointerType                                                      Clone() const noexcept override {
                return MakePointer<ExternalBufferReader>(*this);
            }
 
            inline PointerType                                                      Move() noexcept override {
                return MakePointer<ExternalBufferReader>(std::move(*this));
            }
 
            bool                                                                    Read(std::size_t bytes, DataType& out) const noexcept override;
 
            bool                                                                    Read(std::size_t bytes, DataType& out) noexcept override;
 
        private:
            std::reference_wrapper<ReadOnly> m_buffer;                              
    };
 
    class STORMBYTE_BUFFER_PUBLIC ExternalWriter: public Clonable<ExternalWriter> {
        public:
            ExternalWriter() noexcept                                               = default;
 
            ExternalWriter(const ExternalWriter& other)                             = default;
 
            ExternalWriter(ExternalWriter&& other) noexcept                         = default;
 
            virtual ~ExternalWriter() noexcept                                      = default;
 
            ExternalWriter& operator=(const ExternalWriter& other)                  = default;
            ExternalWriter& operator=(ExternalWriter&& other) noexcept              = default;
 
            virtual bool                                                            Write(DataType&& in) noexcept = 0;
    };
 
    class STORMBYTE_BUFFER_PUBLIC ExternalBufferWriter final: public ExternalWriter {
        public:
            inline ExternalBufferWriter(WriteOnly& buffer) noexcept:
                m_buffer(buffer) {}
 
            ExternalBufferWriter(const ExternalBufferWriter& other)                 = default;
 
            ExternalBufferWriter(ExternalBufferWriter&& other) noexcept             = default;
 
            ~ExternalBufferWriter() noexcept                                        = default;
 
            ExternalBufferWriter& operator=(const ExternalBufferWriter& other)      = default;
 
            ExternalBufferWriter& operator=(ExternalBufferWriter&& other) noexcept  = default;
 
            inline PointerType                                                      Clone() const noexcept override {
                return MakePointer<ExternalBufferWriter>(*this);
            }
 
            inline PointerType                                                      Move() noexcept override {
                return MakePointer<ExternalBufferWriter>(std::move(*this));
            }
 
            bool                                                                    Write(DataType&& in) noexcept override;
 
        private:
            std::reference_wrapper<WriteOnly> m_buffer;                             
    };
}