server.hpp

#pragma once
#ifdef StevEngine_NETWORKING
#include "networking.hpp"
#include "utilities/ID.hpp"
 
#include <functional>
#include <unordered_set>

 
namespace StevEngine::Networking::Server {
    class Client {
        friend class Manager;
        public:
            const Utilities::ID id;

            const Socket tcp;

            const sockaddr_in address;

            bool operator== (const Client& client) const;
        private:
            Client(const Utilities::ID& id, const Socket& tcp, const sockaddr_in& address);

            mutable float sinceLastPing = 0;
    };
}

template<> struct std::hash<StevEngine::Networking::Server::Client> {
    std::size_t operator()(const StevEngine::Networking::Server::Client& k) const {
        size_t result = 0;
        return std::hash<StevEngine::Utilities::ID>()(k.id);
    }
};
 
namespace StevEngine::Networking::Server {

    using MessageFunction = std::function<void(const Client& client, MessageData message)>;

    class Manager {
        private:
            class MessageHandler {
                public:
                    MessageHandler(const MessageFunction& function);

                    MessageHandler(const MessageHandler& copy);

                    void operator= (const MessageHandler& copy);

                    void operator() (const Client& client, MessageData message) const;

                    bool operator== (const MessageHandler& other) const;

                    Utilities::ID getId() const { return id; }
                private:
                    MessageFunction function;  
                    Utilities::ID id;          
            };
        public:
            Manager(int port, bool ipv4 = true);

            ~Manager();

            void send(const Message& message, bool reliable = true) const;

            void send(const MessageID& id, MessageData data = MessageData(), bool reliable = true) const;

            void send(const Client& to, const Message& message, bool reliable = true) const;

            void send(const Client& to, const MessageID& id, MessageData data = MessageData(), bool reliable = true) const;

            void send(const Utilities::ID& clientId, const Message& message, bool reliable = true) const;

            void send(const Utilities::ID& clientId, const MessageID& id, MessageData data = MessageData(), bool reliable = true) const;

            Utilities::ID listen(MessageID id, MessageFunction function);

            void unlisten(MessageID id, const Utilities::ID handler);

            const std::unordered_set<Client>& getClients() const { return clients; };
 
        private:
            Socket tcp, udp;              
            sockaddr_in serverAddress;  

            std::unordered_map<MessageID, std::vector<MessageHandler>> subscribers;

            std::unordered_set<Client> clients;
            std::unordered_map<Utilities::ID, Socket> TCPConnections;

            std::unordered_set<Client> disconnected;
 
            fd_set readfds;             

            void acceptTCPConnections();
            void connectConnections();

            void recieveReliableMessages();
            void recieveUnreliableMessages();

            void recieve(const Client& from, const Message& message);
    };
}
 
#endif