WebSocketProtocol.h

#pragma once
 
#include <chrono>
#include <functional>
#include <map>
#include <optional>
#include <string>
 
#include <nlohmann/json.hpp>
 
namespace net {
namespace websocket {
 
using nlohmann::json;
 
typedef std::function<void(const json&)> msghandler_t;
typedef std::function<bool(const json&)> validator_t;
typedef std::function<void()> connhandler_t;
typedef std::function<void()> heartbeattimeouthandler_t;

class WebSocketProtocol {
public:
    WebSocketProtocol(const std::string& protocolPath);
 
    virtual ~WebSocketProtocol() = default;

    bool addMessageHandler(const std::string& messageType, const msghandler_t& callback);

    bool addMessageHandler(const std::string& messageType, const msghandler_t& callback,
                           const validator_t& validator);

    bool removeMessageHandler(const std::string& messageType);

    bool hasMessageHandler(const std::string& messageType) const;
 
    void addConnectionHandler(const connhandler_t& handler);
 
    void addDisconnectionHandler(const connhandler_t& handler);

    void setHeartbeatTimedOutHandler(std::chrono::milliseconds timeout,
                                     const heartbeattimeouthandler_t& handler);

    std::string getProtocolPath() const;
 
private:
    friend class SingleClientWSServer;
 
    std::string protocolPath;
    std::map<std::string, msghandler_t> handlerMap;
    std::map<std::string, validator_t> validatorMap;
    std::vector<connhandler_t> connectionHandlers;
    std::vector<connhandler_t> disconnectionHandlers;
    std::optional<std::pair<std::chrono::milliseconds, heartbeattimeouthandler_t>>
        heartbeatInfo;

    void processMessage(const json& obj) const;

    void clientConnected();

    void clientDisconnected();

    void heartbeatTimedOut();
};
 
} // namespace websocket
} // namespace net