endpoint.hxx

#pragma once
 
#include <StormByte/buffer/pipeline.hxx>
#include <StormByte/logger/threaded_log.hxx>
#include <StormByte/network/typedefs.hxx>
 
namespace StormByte::Network {
    namespace Connection {
        class Client;                                        
    }
 
    class STORMBYTE_NETWORK_PUBLIC Endpoint {
        public:
            Endpoint(const DeserializePacketFunction& deserialize_packet_function, std::shared_ptr<Logger::Log> logger) noexcept;
 
            Endpoint(const Endpoint& other)                             = delete;
 
            Endpoint(Endpoint&& other) noexcept                         = default;
 
            virtual ~Endpoint() noexcept                                = default;
 
            Endpoint& operator=(const Endpoint& other)                  = delete;
 
            Endpoint& operator=(Endpoint&& other) noexcept              = default;
 
            virtual bool                                                Connect(const Connection::Protocol& protocol, const std::string& address, const unsigned short& port) = 0;
 
            virtual void                                                Disconnect() noexcept = 0;
 
            virtual Connection::Status                                  Status() const noexcept = 0;
 
        protected:
            DeserializePacketFunction m_deserialize_packet_function;    
            std::shared_ptr<Logger::Log> m_logger;                      
 
            std::shared_ptr<Connection::Client>                         CreateConnection(std::shared_ptr<Socket::Client> socket) noexcept;
 
            virtual Buffer::Pipeline                                    InputPipeline() const noexcept = 0;
 
            virtual Buffer::Pipeline                                    OutputPipeline() const noexcept = 0;
 
            PacketPointer                                               Send(std::shared_ptr<Connection::Client> client_connection, const Transport::Packet& packet) noexcept;
 
            bool                                                        Reply(std::shared_ptr<Connection::Client> client_connection, const Transport::Packet& packet) noexcept;
 
        private:
            bool                                                        SendPacket(std::shared_ptr<Connection::Client> client_connection, const Transport::Packet& packet) noexcept;
    };
}