Formats minimally release source files based on former clang-format

This commit is contained in:
torsten committed 2026-10-14 13:28:01 +00:00
1 parent b662e4daf9
commit 5644914fe3
387 files changed
+37323 -38074

No files matched your search

@@ -10,80 +10,80 @@
namespace LtsWebSocket
{
ClientConnection::ClientConnection(QWebSocket* socket, QObject* parent)
: QThread(parent), m_logger(getLogger("LtsWebSocket.ClientConnection")), m_socket(socket ? socket : new QWebSocket)
{
}
ClientConnection::ClientConnection(QWebSocket *socket, QObject *parent)
: QThread(parent)
, m_logger(getLogger("LtsWebSocket.ClientConnection"))
, m_socket(socket ? socket : new QWebSocket)
{
}
ClientConnection::~ClientConnection()
{
ClientConnection::~ClientConnection()
{
DEBUG_LOG(m_logger) << "Thread closed" << this;
delete m_socket;
qDeleteAll(m_messageQueue);
}
}
#ifdef QT6_WEBSOCKETS_AVAILABLE
bool ClientConnection::init()
{
bool ClientConnection::init()
{
if (m_socket == nullptr)
{
ERROR_LOG(m_logger) << "Initialisation failed due to an invalid socket";
return false;
ERROR_LOG(m_logger) << "Initialisation failed due to an invalid socket";
return false;
}
DEBUG_LOG(m_logger) << "Started new thread" << this;
connect(m_socket, &QWebSocket::textMessageReceived, this, &ClientConnection::onNewTextMessageFromSocket,
Qt::DirectConnection);
connect(m_socket, &QWebSocket::textMessageReceived, this, &ClientConnection::onNewTextMessageFromSocket, Qt::DirectConnection);
connect(m_socket, &QWebSocket::connected, this, &ClientConnection::sendMessagesFromQueue);
connect(m_socket, &QWebSocket::disconnected, this, &ClientConnection::onSocketDisconnect);
return true;
}
}
void ClientConnection::addReply(ReplyMessage* message)
{
void ClientConnection::addReply(ReplyMessage *message)
{
if (!m_socket || m_socket->state() != QAbstractSocket::ConnectedState)
{
m_messageQueue.enqueue(message);
DEBUG_LOG(m_logger) << "Adding message to queue, size: " << m_messageQueue.size();
return;
m_messageQueue.enqueue(message);
DEBUG_LOG(m_logger) << "Adding message to queue, size: " << m_messageQueue.size();
return;
}
const QString msg(message->toJsonString());
DEBUG_LOG(m_logger) << "Sending message: " << msg;
m_socket->sendTextMessage(msg);
delete message;
}
}
void ClientConnection::onNewTextMessageFromSocket(const QString& message)
{
void ClientConnection::onNewTextMessageFromSocket(const QString &message)
{
DEBUG_LOG(m_logger) << "Recv msg: " << message << this;
emit newTextMessage(this, message);
}
}
void ClientConnection::sendMessagesFromQueue()
{
void ClientConnection::sendMessagesFromQueue()
{
INFO_LOG(m_logger) << "Client connected ip: " << m_socket->peerAddress().toString() << ":" << m_socket->peerPort();
if (m_socket->state() != QAbstractSocket::ConnectedState)
return;
return;
while (!m_messageQueue.isEmpty())
{
ReplyMessage* message = m_messageQueue.dequeue();
const QString msg(message->toJsonString());
TRACE_LOG(m_logger) << "Send msg: " << msg;
m_socket->sendTextMessage(msg);
delete message;
DEBUG_LOG(m_logger) << "Sent message from queue, new size: " << m_messageQueue.size();
ReplyMessage *message = m_messageQueue.dequeue();
const QString msg(message->toJsonString());
TRACE_LOG(m_logger) << "Send msg: " << msg;
m_socket->sendTextMessage(msg);
delete message;
DEBUG_LOG(m_logger) << "Sent message from queue, new size: " << m_messageQueue.size();
}
}
}
void ClientConnection::onSocketDisconnect()
{
DEBUG_LOG(m_logger) << "Client disconnected ip: " << m_socket->peerAddress().toString() << ":"
<< m_socket->peerPort();
void ClientConnection::onSocketDisconnect()
{
DEBUG_LOG(m_logger) << "Client disconnected ip: " << m_socket->peerAddress().toString() << ":" << m_socket->peerPort();
exit(0);
emit disconnected(this);
}
}
#endif
} // namespace LtsWebSocket
@@ -12,68 +12,70 @@
#ifdef QT6_WEBSOCKETS_AVAILABLE
class QWebSocket;
#else
namespace LtsWebSocket { class QWebSocketStub; }
namespace LtsWebSocket
{
class QWebSocketStub;
}
using QWebSocket = LtsWebSocket::QWebSocketStub;
namespace LtsWebSocket
{
class QWebSocketStub
{
class QWebSocketStub
{
public:
QWebSocketStub(QObject* parent = nullptr) { Q_UNUSED(parent); }
QWebSocketStub(QObject *parent = nullptr) { Q_UNUSED(parent); }
virtual ~QWebSocketStub() = default;
void sendTextMessage(const QString& /*message*/) {}
void sendTextMessage(const QString & /*message*/) {}
void close() {}
bool isValid() const { return false; }
QString errorString() const { return QString(); }
};
};
} // namespace LtsWebSocket
#endif
namespace LtsWebSocket
{
class LTSWEBSOCKETSERVER_EXPORT ClientConnection : public QThread, public ReplyHandler
{
class LTSWEBSOCKETSERVER_EXPORT ClientConnection
: public QThread
, public ReplyHandler
{
Q_OBJECT
public:
explicit ClientConnection(QWebSocket* socket, QObject* parent = nullptr);
explicit ClientConnection(QWebSocket *socket, QObject *parent = nullptr);
~ClientConnection();
#ifdef QT6_WEBSOCKETS_AVAILABLE
bool init();
void addReply(ReplyMessage* message) override;
void addReply(ReplyMessage *message) override;
QWebSocket* webSocket()
{
return m_socket;
}
QWebSocket *webSocket() { return m_socket; }
#else
bool init() { return false; }
void addReply(ReplyMessage* /*message*/) override {}
QWebSocket* webSocket() { return nullptr; }
void addReply(ReplyMessage * /*message*/) override {}
QWebSocket *webSocket() { return nullptr; }
#endif
signals:
void newTextMessage(ClientConnection* client, const QString& message);
void newTextMessage(ClientConnection *client, const QString &message);
void disconnected(ClientConnection* client);
void disconnected(ClientConnection *client);
private slots:
#ifdef QT6_WEBSOCKETS_AVAILABLE
void onNewTextMessageFromSocket(const QString& message);
void onNewTextMessageFromSocket(const QString &message);
void sendMessagesFromQueue();
void onSocketDisconnect();
#endif
private:
NGL::INGLLogger& m_logger;
NGL::INGLLogger &m_logger;
#ifdef QT6_WEBSOCKETS_AVAILABLE
void sendMessages();
#endif
QWebSocket* m_socket;
QQueue<ReplyMessage*> m_messageQueue;
};
QWebSocket *m_socket;
QQueue<ReplyMessage *> m_messageQueue;
};
} // namespace LtsWebSocket
@@ -9,13 +9,14 @@
namespace LtsWebSocket
{
InvalidMessage::InvalidMessage(ReplyHandler* client, const QString& uuid, const QString& errorText)
: AbstractClientMessage(client, QString(), 1, uuid), m_errorText(errorText)
{
}
InvalidMessage::InvalidMessage(ReplyHandler *client, const QString &uuid, const QString &errorText)
: AbstractClientMessage(client, QString(), 1, uuid)
, m_errorText(errorText)
{
}
void InvalidMessage::process()
{
void InvalidMessage::process()
{
ErrorMessage::ErrorData errorData;
errorData.errorClass = 1;
@@ -23,12 +24,12 @@ void InvalidMessage::process()
errorData.uuid = m_uuid;
m_client->addReply(new ErrorMessage(errorData));
}
}
bool InvalidMessage::hasValidData() const
{
bool InvalidMessage::hasValidData() const
{
return true;
}
}
} // namespace LtsWebSocket
@@ -11,12 +11,15 @@
namespace LtsWebSocket
{
class LTSWEBSOCKETCOMMON_EXPORT AbstractClientMessage
{
class LTSWEBSOCKETCOMMON_EXPORT AbstractClientMessage
{
public:
AbstractClientMessage(ReplyHandler* client, const QString& type, const int typeId, const QString& uuid,
const QJsonValue& data = QJsonValue())
: m_type(type), m_typeId(typeId), m_uuid(uuid), m_data(data), m_client(client)
AbstractClientMessage(ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data = QJsonValue())
: m_type(type)
, m_typeId(typeId)
, m_uuid(uuid)
, m_data(data)
, m_client(client)
{
}
@@ -26,29 +29,26 @@ class LTSWEBSOCKETCOMMON_EXPORT AbstractClientMessage
virtual bool hasValidData() const = 0;
void reply(ReplyMessage* reply)
{
m_client->addReply(reply);
}
void reply(ReplyMessage *reply) { m_client->addReply(reply); }
protected:
const QString m_type;
const int m_typeId;
const QString m_uuid;
const QJsonValue m_data;
ReplyHandler* m_client;
};
ReplyHandler *m_client;
};
class LTSWEBSOCKETCOMMON_EXPORT InvalidMessage final : public AbstractClientMessage
{
class LTSWEBSOCKETCOMMON_EXPORT InvalidMessage final : public AbstractClientMessage
{
public:
explicit InvalidMessage(ReplyHandler* client, const QString& uuid, const QString& errorText);
explicit InvalidMessage(ReplyHandler *client, const QString &uuid, const QString &errorText);
void process() override;
bool hasValidData() const override;
private:
QString m_errorText;
};
};
} // namespace LtsWebSocket
@@ -10,13 +10,13 @@
namespace LtsWebSocket
{
QJsonParseError AbstractClientMessageFactory::parseMessage(const QString& message)
{
QJsonParseError AbstractClientMessageFactory::parseMessage(const QString &message)
{
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(message.toUtf8(), &error);
if (error.error != QJsonParseError::NoError)
return error;
return error;
QJsonObject obj = doc.object();
@@ -26,38 +26,37 @@ QJsonParseError AbstractClientMessageFactory::parseMessage(const QString& messag
m_uuid = obj.value(JsonKeys::UUID_()).toString();
return error;
}
}
AbstractClientMessage* AbstractClientMessageFactory::checkAttributes(ReplyHandler* client, const QString& message) const
{
AbstractClientMessage *AbstractClientMessageFactory::checkAttributes(ReplyHandler *client, const QString &message) const
{
if (!m_uuid.isEmpty() && !m_type.isEmpty())
return nullptr;
return nullptr;
if (m_uuid.isEmpty())
{
WARNING_LOG(m_logger) << "Got message without uuid: " << message << "'";
return new LtsWebSocket::InvalidMessage(client, QString(), QStringLiteral("Got message without uuid"));
WARNING_LOG(m_logger) << "Got message without uuid: " << message << "'";
return new LtsWebSocket::InvalidMessage(client, QString(), QStringLiteral("Got message without uuid"));
}
WARNING_LOG(m_logger) << "Got message no type: " << message << "'";
return new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Message has no type"));
}
}
AbstractClientMessage* AbstractClientMessageFactory::checkResult(ReplyHandler* client, const QString& message,
AbstractClientMessage* result) const
{
AbstractClientMessage *AbstractClientMessageFactory::checkResult(ReplyHandler *client, const QString &message, AbstractClientMessage *result) const
{
if (result == nullptr)
{
WARNING_LOG(m_logger) << "Could not parse message: " << message;
result = new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Invalid type"));
WARNING_LOG(m_logger) << "Could not parse message: " << message;
result = new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Invalid type"));
}
if (!result->hasValidData())
{
WARNING_LOG(m_logger) << "Resulting JSon message has invalid data... " << message;
delete result;
result = new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Has invalid data part"));
WARNING_LOG(m_logger) << "Resulting JSon message has invalid data... " << message;
delete result;
result = new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Has invalid data part"));
}
return result;
}
}
} // namespace LtsWebSocket
@@ -11,58 +11,55 @@
namespace NGL
{
class INGLLogger;
class INGLLogger;
}
namespace LtsWebSocket
{
class LTSWEBSOCKETCOMMON_EXPORT AbstractClientMessageFactory
{
class LTSWEBSOCKETCOMMON_EXPORT AbstractClientMessageFactory
{
public:
explicit AbstractClientMessageFactory(NGL::INGLLogger& logger) : m_logger(logger) {}
explicit AbstractClientMessageFactory(NGL::INGLLogger &logger)
: m_logger(logger)
{
}
virtual ~AbstractClientMessageFactory() {}
QJsonParseError parseMessage(const QString& message);
QJsonParseError parseMessage(const QString &message);
virtual AbstractClientMessage* createMessage(ReplyHandler* client, const QString& message) = 0;
virtual AbstractClientMessage *createMessage(ReplyHandler *client, const QString &message) = 0;
protected:
AbstractClientMessage* checkAttributes(ReplyHandler* client, const QString& message) const;
AbstractClientMessage* checkResult(ReplyHandler* client, const QString& message,
AbstractClientMessage* result) const;
AbstractClientMessage *checkAttributes(ReplyHandler *client, const QString &message) const;
AbstractClientMessage *checkResult(ReplyHandler *client, const QString &message, AbstractClientMessage *result) const;
protected:
NGL::INGLLogger& m_logger;
NGL::INGLLogger &m_logger;
QString m_type;
int m_typeId;
QString m_uuid;
QJsonValue m_data;
};
};
class PongMessage final : public ReplyMessage
{
class PongMessage final : public ReplyMessage
{
public:
static QString strPong()
static QString strPong() { return QStringLiteral("pong"); }
static int idPong() { return 2; }
explicit PongMessage(const QString &payload)
: ReplyMessage(strPong(), idPong(), QString())
, m_payload(payload)
{
return QStringLiteral("pong");
}
static int idPong()
{
return 2;
}
explicit PongMessage(const QString& payload) : ReplyMessage(strPong(), idPong(), QString()), m_payload(payload) {}
QString toJsonString() const override
{
return m_payload.isEmpty() ? strPong() : QStringLiteral("%1 %2").arg(strPong(), m_payload);
}
QString toJsonString() const override { return m_payload.isEmpty() ? strPong() : QStringLiteral("%1 %2").arg(strPong(), m_payload); }
private:
QString m_payload;
};
};
} // namespace LtsWebSocket
@@ -12,84 +12,84 @@
using namespace LtsWebSocket;
ConnectionHandler::ConnectionHandler(QObject* parent)
: QObject(parent), m_logger(getLogger("LtsWebSocket.ConnectionHandler")), m_server(nullptr)
ConnectionHandler::ConnectionHandler(QObject *parent)
: QObject(parent)
, m_logger(getLogger("LtsWebSocket.ConnectionHandler"))
, m_server(nullptr)
{
}
ConnectionHandler::~ConnectionHandler()
{
#ifdef QT6_WEBSOCKETS_AVAILABLE
for (auto connection : std::as_const(m_connections))
connection->disconnect(this);
for (auto connection : std::as_const(m_connections))
connection->disconnect(this);
#endif
}
#ifdef QT6_WEBSOCKETS_AVAILABLE
bool ConnectionHandler::init(const QString& serviceName, unsigned short port)
bool ConnectionHandler::init(const QString &serviceName, unsigned short port)
{
if (m_server != nullptr)
{
m_server->disconnect();
delete m_server;
}
if (m_server != nullptr)
{
m_server->disconnect();
delete m_server;
}
m_server = new QWebSocketServer(QStringLiteral("RME-") + serviceName, QWebSocketServer::NonSecureMode, this);
m_server = new QWebSocketServer(QStringLiteral("RME-") + serviceName, QWebSocketServer::NonSecureMode, this);
connect(m_server, &QWebSocketServer::newConnection, this, &ConnectionHandler::onNewConnection);
connect(m_server, &QWebSocketServer::serverError, this, &ConnectionHandler::onServerError);
connect(m_server, &QWebSocketServer::newConnection, this, &ConnectionHandler::onNewConnection);
connect(m_server, &QWebSocketServer::serverError, this, &ConnectionHandler::onServerError);
DEBUG_LOG(m_logger) << "Trying to listen ";
if (!m_server->listen(QHostAddress::Any, port))
{
ERROR_LOG(m_logger) << "Not possible to listen to port " << port;
return false;
}
DEBUG_LOG(m_logger) << "... ok, port " << m_server->serverPort();
DEBUG_LOG(m_logger) << "Trying to listen ";
if (!m_server->listen(QHostAddress::Any, port))
{
ERROR_LOG(m_logger) << "Not possible to listen to port " << port;
return false;
}
DEBUG_LOG(m_logger) << "... ok, port " << m_server->serverPort();
return true;
return true;
}
void ConnectionHandler::sendToAllClients(ReplyMessage* message)
void ConnectionHandler::sendToAllClients(ReplyMessage *message)
{
for (auto connection : std::as_const(m_connections))
connection->addReply(new ReplyMessage(*message));
for (auto connection : std::as_const(m_connections))
connection->addReply(new ReplyMessage(*message));
delete message;
delete message;
}
void ConnectionHandler::onServerError(QWebSocketProtocol::CloseCode closeCode)
{
ERROR_LOG(m_logger) << "Got server error with close code " << closeCode;
ERROR_LOG(m_logger) << "Got server error with close code " << closeCode;
}
void ConnectionHandler::onNewConnection()
{
while (m_server->hasPendingConnections())
while (m_server->hasPendingConnections())
{
QWebSocket *socket = m_server->nextPendingConnection();
ClientConnection *newConnection = new ClientConnection(socket, this);
connect(newConnection, &ClientConnection::destroyed, this, [this](QObject *o) { m_connections.remove(static_cast<ClientConnection *>(o)); });
if (!newConnection->init())
{
QWebSocket* socket = m_server->nextPendingConnection();
ClientConnection* newConnection = new ClientConnection(socket, this);
connect(newConnection, &ClientConnection::destroyed, this,
[this](QObject* o) { m_connections.remove(static_cast<ClientConnection*>(o)); });
if (!newConnection->init())
{
ERROR_LOG(m_logger) << "Failed to initialise new client";
delete newConnection;
newConnection = nullptr;
continue;
}
newConnection->start();
connect(newConnection, &ClientConnection::newTextMessage, this, &ConnectionHandler::newTextMessageFromClient);
connect(newConnection, &ClientConnection::disconnected, this, &ConnectionHandler::clientDisconnected);
connect(newConnection, &ClientConnection::finished, newConnection, &ClientConnection::deleteLater);
m_connections.insert(newConnection);
emit clientConnected(newConnection);
INFO_LOG(m_logger) << "New client connected ip: " << socket->localAddress().toString() << ":"
<< socket->localPort();
ERROR_LOG(m_logger) << "Failed to initialise new client";
delete newConnection;
newConnection = nullptr;
continue;
}
newConnection->start();
connect(newConnection, &ClientConnection::newTextMessage, this, &ConnectionHandler::newTextMessageFromClient);
connect(newConnection, &ClientConnection::disconnected, this, &ConnectionHandler::clientDisconnected);
connect(newConnection, &ClientConnection::finished, newConnection, &ClientConnection::deleteLater);
m_connections.insert(newConnection);
emit clientConnected(newConnection);
INFO_LOG(m_logger) << "New client connected ip: " << socket->localAddress().toString() << ":" << socket->localPort();
}
}
#endif
@@ -11,46 +11,52 @@
#include <QtWebSockets/QWebSocketServer>
#include <QtWebSockets/qwebsocketprotocol.h>
#else
namespace LtsWebSocket { class QWebSocketServerStub; }
namespace LtsWebSocket
{
class QWebSocketServerStub;
}
using QWebSocketServer = LtsWebSocket::QWebSocketServerStub;
namespace QWebSocketProtocol { enum class CloseCode { NormalClosure = 1000 }; }
namespace QWebSocketProtocol
{
enum class CloseCode
{
NormalClosure = 1000
};
}
#endif
namespace LtsWebSocket
{
class MessageHandler;
class ClientConnection;
class ReplyMessage;
class MessageHandler;
class ClientConnection;
class ReplyMessage;
class ConnectionHandler : public QObject
{
class ConnectionHandler : public QObject
{
Q_OBJECT
public:
explicit ConnectionHandler(QObject* parent = nullptr);
explicit ConnectionHandler(QObject *parent = nullptr);
~ConnectionHandler();
#ifdef QT6_WEBSOCKETS_AVAILABLE
bool init(const QString& serviceName, unsigned short port);
bool init(const QString &serviceName, unsigned short port);
void sendToAllClients(ReplyMessage* message);
void sendToAllClients(ReplyMessage *message);
unsigned short webSocketPort()
{
return m_server->serverPort();
}
unsigned short webSocketPort() { return m_server->serverPort(); }
#else
bool init(const QString& /*serviceName*/, unsigned short /*port*/) { return false; }
void sendToAllClients(ReplyMessage* /*message*/) {}
bool init(const QString & /*serviceName*/, unsigned short /*port*/) { return false; }
void sendToAllClients(ReplyMessage * /*message*/) {}
unsigned short webSocketPort() { return 0; }
#endif
signals:
void newTextMessageFromClient(ClientConnection* client, const QString& message);
void newTextMessageFromClient(ClientConnection *client, const QString &message);
void clientDisconnected(ClientConnection* client);
void clientDisconnected(ClientConnection *client);
void clientConnected(ClientConnection* client);
void clientConnected(ClientConnection *client);
private slots:
#ifdef QT6_WEBSOCKETS_AVAILABLE
@@ -59,12 +65,12 @@ class ConnectionHandler : public QObject
#endif
private:
NGL::INGLLogger& m_logger;
NGL::INGLLogger &m_logger;
#ifdef QT6_WEBSOCKETS_AVAILABLE
QWebSocketServer* m_server;
QWebSocketServer *m_server;
#else
void* m_server;
void *m_server;
#endif
QSet<ClientConnection*> m_connections;
};
QSet<ClientConnection *> m_connections;
};
} // namespace LtsWebSocket
@@ -9,33 +9,34 @@
namespace LtsWebSocket
{
template <typename T> class DataManagerBaseDl
{
template <typename T> class DataManagerBaseDl
{
protected:
explicit DataManagerBaseDl(const std::shared_ptr<T>& dbInterface, NGL::INGLLogger& logger)
: m_logger(logger), m_dbInterface(dbInterface)
explicit DataManagerBaseDl(const std::shared_ptr<T> &dbInterface, NGL::INGLLogger &logger)
: m_logger(logger)
, m_dbInterface(dbInterface)
{
}
template <typename DbType, typename MessageType> ReplyMessage* toBaseDataMessageFromDb(const QString& uuid) const
template <typename DbType, typename MessageType> ReplyMessage *toBaseDataMessageFromDb(const QString &uuid) const
{
QVector<DbType> dataVec;
QVector<DbType> dataVec;
if (!m_dbInterface->select(dataVec))
{
const QString errorMessage = QStringLiteral("Error reading data from database!");
ERROR_LOG(m_logger) << errorMessage;
ErrorMessage::ErrorData errData;
errData.errorMessage = errorMessage;
errData.uuid = uuid;
return new ErrorMessage(errData);
}
if (!m_dbInterface->select(dataVec))
{
const QString errorMessage = QStringLiteral("Error reading data from database!");
ERROR_LOG(m_logger) << errorMessage;
ErrorMessage::ErrorData errData;
errData.errorMessage = errorMessage;
errData.uuid = uuid;
return new ErrorMessage(errData);
}
return new MessageType(m_dbInterface->template toJson<DbType>(dataVec), uuid);
return new MessageType(m_dbInterface->template toJson<DbType>(dataVec), uuid);
}
protected:
NGL::INGLLogger &m_logger;
std::shared_ptr<T> m_dbInterface;
};
};
} // namespace LtsWebSocket
@@ -7,42 +7,42 @@
namespace LtsWebSocket
{
namespace JsonKeys
{
namespace JsonKeys
{
inline QString DATA()
{
return QStringLiteral("data");
}
inline QString DATA()
{
return QStringLiteral("data");
}
inline QString UUID_()
{
return QStringLiteral("uuid");
}
inline QString UUID_()
{
return QStringLiteral("uuid");
}
inline QString TYPE()
{
return QStringLiteral("type");
}
inline QString TYPE()
{
return QStringLiteral("type");
}
inline QString TYPEID()
{
return QStringLiteral("typeId");
}
inline QString TYPEID()
{
return QStringLiteral("typeId");
}
inline QString ERROR_()
{
return QStringLiteral("error");
}
inline QString ERROR_()
{
return QStringLiteral("error");
}
inline QString ERROR_MESSAGE()
{
return QStringLiteral("errorMessage");
}
inline QString ERROR_MESSAGE()
{
return QStringLiteral("errorMessage");
}
inline QString ERROR_CLASS()
{
return QStringLiteral("errorClass");
}
} // namespace JsonKeys
inline QString ERROR_CLASS()
{
return QStringLiteral("errorClass");
}
} // namespace JsonKeys
} // namespace LtsWebSocket
@@ -7,8 +7,8 @@
namespace LtsWebSocket
{
LOGGER_T getLogger(const char* name)
{
LOGGER_T getLogger(const char *name)
{
static const char ns[] = "Lts.WebSocket.";
std::string loggerName;
const size_t len = strlen(name);
@@ -18,13 +18,13 @@ LOGGER_T getLogger(const char* name)
try
{
return NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger(loggerName);
return NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger(loggerName);
}
catch (const std::exception& ex)
catch (const std::exception &ex)
{
fprintf(stderr, "Error retrieving logger: %s", ex.what());
abort();
fprintf(stderr, "Error retrieving logger: %s", ex.what());
abort();
}
}
}
} // namespace LtsWebSocket
@@ -8,12 +8,12 @@
namespace LtsWebSocket
{
typedef NGL::INGLLogger& LOGGER_T;
typedef NGL::INGLLogger &LOGGER_T;
LTSWEBSOCKETCOMMON_EXPORT LOGGER_T getLogger(const char* name);
LTSWEBSOCKETCOMMON_EXPORT LOGGER_T getLogger(const char *name);
inline LOGGER_T getLogger(const QString& loggerName)
{
inline LOGGER_T getLogger(const QString &loggerName)
{
return getLogger(loggerName.toUtf8().constData());
}
}
} // namespace LtsWebSocket
@@ -10,138 +10,137 @@
namespace LtsWebSocket
{
class WebSocketHelper : public QObject
{
class WebSocketHelper : public QObject
{
Q_OBJECT
public:
WebSocketHelper(AbstractClientMessageFactory* messageFactory, LtsWebSocketClient* webSocketClient,
NGL::INGLLogger& logger);
WebSocketHelper(AbstractClientMessageFactory *messageFactory, LtsWebSocketClient *webSocketClient, NGL::INGLLogger &logger);
~WebSocketHelper();
public Q_SLOTS:
void doOpen(const QString& hostname, const unsigned short port);
void doOpen(const QString &hostname, const unsigned short port);
void doClose();
void doSendTextMessage(const QString& msg);
void doSendTextMessage(const QString &msg);
void onConnected();
void onDisconnected();
void onError(QAbstractSocket::SocketError error);
void parseMessage(const QString& message);
void parseMessage(const QString &message);
Q_SIGNALS:
void messageParsed(AbstractClientMessage* clientMessage);
void messageParsed(AbstractClientMessage *clientMessage);
void connected();
void disconnected();
void dataReceived();
void error(QAbstractSocket::SocketError);
private:
AbstractClientMessageFactory* m_messageFactory;
LtsWebSocketClient* m_webSocketClient;
QWebSocket* m_socket;
NGL::INGLLogger& m_logger;
};
AbstractClientMessageFactory *m_messageFactory;
LtsWebSocketClient *m_webSocketClient;
QWebSocket *m_socket;
NGL::INGLLogger &m_logger;
};
WebSocketHelper::WebSocketHelper(AbstractClientMessageFactory* messageFactory, LtsWebSocketClient* webSocketClient,
NGL::INGLLogger& logger)
: QObject(), m_messageFactory(messageFactory), m_webSocketClient(webSocketClient),
m_socket(new QWebSocket(QString(), QWebSocketProtocol::VersionLatest, this)), m_logger(logger)
{
WebSocketHelper::WebSocketHelper(AbstractClientMessageFactory *messageFactory, LtsWebSocketClient *webSocketClient, NGL::INGLLogger &logger)
: QObject()
, m_messageFactory(messageFactory)
, m_webSocketClient(webSocketClient)
, m_socket(new QWebSocket(QString(), QWebSocketProtocol::VersionLatest, this))
, m_logger(logger)
{
connect(m_socket, &QWebSocket::textMessageReceived, this, &WebSocketHelper::parseMessage);
connect(m_socket, &QWebSocket::textFrameReceived, this, &WebSocketHelper::dataReceived);
connect(m_socket, &QWebSocket::connected, this, &WebSocketHelper::onConnected);
connect(m_socket, &QWebSocket::disconnected, this, &WebSocketHelper::onDisconnected);
connect(m_socket, &QWebSocket::errorOccurred, this, &WebSocketHelper::error);
}
}
WebSocketHelper::~WebSocketHelper()
{
WebSocketHelper::~WebSocketHelper()
{
m_socket->close();
delete m_socket;
}
}
void WebSocketHelper::doOpen(const QString& hostname, const unsigned short port)
{
void WebSocketHelper::doOpen(const QString &hostname, const unsigned short port)
{
const QUrl url(QStringLiteral("ws://%1:%2/").arg(hostname).arg(port));
if (m_socket->state() == QAbstractSocket::SocketState::ConnectedState)
{
if (m_socket->requestUrl() != url)
doClose();
else
{
INFO_LOG(m_logger) << "Web socket to url: " << url.toDisplayString() << " is already open.";
return;
}
if (m_socket->requestUrl() != url)
doClose();
else
{
INFO_LOG(m_logger) << "Web socket to url: " << url.toDisplayString() << " is already open.";
return;
}
}
INFO_LOG(m_logger) << "Opening web socket to url: " << url.toDisplayString();
m_socket->open(url);
}
}
void WebSocketHelper::doClose()
{
void WebSocketHelper::doClose()
{
INFO_LOG(m_logger) << "Closing web socket to url:" << m_socket->requestUrl().toDisplayString();
m_socket->close();
}
}
void WebSocketHelper::doSendTextMessage(const QString& msg)
{
void WebSocketHelper::doSendTextMessage(const QString &msg)
{
if (!m_socket || m_socket->state() != QAbstractSocket::ConnectedState)
{
ERROR_LOG(m_logger) << "Message could not be send, socket is not connected.";
return;
ERROR_LOG(m_logger) << "Message could not be send, socket is not connected.";
return;
}
DEBUG_LOG(m_logger) << "Sending message: " << msg;
m_socket->sendTextMessage(msg);
}
}
void WebSocketHelper::onConnected()
{
INFO_LOG(m_logger) << "Connected to server url: " << m_socket->requestUrl().toDisplayString()
<< " using local port: " << m_socket->localPort();
void WebSocketHelper::onConnected()
{
INFO_LOG(m_logger) << "Connected to server url: " << m_socket->requestUrl().toDisplayString() << " using local port: " << m_socket->localPort();
emit connected();
}
}
void WebSocketHelper::onDisconnected()
{
void WebSocketHelper::onDisconnected()
{
INFO_LOG(m_logger) << "Disconnected from server url: " << m_socket->requestUrl().toDisplayString();
emit disconnected();
}
}
void WebSocketHelper::onError(QAbstractSocket::SocketError error)
{
void WebSocketHelper::onError(QAbstractSocket::SocketError error)
{
ERROR_LOG(m_logger) << "Error occured: " << error << " closing socket.";
m_socket->close();
}
}
void WebSocketHelper::parseMessage(const QString& message)
{
void WebSocketHelper::parseMessage(const QString &message)
{
const QString pingMsg(QStringLiteral("ping"));
if (message.startsWith(pingMsg))
{
doSendTextMessage(PongMessage(message.mid(pingMsg.size())).toJsonString());
return;
doSendTextMessage(PongMessage(message.mid(pingMsg.size())).toJsonString());
return;
}
AbstractClientMessage* clientMessage = nullptr;
AbstractClientMessage *clientMessage = nullptr;
auto result = m_messageFactory->parseMessage(message);
if (QJsonParseError::NoError == result.error)
clientMessage = m_messageFactory->createMessage(m_webSocketClient, message);
clientMessage = m_messageFactory->createMessage(m_webSocketClient, message);
else
{
WARNING_LOG(m_logger) << "Could not parse incoming message: '" << message
<< "', error: " << result.errorString();
clientMessage =
new InvalidMessage(m_webSocketClient, QString(),
QStringLiteral("Got message which is not JSON conform (%1)").arg(result.errorString()));
WARNING_LOG(m_logger) << "Could not parse incoming message: '" << message << "', error: " << result.errorString();
clientMessage = new InvalidMessage(m_webSocketClient, QString(), QStringLiteral("Got message which is not JSON conform (%1)").arg(result.errorString()));
}
if (clientMessage)
emit messageParsed(clientMessage);
}
emit messageParsed(clientMessage);
}
LtsWebSocketClient::LtsWebSocketClient(AbstractClientMessageFactory* messageFactory, QObject* parent)
: QObject(parent), m_logger(getLogger("LtsWebSocketClient")), m_messageFactory(messageFactory),
m_webSocketHelperThread(new QThread(this))
{
LtsWebSocketClient::LtsWebSocketClient(AbstractClientMessageFactory *messageFactory, QObject *parent)
: QObject(parent)
, m_logger(getLogger("LtsWebSocketClient"))
, m_messageFactory(messageFactory)
, m_webSocketHelperThread(new QThread(this))
{
m_webSocketHelper = new WebSocketHelper(m_messageFactory, this, m_logger);
m_webSocketHelper->moveToThread(m_webSocketHelperThread);
m_webSocketHelperThread->start();
@@ -154,40 +153,40 @@ LtsWebSocketClient::LtsWebSocketClient(AbstractClientMessageFactory* messageFact
connect(this, &LtsWebSocketClient::onOpen, m_webSocketHelper, &WebSocketHelper::doOpen);
connect(this, &LtsWebSocketClient::onClose, m_webSocketHelper, &WebSocketHelper::doClose);
connect(this, &LtsWebSocketClient::onSendTextMessage, m_webSocketHelper, &WebSocketHelper::doSendTextMessage);
}
}
LtsWebSocketClient::~LtsWebSocketClient()
{
LtsWebSocketClient::~LtsWebSocketClient()
{
m_webSocketHelper->disconnect(this);
m_webSocketHelperThread->quit();
m_webSocketHelperThread->wait();
delete m_webSocketHelper;
}
}
void LtsWebSocketClient::open(const QString& hostname, const unsigned short port)
{
void LtsWebSocketClient::open(const QString &hostname, const unsigned short port)
{
emit onOpen(hostname, port);
}
}
void LtsWebSocketClient::close()
{
void LtsWebSocketClient::close()
{
emit onClose();
}
}
void LtsWebSocketClient::addReply(ReplyMessage* message)
{
void LtsWebSocketClient::addReply(ReplyMessage *message)
{
const QString msg(message->toJsonString());
emit onSendTextMessage(msg);
delete message;
}
}
void LtsWebSocketClient::onNewClientMessage(AbstractClientMessage* clientMessage)
{
void LtsWebSocketClient::onNewClientMessage(AbstractClientMessage *clientMessage)
{
if (!clientMessage)
return;
return;
clientMessage->process();
delete clientMessage;
}
}
} // namespace LtsWebSocket
@@ -13,20 +13,22 @@ class QThread;
namespace LtsWebSocket
{
class WebSocketHelper;
class WebSocketHelper;
class LTSWEBSOCKETCLIENT_EXPORT LtsWebSocketClient : public QObject, public ReplyHandler
{
class LTSWEBSOCKETCLIENT_EXPORT LtsWebSocketClient
: public QObject
, public ReplyHandler
{
Q_OBJECT
public:
explicit LtsWebSocketClient(AbstractClientMessageFactory* messageFactory, QObject* parent = nullptr);
explicit LtsWebSocketClient(AbstractClientMessageFactory *messageFactory, QObject *parent = nullptr);
~LtsWebSocketClient();
void open(const QString& hostname, const unsigned short port);
void open(const QString &hostname, const unsigned short port);
void close();
void addReply(ReplyMessage* message) override;
void addReply(ReplyMessage *message) override;
signals:
void connected();
@@ -35,18 +37,18 @@ class LTSWEBSOCKETCLIENT_EXPORT LtsWebSocketClient : public QObject, public Repl
private slots:
void onNewClientMessage(AbstractClientMessage* clientMessage);
void onNewClientMessage(AbstractClientMessage *clientMessage);
signals:
void onOpen(const QString& hostname, const unsigned short port);
void onOpen(const QString &hostname, const unsigned short port);
void onClose();
void onSendTextMessage(const QString& msg);
void onSendTextMessage(const QString &msg);
private:
NGL::INGLLogger& m_logger;
AbstractClientMessageFactory* m_messageFactory;
NGL::INGLLogger &m_logger;
AbstractClientMessageFactory *m_messageFactory;
QThread* m_webSocketHelperThread;
WebSocketHelper* m_webSocketHelper;
};
QThread *m_webSocketHelperThread;
WebSocketHelper *m_webSocketHelper;
};
} // namespace LtsWebSocket
@@ -11,114 +11,112 @@
namespace LtsWebSocket
{
LtsWebSocketServer::LtsWebSocketServer(AbstractClientMessageFactory* messageFactory, QObject* parent)
: QObject(parent), m_queueTimer(new QTimer(this)), m_messageFactory(messageFactory), m_connectionHandler(nullptr),
m_logger(getLogger("LtsWebSocket.Server"))
{
LtsWebSocketServer::LtsWebSocketServer(AbstractClientMessageFactory *messageFactory, QObject *parent)
: QObject(parent)
, m_queueTimer(new QTimer(this))
, m_messageFactory(messageFactory)
, m_connectionHandler(nullptr)
, m_logger(getLogger("LtsWebSocket.Server"))
{
connect(m_queueTimer, &QTimer::timeout, this, &LtsWebSocketServer::onQueueTimerTimeout);
m_queueTimer->setSingleShot(true);
}
}
LtsWebSocketServer::~LtsWebSocketServer() = default;
LtsWebSocketServer::~LtsWebSocketServer() = default;
bool LtsWebSocketServer::init(const QString& serviceName, const unsigned short port)
{
bool LtsWebSocketServer::init(const QString &serviceName, const unsigned short port)
{
m_connectionHandler.reset(new ConnectionHandler(this));
if (!m_connectionHandler->init(serviceName, port))
{
ERROR_LOG(m_logger) << "Could not init m_connectionHandler with servicename: " << serviceName
<< ((port == 0) ? QStringLiteral(" random port")
: QStringLiteral(" port: ") + QString::number(port));
m_connectionHandler.reset();
return false;
ERROR_LOG(m_logger) << "Could not init m_connectionHandler with servicename: " << serviceName
<< ((port == 0) ? QStringLiteral(" random port") : QStringLiteral(" port: ") + QString::number(port));
m_connectionHandler.reset();
return false;
}
connect(m_connectionHandler.get(), &ConnectionHandler::newTextMessageFromClient, this,
&LtsWebSocketServer::onNewTextMessage);
connect(m_connectionHandler.get(), &ConnectionHandler::clientDisconnected, this,
&LtsWebSocketServer::clientDisconnected);
connect(m_connectionHandler.get(), &ConnectionHandler::newTextMessageFromClient, this, &LtsWebSocketServer::onNewTextMessage);
connect(m_connectionHandler.get(), &ConnectionHandler::clientDisconnected, this, &LtsWebSocketServer::clientDisconnected);
connect(m_connectionHandler.get(), &ConnectionHandler::clientConnected, this, &LtsWebSocketServer::clientConnected);
m_queueTimer->start(m_messageDelay);
return true;
}
}
bool LtsWebSocketServer::init(const QString& serviceName, const QPair<quint16, quint16>& portRange)
{
bool LtsWebSocketServer::init(const QString &serviceName, const QPair<quint16, quint16> &portRange)
{
if (portRange.first < 1025 || portRange.first > portRange.second)
return init(serviceName);
return init(serviceName);
for (quint16 currentPort = portRange.first; currentPort <= portRange.second; ++currentPort)
{
if (init(serviceName, currentPort))
return true;
if (init(serviceName, currentPort))
return true;
}
return init(serviceName);
}
}
void LtsWebSocketServer::sendToAllClients(ReplyMessage* message)
{
void LtsWebSocketServer::sendToAllClients(ReplyMessage *message)
{
DEBUG_LOG(m_logger) << "Sending message to all clients: " << message->toJsonString();
m_connectionHandler->sendToAllClients(message);
}
}
unsigned short LtsWebSocketServer::webSocketPort() const
{
unsigned short LtsWebSocketServer::webSocketPort() const
{
return m_connectionHandler->webSocketPort();
}
}
void LtsWebSocketServer::setMessageDelay(qint32 delay)
{
void LtsWebSocketServer::setMessageDelay(qint32 delay)
{
m_messageDelay = delay;
}
}
void LtsWebSocketServer::onNewTextMessage(ReplyHandler* client, const QString& message)
{
void LtsWebSocketServer::onNewTextMessage(ReplyHandler *client, const QString &message)
{
const QString pingMsg(QStringLiteral("ping"));
if (message.startsWith(pingMsg))
{
client->addReply(new PongMessage(message.mid(pingMsg.size())));
return;
client->addReply(new PongMessage(message.mid(pingMsg.size())));
return;
}
DEBUG_LOG(m_logger) << "Got new message: " << message;
m_messageQueue.append({client, message});
if (!m_queueTimer->isActive())
m_queueTimer->start(m_messageDelay);
}
m_queueTimer->start(m_messageDelay);
}
void LtsWebSocketServer::onQueueTimerTimeout()
{
void LtsWebSocketServer::onQueueTimerTimeout()
{
if (m_messageQueue.isEmpty())
return;
return;
MessageCredentials credentials = m_messageQueue.takeFirst();
AbstractClientMessage* clientMessage = nullptr;
AbstractClientMessage *clientMessage = nullptr;
auto result = m_messageFactory->parseMessage(credentials.message);
if (QJsonParseError::NoError == result.error)
clientMessage = m_messageFactory->createMessage(credentials.client, credentials.message);
clientMessage = m_messageFactory->createMessage(credentials.client, credentials.message);
else
{
WARNING_LOG(m_logger) << "Could not parse incoming message: '" << credentials.message
<< "', error: " << result.errorString();
WARNING_LOG(m_logger) << "Could not parse incoming message: '" << credentials.message << "', error: " << result.errorString();
clientMessage =
new InvalidMessage(credentials.client, QString(), QStringLiteral("Got message which is not JSON conform"));
clientMessage = new InvalidMessage(credentials.client, QString(), QStringLiteral("Got message which is not JSON conform"));
}
if (clientMessage)
clientMessage->process();
clientMessage->process();
delete clientMessage;
m_queueTimer->start(m_messageDelay);
}
}
} // namespace LtsWebSocket
#else
@@ -126,12 +124,14 @@ void LtsWebSocketServer::onQueueTimerTimeout()
namespace LtsWebSocket
{
LtsWebSocketServer::LtsWebSocketServer(AbstractClientMessageFactory* /*messageFactory*/, QObject* parent)
: QObject(parent), m_queueTimer(new QTimer(this)), m_logger(getLogger("LtsWebSocket.Server"))
{
}
LtsWebSocketServer::LtsWebSocketServer(AbstractClientMessageFactory * /*messageFactory*/, QObject *parent)
: QObject(parent)
, m_queueTimer(new QTimer(this))
, m_logger(getLogger("LtsWebSocket.Server"))
{
}
LtsWebSocketServer::~LtsWebSocketServer() = default;
LtsWebSocketServer::~LtsWebSocketServer() = default;
} // namespace LtsWebSocket
#endif
@@ -15,83 +15,87 @@ class QTimer;
#ifdef QT6_WEBSOCKETS_AVAILABLE
namespace LtsWebSocket
{
class ConnectionHandler;
class ClientConnection;
class ConnectionHandler;
class ClientConnection;
class LTSWEBSOCKETSERVER_EXPORT LtsWebSocketServer : public QObject
{
class LTSWEBSOCKETSERVER_EXPORT LtsWebSocketServer : public QObject
{
Q_OBJECT
public:
explicit LtsWebSocketServer(AbstractClientMessageFactory* messageFactory, QObject* parent = nullptr);
explicit LtsWebSocketServer(AbstractClientMessageFactory *messageFactory, QObject *parent = nullptr);
virtual ~LtsWebSocketServer();
bool init(const QString& serviceName, const unsigned short port = 0);
bool init(const QString &serviceName, const unsigned short port = 0);
bool init(const QString& serviceName, const QPair<quint16, quint16>& portRange);
bool init(const QString &serviceName, const QPair<quint16, quint16> &portRange);
void sendToAllClients(ReplyMessage* message);
void sendToAllClients(ReplyMessage *message);
unsigned short webSocketPort() const;
void setMessageDelay(qint32 delay);
signals:
void clientDisconnected(ClientConnection* client);
void clientDisconnected(ClientConnection *client);
void clientConnected(ClientConnection* client);
void clientConnected(ClientConnection *client);
private slots:
void onNewTextMessage(ReplyHandler* client, const QString& message);
void onNewTextMessage(ReplyHandler *client, const QString &message);
void onQueueTimerTimeout();
private:
struct MessageCredentials
{
ReplyHandler* client{nullptr};
QString message;
ReplyHandler *client{nullptr};
QString message;
MessageCredentials(ReplyHandler* client, const QString& message) : client(client), message(message) {}
MessageCredentials(ReplyHandler *client, const QString &message)
: client(client)
, message(message)
{
}
};
QQueue<MessageCredentials> m_messageQueue;
QTimer* m_queueTimer{nullptr};
AbstractClientMessageFactory* m_messageFactory{nullptr};
QTimer *m_queueTimer{nullptr};
AbstractClientMessageFactory *m_messageFactory{nullptr};
std::unique_ptr<ConnectionHandler> m_connectionHandler;
qint32 m_messageDelay{0};
LOGGER_T m_logger;
};
};
} // namespace LtsWebSocket
#else
#include <QtCore/QTimer>
namespace LtsWebSocket
{
class LTSWEBSOCKETSERVER_EXPORT LtsWebSocketServer : public QObject
{
class LTSWEBSOCKETSERVER_EXPORT LtsWebSocketServer : public QObject
{
Q_OBJECT
public:
explicit LtsWebSocketServer(AbstractClientMessageFactory* /*messageFactory*/, QObject* parent = nullptr);
explicit LtsWebSocketServer(AbstractClientMessageFactory * /*messageFactory*/, QObject *parent = nullptr);
virtual ~LtsWebSocketServer();
bool init(const QString& /*serviceName*/, const unsigned short /*port*/ = 0) { return false; }
bool init(const QString& /*serviceName*/, const QPair<quint16, quint16>& /*portRange*/) { return false; }
void sendToAllClients(ReplyMessage* /*message*/) {}
bool init(const QString & /*serviceName*/, const unsigned short /*port*/ = 0) { return false; }
bool init(const QString & /*serviceName*/, const QPair<quint16, quint16> & /*portRange*/) { return false; }
void sendToAllClients(ReplyMessage * /*message*/) {}
unsigned short webSocketPort() const { return 0; }
void setMessageDelay(qint32 /*delay*/) {}
signals:
void clientDisconnected(void* /*client*/);
void clientConnected(void* /*client*/);
void clientDisconnected(void * /*client*/);
void clientConnected(void * /*client*/);
private slots:
void onNewTextMessage(void* /*client*/, const QString& /*message*/) {}
void onNewTextMessage(void * /*client*/, const QString & /*message*/) {}
void onQueueTimerTimeout() {}
private:
QTimer* m_queueTimer{nullptr};
QTimer *m_queueTimer{nullptr};
LOGGER_T m_logger;
};
};
} // namespace LtsWebSocket
#endif
@@ -5,9 +5,9 @@
#include <QtCore/qglobal.h>
#if defined(LTSWEBSOCKETCOMMON_LIBRARY)
#define LTSWEBSOCKETCOMMON_EXPORT Q_DECL_EXPORT
#define LTSWEBSOCKETCOMMON_EXPORT Q_DECL_EXPORT
#else
#define LTSWEBSOCKETCOMMON_EXPORT Q_DECL_IMPORT
#define LTSWEBSOCKETCOMMON_EXPORT Q_DECL_IMPORT
#endif
#endif // LTSWEBSOCKETCOMMON_EXPORT_H
#endif // LTSWEBSOCKETCOMMON_EXPORT_H
@@ -4,9 +4,9 @@
#include <QtCore/qglobal.h>
#if defined(LTSWEBSOCKETSERVER_LIBRARY)
# define LTSWEBSOCKETSERVER_EXPORT Q_DECL_EXPORT
#define LTSWEBSOCKETSERVER_EXPORT Q_DECL_EXPORT
#else
# define LTSWEBSOCKETSERVER_EXPORT Q_DECL_IMPORT
#define LTSWEBSOCKETSERVER_EXPORT Q_DECL_IMPORT
#endif
#endif // LTSWEBSOCKETSERVER_EXPORT_H
#endif // LTSWEBSOCKETSERVER_EXPORT_H
@@ -2,11 +2,11 @@
namespace LtsWebSocketServer
{
class ReplyMessage;
class ReplyMessage;
class MessageHandler
{
class MessageHandler
{
public:
virtual void addMessage(ReplyMessage* message) = 0;
};
virtual void addMessage(ReplyMessage *message) = 0;
};
} // namespace LtsWebSocketServer
@@ -9,26 +9,26 @@
namespace LtsWebSocket
{
QString ReplyMessage::toJsonString() const
{
QString ReplyMessage::toJsonString() const
{
return QString::fromUtf8(QJsonDocument(m_jsonRepresentation).toJson(QJsonDocument::Compact));
}
}
ReplyMessage::ReplyMessage(const QString& type, const int typeId, const QString& uuid)
{
ReplyMessage::ReplyMessage(const QString &type, const int typeId, const QString &uuid)
{
m_jsonRepresentation.insert(JsonKeys::TYPE(), type);
m_jsonRepresentation.insert(JsonKeys::TYPEID(), typeId);
if (!uuid.isEmpty())
m_jsonRepresentation.insert(JsonKeys::UUID_(), uuid);
}
m_jsonRepresentation.insert(JsonKeys::UUID_(), uuid);
}
ErrorMessage::ErrorMessage(const ErrorMessage::ErrorData& data)
: ReplyMessage(JsonKeys::ERROR_(), -1, QUuid::createUuid().toString())
{
m_jsonRepresentation.insert(JsonKeys::DATA(), QJsonObject({{JsonKeys::UUID_(), data.uuid},
{JsonKeys::ERROR_CLASS(), data.errorClass},
{JsonKeys::ERROR_MESSAGE(), data.errorMessage}}));
}
ErrorMessage::ErrorMessage(const ErrorMessage::ErrorData &data)
: ReplyMessage(JsonKeys::ERROR_(), -1, QUuid::createUuid().toString())
{
m_jsonRepresentation.insert(JsonKeys::DATA(),
QJsonObject(
{{JsonKeys::UUID_(), data.uuid}, {JsonKeys::ERROR_CLASS(), data.errorClass}, {JsonKeys::ERROR_MESSAGE(), data.errorMessage}}));
}
} // namespace LtsWebSocket
@@ -11,45 +11,42 @@
namespace LtsWebSocket
{
class LTSWEBSOCKETCOMMON_EXPORT ReplyMessage
{
class LTSWEBSOCKETCOMMON_EXPORT ReplyMessage
{
public:
virtual ~ReplyMessage() = default;
virtual QString toJsonString() const;
QJsonObject json() const
{
return m_jsonRepresentation;
}
QJsonObject json() const { return m_jsonRepresentation; }
protected:
ReplyMessage() = default;
ReplyMessage(const QString& type, const int typeId, const QString& uuid);
ReplyMessage(const QString &type, const int typeId, const QString &uuid);
protected:
QJsonObject m_jsonRepresentation;
};
};
class LTSWEBSOCKETCOMMON_EXPORT ReplyHandler
{
class LTSWEBSOCKETCOMMON_EXPORT ReplyHandler
{
public:
virtual ~ReplyHandler() = default;
virtual void addReply(ReplyMessage* message) = 0;
};
virtual void addReply(ReplyMessage *message) = 0;
};
class LTSWEBSOCKETCOMMON_EXPORT ErrorMessage final : public ReplyMessage
{
class LTSWEBSOCKETCOMMON_EXPORT ErrorMessage final : public ReplyMessage
{
public:
struct ErrorData
{
int errorClass = 0;
QString uuid;
QString errorMessage;
int errorClass = 0;
QString uuid;
QString errorMessage;
};
explicit ErrorMessage(const ErrorData& data);
};
explicit ErrorMessage(const ErrorData &data);
};
} // namespace LtsWebSocket