bridge.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-Buffer.
 *
 * StormByte-Buffer is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * or later, as published by the Free Software Foundation.
 *
 * StormByte-Buffer is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with StormByte-Buffer. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 */
 
#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&) = delete;
 
            Bridge(Bridge&&) noexcept = default;
 
            inline ~Bridge() noexcept {
                Flush();
            }
 
            Bridge& operator=(const Bridge&) = delete;
 
            Bridge& operator=(Bridge&&) noexcept = default;
 
            inline std::size_t ChunkSize() const noexcept {
                return m_chunk_size;
            }
 
            inline std::size_t PendingBytes() const noexcept {
                return m_buffer.Size();
            }
 
            inline bool EoF() const noexcept {
                return m_read_handler->EoF();
            }
 
            inline bool IsReadable() const noexcept {
                return m_read_handler->IsReadable();
            }
 
            inline bool IsWritable() const noexcept {
                return m_write_handler->IsWritable();
            }
 
            bool Flush() const noexcept;
 
            bool FlushAndClose() const noexcept;
 
            void SetError() const noexcept;
 
            bool Passthrough(std::size_t bytes) const noexcept;
 
            bool Passthrough(std::size_t bytes) noexcept;
 
        private:
            mutable FIFO m_buffer;                          
            ExternalReader::PointerType m_read_handler;     
            ExternalWriter::PointerType m_write_handler;    
            std::size_t m_chunk_size;                       
 
            bool PassthroughWrite(DataType&& data) const noexcept;
    };
}