consumer.hxx

#pragma once
 
#include <StormByte/buffer/shared_fifo.hxx>
 
#include <memory>
 
namespace StormByte::Buffer {
    class STORMBYTE_BUFFER_PUBLIC Consumer final: public ReadOnly {
        friend class Producer;
        public:
            inline Consumer(const Consumer& other) noexcept {
                m_buffer = other.m_buffer;
            }
 
            inline Consumer(Consumer&& other) noexcept {
                m_buffer = std::move(other.m_buffer);
            }
 
            ~Consumer() noexcept                                        = default;
 
            inline Consumer& operator=(const Consumer& other) noexcept {
                if (this != &other)
                    m_buffer = other.m_buffer;
                return *this;
            }
 
            inline Consumer& operator=(Consumer&& other) noexcept {
                if (this != &other)
                    m_buffer = std::move(other.m_buffer);
                return *this;
            }
 
            inline bool operator==(const Consumer& other) const noexcept {
                return m_buffer.get() == other.m_buffer.get();
            }
 
            inline bool operator!=(const Consumer& other) const noexcept {
                return !(*this == other);
            }
 
            inline std::size_t                                          AvailableBytes() const noexcept override {
                return m_buffer->AvailableBytes();
            }
 
            inline void                                                 Clean() noexcept override {
                m_buffer->Clean();
            }
 
            inline void                                                 Clear() noexcept override {
                m_buffer->Clear();
            }
 
            inline void                                                 Close() noexcept {
                m_buffer->Close();
            }
 
            inline bool                                                 Drop(const std::size_t& count) noexcept override {
                return m_buffer->Drop(count);
            }
 
            inline bool                                                 Empty() const noexcept override {
                return m_buffer->Empty();
            }
 
            inline bool                                                 EoF() const noexcept override {
                return m_buffer->EoF();
            }
 
            inline bool                                                 Extract(const std::size_t& count, DataType& outBuffer) noexcept override {
                return m_buffer->Extract(count, outBuffer);
            }
 
            inline bool                                                 Extract(const std::size_t& count, WriteOnly& outBuffer) noexcept {
                return m_buffer->Extract(count, outBuffer);
            }
 
            inline void                                                 ExtractUntilEoF(DataType& outBuffer) noexcept override {
                m_buffer->ExtractUntilEoF(outBuffer);
            }
 
            inline void                                                 ExtractUntilEoF(WriteOnly& outBuffer) noexcept override {
                m_buffer->ExtractUntilEoF(outBuffer);
            }
 
            inline bool                                                 IsReadable() const noexcept override {
                return m_buffer->IsReadable();
            }
 
            inline bool                                                 IsWritable() const noexcept {
                return m_buffer->IsWritable();
            }
 
            inline bool                                                 HasError() const noexcept {
                return m_buffer->HasError();
            }
 
            inline bool                                                 Read(const std::size_t& count, DataType& outBuffer) const noexcept override {
                return m_buffer->Read(count, outBuffer);
            }
 
            inline bool                                                 Read(const std::size_t& count, WriteOnly& outBuffer) const noexcept override {
                return m_buffer->Read(count, outBuffer);
            }
 
            inline void                                                 ReadUntilEoF(DataType& outBuffer) const noexcept override {
                m_buffer->ReadUntilEoF(outBuffer);
            }
 
            inline void                                                 ReadUntilEoF(WriteOnly& outBuffer) const noexcept override {
                m_buffer->ReadUntilEoF(outBuffer);
            }
 
            inline bool                                                 Peek(const std::size_t& count, DataType& outBuffer) const noexcept override {
                return m_buffer->Peek(count, outBuffer);
            }
 
            inline bool                                                 Peek(const std::size_t& count, WriteOnly& outBuffer) const noexcept override {
                return m_buffer->Peek(count, outBuffer);
            }
 
            inline void                                                 Seek(const std::ptrdiff_t& offset, const Position& mode) const noexcept {
                m_buffer->Seek(offset, mode);
            }
 
            inline std::size_t                                          Size() const noexcept override {
                return m_buffer->Size();
            }
 
        private:
            std::shared_ptr<SharedFIFO> m_buffer;                       
 
            inline Consumer(std::shared_ptr<SharedFIFO> buffer): m_buffer(buffer) {}
    };
}