shared.hxx

#pragma once
 
#include <StormByte/buffer/simple.hxx>
 
#include <atomic>
#include <cstddef>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <string>
 
namespace StormByte::Buffer {
    class STORMBYTE_PUBLIC Shared: public Simple {
        public:
            Shared() noexcept;
 
            explicit Shared(const std::size_t& size);
 
            Shared(const char* data, const std::size_t& length);
 
            Shared(const std::string& data);
 
            Shared(const Buffer::Data& data);
 
            Shared(Buffer::Data&& data);
 
            Shared(const std::span<const Byte>& data);
 
            Shared(const Shared& other);
 
            Shared(Shared&& other) noexcept;
 
            Shared(const Simple& other);
 
            Shared(Simple&& other) noexcept;
 
            virtual ~Shared() noexcept override                                 = default;
 
            Shared&                                                             operator=(const Shared& other);
 
            Shared&                                                             operator=(Shared&& other) noexcept;
 
            Shared&                                                             operator<<(const Status& status);
 
            Shared&                                                             operator<<(const Simple& buffer);
 
            Shared&                                                             operator<<(Simple&& buffer);
 
            Shared&                                                             operator<<(const std::string& data);
 
            Shared&                                                             operator<<(const Buffer::Data& data);
 
            Shared&                                                             operator<<(Buffer::Data&& data);
 
            template <typename NumericType, typename = std::enable_if_t<std::is_arithmetic_v<std::decay_t<NumericType>>>>
            Shared&                                                             operator<<(const NumericType& value) {
                std::unique_lock lock(m_data_mutex);
                Simple::operator<<(value);
                return *this;
            }
 
            Shared&                                                             operator>>(Shared& buffer);
 
            virtual size_t                                                      AvailableBytes() const noexcept;
 
            size_t                                                              Capacity() const noexcept override;
 
            void                                                                Clear() noexcept override;
 
            Buffer::Data                                                        Data() const noexcept override;
 
            void                                                                Discard(const std::size_t& length, const Read::Position& mode) noexcept override;
 
            bool                                                                End() const noexcept override;
 
            bool                                                                Empty() const noexcept override;
 
            virtual ExpectedData<BufferOverflow>                                Extract(const size_t& length) override;
 
            virtual Read::Status                                                ExtractInto(const size_t& length, Shared& output) noexcept;
 
            virtual bool                                                        HasEnoughData(const std::size_t& length) override;
 
            std::string                                                         HexData(const std::size_t& column_size = 16) const override;
 
            bool                                                                IsEoF() const noexcept override;
 
            bool                                                                IsReadable() const noexcept;
 
            bool                                                                IsWritable() const noexcept;
 
            void                                                                Lock();
 
            ExpectedByte<BufferOverflow>                                        Peek() const override;
 
            std::size_t                                                         Position() const noexcept override;
 
            virtual ExpectedData<BufferOverflow>                                Read(const size_t& length) const override;
 
            void                                                                Reserve(const std::size_t& size) override;
 
            void                                                                Seek(const std::ptrdiff_t& position, const Read::Position& mode) const override;
 
            std::size_t                                                         Size() const noexcept override;
 
            enum Status                                                         Status() const noexcept;
 
            void                                                                Unlock();
 
            Write::Status                                                       Write(const Simple& buffer) override;
 
            Write::Status                                                       Write(Simple&& buffer) override;
 
            Write::Status                                                       Write(const std::string& data) override;
 
            Write::Status                                                       Write(const Buffer::Data& data) override;
 
            Write::Status                                                       Write(Buffer::Data&& data) override;
 
        protected:
            mutable std::shared_mutex m_data_mutex;                             
            std::atomic<enum Status> m_status;                                  
 
            virtual Read::Status                                                Wait(const std::size_t& length) noexcept;
    };
}