external.hxx

#pragma once
 
#include <StormByte/buffer/reader.hxx>
#include <StormByte/buffer/shared.hxx>
 
namespace StormByte::Buffer {
    class STORMBYTE_PUBLIC External: public Shared {
        public:
            External(const Reader& reader) noexcept;
 
            External(Reader&& reader) noexcept;
 
            External(const External& other)                                     = default;
 
            External(External&& other) noexcept                                 = default;
 
            ~External() noexcept override                                       = default;
 
            External& operator=(const External& other)                          = default;
 
            External& operator=(External&& other) noexcept                      = default;
 
            External&                                                           operator<<(const Buffer::Status& status);
 
            External&                                                           operator<<(const Simple& buffer);
 
            External&                                                           operator<<(Simple&& buffer);
 
            External&                                                           operator<<(const std::string& data);
 
            External&                                                           operator<<(const Buffer::Data& data);
 
            External&                                                           operator<<(Buffer::Data&& data);
 
            template <typename NumericType, typename = std::enable_if_t<std::is_arithmetic_v<std::decay_t<NumericType>>>>
            External&                                                           operator<<(const NumericType& value) {
                Shared::operator<<(value);
                return *this;
            }
 
            External&                                                           operator>>(External& buffer);
 
            void                                                                Reader(const class Reader& reader) noexcept;
 
            void                                                                Reader(class Reader&& reader) noexcept;
 
            bool                                                                HasEnoughData(const std::size_t& length) override;
 
            ExpectedData<BufferOverflow>                                        Read(const size_t& length) const override;
 
        private:
            std::shared_ptr<class Reader> m_external_reader;                    
 
            Read::Status                                                        Wait(const std::size_t& length) noexcept override;
 
            bool                                                                ReadExternalData(const size_t& bytes) noexcept;
    };
}