endpoint.hxx

#pragma once
 
#include <StormByte/buffer/pipeline.hxx>
#include <StormByte/network/connection/handler.hxx>
#include <StormByte/network/packet.hxx>
#include <StormByte/network/typedefs.hxx>
#include <StormByte/logger.hxx>
 
#include <atomic>
 
namespace StormByte::Network {
    class STORMBYTE_NETWORK_PUBLIC EndPoint {
        public:
            EndPoint(const Connection::Protocol& protocol, std::shared_ptr<Connection::Handler> handler, std::shared_ptr<Logger> logger) noexcept;
 
            EndPoint(const EndPoint& other)                                     = delete;
 
            EndPoint(EndPoint&& other) noexcept                                 = default;
 
            virtual ~EndPoint() noexcept;
 
            EndPoint& operator=(const EndPoint& other)                          = delete;
 
            EndPoint& operator=(EndPoint&& other) noexcept                      = default;
 
            virtual ExpectedVoid                                                Connect(const std::string& host, const unsigned short& port) noexcept = 0;
 
            virtual void                                                        Disconnect() noexcept;
 
            const Connection::Protocol&                                         Protocol() const noexcept;
 
            Connection::Status                                                  Status() const noexcept;
 
        protected:
            Connection::Protocol m_protocol;                                    
            std::shared_ptr<Connection::Handler> m_handler;                     
            std::shared_ptr<Logger> m_logger;                                   
            std::atomic<Connection::Status> m_status;                           
            Socket::Socket* m_socket;                                           
            Buffer::Pipeline m_input_pipeline, m_output_pipeline;               
 
            virtual ExpectedVoid                                                Handshake(Socket::Client& client) noexcept;
 
            virtual ExpectedVoid                                                Authenticate(Socket::Client& client) noexcept;
 
            ExpectedPacket                                                      Receive(Socket::Client& client) noexcept;
 
            ExpectedPacket                                                      RawReceive(Socket::Client& client) noexcept;
 
            ExpectedVoid                                                        Send(Socket::Client& client, const Packet& packet) noexcept;
 
            ExpectedVoid                                                        RawSend(Socket::Client& client, const Packet& packet) noexcept;
 
        private:
            ExpectedPacket                                                      Receive(Socket::Client& client, Buffer::Pipeline& pipeline) noexcept;
 
            ExpectedVoid                                                        Send(Socket::Client& client, const Packet& packet, Buffer::Pipeline& pipeline) noexcept;
    };
}