producer.hxx

#pragma once
 
#include <StormByte/buffer/shared.hxx>
#include <memory>
 
namespace StormByte::Buffer {
    class Consumer; // Forward declaration of the Consumer class
 
    class STORMBYTE_PUBLIC Producer final {
        public:
            Producer() noexcept;
 
            Producer(const Consumer& consumer);
 
            Producer(std::shared_ptr<Shared> shared) noexcept;
 
            Producer(const Simple& simple) noexcept;
 
            Producer(Simple&& simple) noexcept;
 
            Producer(const Producer& other)                             = default;
 
            Producer(Producer&& other) noexcept                         = default;
 
            ~Producer() noexcept                                        = default;
 
            Producer& operator=(const Producer& other)                  = default;
 
            Producer& operator=(Producer&& other) noexcept              = default;
 
            Producer& operator=(const Consumer& consumer) noexcept;
 
            Producer&                                                   operator<<(const Status& status);
 
            Producer&                                                   operator<<(const Simple& buffer);
 
            Producer&                                                   operator<<(Simple&& buffer);
 
            Producer&                                                   operator<<(const std::string& data);
 
            Producer&                                                   operator<<(const Buffer::Data& data);
 
            Producer&                                                   operator<<(Buffer::Data&& data);
 
            Consumer                                                    Consumer() const noexcept;
 
            void                                                        Lock();
 
            void                                                        Reserve(const std::size_t& size);
 
            void                                                        Unlock();
 
            Write::Status                                               Write(const Simple& buffer);
 
            Write::Status                                               Write(Simple&& buffer);
 
            Write::Status                                               Write(const std::string& data);
 
            Write::Status                                               Write(const Buffer::Data& data);
 
            Write::Status                                               Write(Buffer::Data&& data);
 
        private:
            std::shared_ptr<Shared> m_shared; 
    };
}