aswi2021virtual-surreality-gitlab/deltarobot/curvedataserver.h @ 285c6fe5

#ifndef CURVEDATASERVER_H
#define CURVEDATASERVER_H

#include <QObject>
#include <QTcpServer>
#include <QTcpSocket>
#include <map>
#include <mutex>
#include <thread>

class CurveDataServer : QObject
{
    Q_OBJECT

public:
    struct Client {
        /**
         * Size of the client buffer.
         *
         * @note Current implementation truncates any variable-length messages longer than what would fit in the buffer.
         */
        static const size_t BUF_SIZE = 4096;

        static const size_t MESSAGE_ID_SIZE = sizeof(uint16_t);      ///< Size of the protocol message identifier.
        static const size_t MESSAGE_LENGTH_SIZE = sizeof(uint32_t);  ///< Size of the variable-length message's content length.

        QTcpSocket* socket;
        std::map<uint64_t, uint64_t> ping;  ///< key: ping ID;  value: ping timestamp (msec);
        uint64_t latency;               ///< client's latency
        uint64_t lastPong;              ///< timestamp of last pong

        char buf[BUF_SIZE];
        size_t bufUsed;

        bool magic = false;
        bool version = false;
        bool initialized = false;

        Client(QTcpSocket* socket);
    };

    explicit CurveDataServer();
    ~CurveDataServer();

    void sendActuatorPosition(float x, float y, float z);
    void sendActualDirection(float x, float y, float z);
    void sendTargetDirection(float x, float y, float z);
    void sendNewCurve(QList<QVector4D> &points);
    void sendNewCurve(QList<QVector3D> &points);
    void sendCurve(Client &client);

    void processPings();            ///< send pings, check timeouts

public slots:
    void onNewConnection();
    void onSocketStateChanged(QAbstractSocket::SocketState socketState);
    void onReadyRead();

private:
    QList<Client>::iterator clientOf(QTcpSocket *socket);

    void handleMessage(Client& client, uint16_t messageId, void* content, size_t contentSize);
    void handleProtocolMagic(Client& client, char* content);
    void handleVersion(Client& client, uint8_t content);
    void handlePong(Client& client, uint64_t* content);
    void handleEOT(Client& client, char* content, size_t contentSize);

    void validPreamble(Client& client);
    void removeSocket(QTcpSocket *socket);
    void terminateConnection(Client& client, std::string&& reason);
    void sendPing(Client& client);

    void sendPreamble(QTcpSocket *socket);
    void sendProtocolMagic(QTcpSocket *socket);
    void sendVersion(QTcpSocket *socket);
    void sendEot(QTcpSocket *socket, std::string&& message);

    void sendMessageToAllConnected(QByteArray &message);

    void threadFunction();

    QTcpServer _server;
    std::thread _pingThread;

    volatile bool _threadIsRunning = true;

    std::recursive_mutex _socketsLock;
    QList<Client> _sockets;

    std::recursive_mutex _currentCurveLock;
    QList<QVector3D> _currentCurve;
};

#endif // CURVEDATASERVER_H