server.hxx

#pragma once
 
#include <StormByte/network/endpoint.hxx>
#include <StormByte/network/typedefs.hxx>
 
#include <mutex>
#include <thread>
#include <unordered_map>
#include <vector>
 
namespace StormByte::Network {
    class STORMBYTE_NETWORK_PUBLIC Server: public EndPoint {
        public:
            Server(Connection::Protocol protocol, std::shared_ptr<Connection::Handler> handler, std::shared_ptr<Logger> logger) noexcept;
 
            Server(const Server& other)                                                     = delete;
 
            Server(Server&& other) noexcept                                                 = default;
 
            virtual ~Server() noexcept override;
 
            Server& operator=(const Server& other)                                          = delete;
 
            Server& operator=(Server&& other) noexcept                                      = default;
 
            virtual StormByte::Expected<void, ConnectionError>                              Start(const std::string& host, const unsigned short& port) noexcept;
 
            virtual void                                                                    Stop() noexcept;
 
        protected:
            std::vector<FutureBufferProcessor> m_input_pipeline;                            
            std::vector<FutureBufferProcessor> m_output_pipeline;                           
 
            Socket::Client&                                                                 AddClient(Socket::Client&& client) noexcept;
 
            void                                                                            RemoveClient(Socket::Client& client) noexcept;
 
            void                                                                            RemoveClientAsync(Socket::Client& client) noexcept;
 
            void                                                                            DisconnectClient(Socket::Client& client) noexcept;
 
            virtual bool                                                                    Handshake(Socket::Client& client) noexcept;
 
            virtual ExpectedFutureBuffer                                                    ProcessClientMessage(Socket::Client& client, FutureBuffer& message) noexcept = 0;
 
        private:
            std::thread m_accept_thread;                                                    
            std::mutex m_clients_mutex;                                                     
            std::vector<Socket::Client> m_clients;                                          
            std::mutex m_msg_threads_mutex;                                                 
            std::unordered_map<Connection::Handler::Type, std::thread> m_msg_threads;       
 
            void                                                                            DisconnectAllClients() noexcept;
 
            void                                                                            AcceptClients() noexcept;
 
            void                                                                            StartClientCommunication(Socket::Client& client) noexcept;
 
            void                                                                            HandleClientMessages(Socket::Client& client) noexcept;
 
            ExpectedVoid                                                                    SendClientReply(Socket::Client& client, FutureBuffer& message) noexcept;
 
            ExpectedFutureBuffer                                                            ProcessInputMessagePipeline(Socket::Client& client, FutureBuffer& message) noexcept;
 
            ExpectedFutureBuffer                                                            ProcessOutputMessagePipeline(Socket::Client& client, FutureBuffer& message) noexcept;
    };
}