consumer.hxx

#pragma once
 
#include <StormByte/buffer/shared.hxx>
#include <memory>
 
namespace StormByte::Buffer {
    class Producer; // Forward declaration of the Producer class
 
    class STORMBYTE_PUBLIC Consumer final {
        friend class Producer;
 
        public:
            Consumer() noexcept;
 
            explicit Consumer(std::shared_ptr<Shared> shared) noexcept;
 
            Consumer(const Consumer& other)                             = default;
 
            Consumer(Consumer&& other) noexcept                         = default;
 
            ~Consumer() noexcept = default;
 
            Consumer& operator=(const Consumer& other)                  = default;
 
            Consumer& operator=(Consumer&& other) noexcept              = default;
 
            std::size_t                                                 AvailableBytes() const noexcept;
 
            Buffer::Data                                                Data() const noexcept;
 
            void                                                        Discard(const std::size_t& length, const Read::Position& mode) noexcept;
 
            bool                                                        End() const noexcept;
 
            bool                                                        Empty() const noexcept;
 
            ExpectedData<BufferOverflow>                                Extract(const size_t& length);
 
            Read::Status                                                ExtractInto(const size_t& length, Shared& output) noexcept;
 
            bool                                                        HasEnoughData(const std::size_t& length) const;
 
            std::string                                                 HexData(const std::size_t& column_size = 16) const;
 
            bool                                                        IsEoF() const noexcept;
 
            bool                                                        IsReadable() const noexcept;
 
            ExpectedByte<BufferOverflow>                                Peek() const;
 
            std::size_t                                                 Position() const noexcept;
 
            ExpectedData<BufferOverflow>                                Read(const size_t& length) const;
 
            void                                                        Seek(const std::ptrdiff_t& position, const Read::Position& mode) const;
 
            std::size_t                                                 Size() const noexcept;
 
            enum Status                                                 Status() const noexcept;
 
            Producer                                                    Producer() const noexcept;
 
        private:
            std::shared_ptr<Shared> m_shared;                           
    };
}