shared_fifo.hxx

#pragma once
 
#include <StormByte/buffer/fifo.hxx>
 
#include <condition_variable>
#include <mutex>
 
namespace StormByte::Buffer {
    class STORMBYTE_BUFFER_PUBLIC SharedFIFO: public FIFO {
        public:
            SharedFIFO() noexcept                               = default;
 
            inline SharedFIFO(const DataType& data): FIFO(data) {}
 
            inline SharedFIFO(DataType&& data) noexcept: FIFO(std::move(data)) {}
 
            template<std::ranges::input_range R>
            requires (!std::is_class_v<std::remove_cv_t<std::ranges::range_value_t<R>>>) &&
                requires(std::ranges::range_value_t<R> v) { static_cast<std::byte>(v); } &&
                (!std::same_as<std::remove_cvref_t<R>, DataType>)
            inline SharedFIFO(const R& r) noexcept: FIFO(r), m_closed(false),
            m_error(false), m_error_message() {}
 
            template<std::ranges::input_range Rr>
            requires (!std::is_class_v<std::remove_cv_t<std::ranges::range_value_t<Rr>>>) &&
                requires(std::ranges::range_value_t<Rr> v) { static_cast<std::byte>(v); }
            inline SharedFIFO(Rr&& r) noexcept: FIFO(std::forward<Rr>(r)), m_closed(false),
            m_error(false), m_error_message() {}
 
            inline SharedFIFO(std::string_view sv) noexcept: FIFO(sv), m_closed(false),
            m_error(false), m_error_message() {}
 
            inline SharedFIFO(const FIFO& other): FIFO(other) {}
 
            inline SharedFIFO(FIFO&& other) noexcept: FIFO(std::move(other)) {}
 
            SharedFIFO(const SharedFIFO&)                       = delete;
            
            SharedFIFO(SharedFIFO&& other) noexcept             = default;
            
            virtual ~SharedFIFO() noexcept                      = default;
 
            SharedFIFO& operator=(const FIFO& other);
 
            SharedFIFO& operator=(FIFO&& other) noexcept;
 
            SharedFIFO& operator=(const SharedFIFO&)            = delete;
 
            SharedFIFO& operator=(SharedFIFO&&) noexcept;
 
            bool operator==(const SharedFIFO& other) const noexcept;
 
            inline bool operator!=(const SharedFIFO& other) const noexcept {
                return !(*this == other);
            }
 
            virtual std::size_t                                 AvailableBytes() const noexcept override;
 
            void                                                Clean() noexcept override;
 
            virtual void                                        Clear() noexcept override;
 
            inline virtual const DataType&                      Data() const noexcept override {
                return m_buffer;
            }
 
            virtual void                                        Close() noexcept;
 
            virtual bool                                        Drop(const std::size_t& count) noexcept override;
            
            virtual bool                                        Empty() const noexcept override;
            
            virtual bool                                        EoF() const noexcept override;
 
            bool                                                HasError() const noexcept;
 
            virtual std::string                                 HexDump(const std::size_t& collumns = 0, const std::size_t& byte_limit = 0) const noexcept override;
 
            inline virtual bool                                 IsReadable() const noexcept override { return !m_error; }
 
            inline virtual bool                                 IsWritable() const noexcept override { return !m_closed && !m_error; }
 
            virtual void                                        Seek(const std::ptrdiff_t& offset, const Position& mode) const noexcept override;
 
            virtual void                                        SetError() noexcept;
            
            virtual std::size_t                                 Size() const noexcept override;
 
        protected:
            bool m_closed {false};                              
            bool m_error {false};                               
            std::string m_error_message;                        
 
        private:
            mutable std::mutex m_mutex;                         
            mutable std::condition_variable_any m_cv;           
 
            std::ostringstream                                  HexDumpHeader() const noexcept override;
 
            virtual bool                                        ReadInternal(const std::size_t& count, DataType& outBuffer, const Operation& flag) noexcept override;
            virtual bool                                        ReadInternal(const std::size_t& count, WriteOnly& outBuffer, const Operation& flag) noexcept override;
 
            void                                                Wait(const std::size_t& n, std::unique_lock<std::mutex>& lock) const;
 
            virtual bool                                        WriteInternal(const std::size_t& count, const DataType& src) noexcept override;
 
            virtual bool                                        WriteInternal(const std::size_t& count, DataType&& src) noexcept override;
    };
}