bridge.hxx

#pragma once
 
#include <StormByte/buffer/external.hxx>
#include <StormByte/buffer/fifo.hxx>
 
namespace StormByte::Buffer {
    class STORMBYTE_BUFFER_PUBLIC Bridge {
        public:
            inline Bridge(const ExternalReader& in, const ExternalWriter& out, std::size_t chunk_size = 4096) noexcept:
                m_buffer(),
                m_read_handler(in.Clone()),
                m_write_handler(out.Clone()),
                m_chunk_size(chunk_size) {}
 
            inline Bridge(ExternalReader&& in, ExternalWriter&& out, std::size_t chunk_size = 4096) noexcept:
                m_buffer(),
                m_read_handler(in.Move()),
                m_write_handler(out.Move()),
                m_chunk_size(chunk_size) {}
 
            Bridge(const Bridge& other)                                 = delete;
 
            inline Bridge(Bridge&& other) noexcept                      = default;
 
            inline ~Bridge() noexcept {
                Flush();
            }
 
            Bridge& operator=(const Bridge& other)                      = delete;
 
            Bridge& operator=(Bridge&& other) noexcept                  = default;
 
            inline std::size_t                                          ChunkSize() const noexcept {
                return m_chunk_size;
            }
 
            bool                                                        Flush() const noexcept;
 
            bool                                                        Passthrough(std::size_t bytes) const noexcept;
 
            bool                                                        Passthrough(std::size_t bytes) noexcept;
 
            inline std::size_t                                          PendingBytes() const noexcept {
                return m_buffer.Size();
            }
 
        private:
            mutable Buffer::FIFO m_buffer;                              
            ExternalReader::PointerType m_read_handler;                 
            ExternalWriter::PointerType m_write_handler;                
            std::size_t m_chunk_size;                                   
 
            bool                                                        PassthroughWrite(Buffer::DataType&& data) const noexcept;
    };
}