Apply clang-format to Lts/Common and DTC/enum headers

- Formatted all CodeGen module files (9 files)
- Formatted LtsAppDescriptor module files
- Formatted LtsAppManager/AppChooser files
- Applied clang-format to all DTC and enum headers across modules
- Removed coordTransTests from CommonUnitTestsPlaceholder (moved to tests/)

Cosmetic changes only, no functional modifications.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

qt6-after/qt6-migrated-legatus/Lts/Common/httq/include/httq/AbstractServer.h

@@ -2,39 +2,41 @@
 
 #include "httq_export.h"
 
-#include <QObject>
 #include <QHostAddress>
-
+#include <QObject>
 
 class QTcpServer;
 class QWebSocketServer;
 
-
 namespace httq
 {
 class HttpRequest;
 class LoggerFactory;
 class Logger;
 
-
 class HTTQ_EXPORT AbstractServer : public QObject
 {
-  Q_OBJECT
-public:
-  explicit AbstractServer(QObject *parent = nullptr);
+    Q_OBJECT
+  public:
+    explicit AbstractServer(QObject* parent = nullptr);
 
-  virtual bool newHttpConnection(HttpRequest *request) = 0;
-  virtual QWebSocketServer *webSocketServer() const { return nullptr; }
-  virtual LoggerFactory *createLoggerFactory();
-  LoggerFactory *getLoggerFactory();
-  bool listen(qint16 port, const QHostAddress &host = QHostAddress::Any);
+    virtual bool newHttpConnection(HttpRequest* request) = 0;
 
-private slots:
-  void slotNewConnection();
+    virtual QWebSocketServer* webSocketServer() const
+    {
+        return nullptr;
+    }
 
-private:
-  QTcpServer *mSvr;
-  LoggerFactory *mLoggerFactory { nullptr };
-  Logger *mLogger;
+    virtual LoggerFactory* createLoggerFactory();
+    LoggerFactory* getLoggerFactory();
+    bool listen(qint16 port, const QHostAddress& host = QHostAddress::Any);
+
+  private slots:
+    void slotNewConnection();
+
+  private:
+    QTcpServer* mSvr;
+    LoggerFactory* mLoggerFactory{nullptr};
+    Logger* mLogger;
 };
-}
+} // namespace httq

qt6-after/qt6-migrated-legatus/Lts/Common/httq/include/httq/DataStream.h

@@ -1,53 +1,49 @@
 #pragma once
 
 #include "httq_export.h"
-#include <httq/Logger.h>
 
 #include <QObject>
 #include <QScopedPointer>
-
+#include <httq/Logger.h>
 
 class QIODevice;
 
-
 namespace httq
 {
 class HttpRequest;
 
 class HTTQ_EXPORT DataStream : public QObject
 {
-  Q_OBJECT
+    Q_OBJECT
 
-private:
-  explicit DataStream(QIODevice *from, QIODevice *to, const QByteArray &bodyPartial,
-                      qint64 fileLength, size_t bufferSize, LoggerFactory *loggerFactory,
-                      QObject *parent = nullptr);
+  private:
+    explicit DataStream(QIODevice* from, QIODevice* to, const QByteArray& bodyPartial, qint64 fileLength,
+                        size_t bufferSize, LoggerFactory* loggerFactory, QObject* parent = nullptr);
 
-public:
-  ~DataStream();
+  public:
+    ~DataStream();
 
-private:
-  friend class HttpRequest;
+  private:
+    friend class HttpRequest;
 
-  void readNext();
-  void writeNext();
+    void readNext();
+    void writeNext();
 
-  bool mReadyWrite { true };
-  
-  QByteArray mBuffer;
-  QByteArray mBodyPartial;
-  QIODevice *mFrom;
-  QIODevice *mTo;
-  
-  qint64 mBufferSize;
-  qint64 alreadyRead { 0 };
-  qint64 mFileLength;
-  bool mFromSupportsSignals { false };
-  bool mToSupportsSignals { false };
-  QScopedPointer<Logger> mLogger;
+    bool mReadyWrite{true};
 
-signals:
-  void signalDone();
+    QByteArray mBuffer;
+    QByteArray mBodyPartial;
+    QIODevice* mFrom;
+    QIODevice* mTo;
 
+    qint64 mBufferSize;
+    qint64 alreadyRead{0};
+    qint64 mFileLength;
+    bool mFromSupportsSignals{false};
+    bool mToSupportsSignals{false};
+    QScopedPointer<Logger> mLogger;
+
+  signals:
+    void signalDone();
 };
-}
+} // namespace httq

qt6-after/qt6-migrated-legatus/Lts/Common/httq/include/httq/HttpRequest.h

@@ -1,20 +1,18 @@
 #pragma once
 
 #include "httq_export.h"
-#include <http_parser.h>
 
-#include <QObject>
 #include <QByteArray>
-#include <QUrl>
 #include <QMap>
+#include <QObject>
 #include <QString>
+#include <QUrl>
 #include <QUrlQuery>
-
+#include <http_parser.h>
 
 class QTcpSocket;
 class QIODevice;
 
-
 namespace httq
 {
 class AbstractServer;
@@ -22,91 +20,118 @@ class Logger;
 class DataStream;
 class HttpRequest;
 
-
 struct HttpRequestData
 {
-  QByteArray mData;
-  QUrl mUrl;
-  QString mCurrentHeaderField;
-  QMap<QString, QString> mHeaders;
-  bool mDone { false };
-  QByteArray mBodyPartial;
-  QUrlQuery mQuery;
-  HttpRequest *mHttpRquest;
+    QByteArray mData;
+    QUrl mUrl;
+    QString mCurrentHeaderField;
+    QMap<QString, QString> mHeaders;
+    bool mDone{false};
+    QByteArray mBodyPartial;
+    QUrlQuery mQuery;
+    HttpRequest* mHttpRquest;
 };
 
-
 class HTTQ_EXPORT HttpRequest : public QObject
 {
-  Q_OBJECT
+    Q_OBJECT
 
-private:
-  explicit HttpRequest(QTcpSocket *cli, AbstractServer *parent = nullptr);
-public:
-  ~HttpRequest();
+  private:
+    explicit HttpRequest(QTcpSocket* cli, AbstractServer* parent = nullptr);
 
-  qint64 availableBytes() const;
-  http_method method() const { return (enum http_method)mParser.method; }
-  QString methodString() const { return QString::fromUtf8(http_method_str(method())); }
-  const QUrl &url() const { return mData.mUrl; }
-  const QUrlQuery &query() const { return mData.mQuery; }
-  qint64 contentLength() const { return mContentLength; }
-  const QMap<QString, QString> &requestHeaders() const { return mData.mHeaders; }
-  
-  
-  Logger *logger() { return mLogger; }
-  QString toString() const;
+  public:
+    ~HttpRequest();
 
-  
-  void addHeader(const QString &key, const QString &value);
-  void write(int status, const QByteArray &data, const QString &contentType);
-  void write(int status, const QJsonValue &jsonValue);
-  DataStream *createDataStreamFromClient(QIODevice *to, qint64 fileSize, qint64 bufferSize = 1024 * 1024);
-  DataStream *createDataStreamToClient(int status, const QString &contentType, QIODevice *from, qint64 fileSize, qint64 bufferSize = 1024 * 1024);
+    qint64 availableBytes() const;
 
-  friend class DataStream;
+    http_method method() const
+    {
+        return (enum http_method)mParser.method;
+    }
 
+    QString methodString() const
+    {
+        return QString::fromUtf8(http_method_str(method()));
+    }
 
-private:
-  friend class AbstractServer;
+    const QUrl& url() const
+    {
+        return mData.mUrl;
+    }
 
-  
-  void writeStatusHeader(int status);
-  void writeHeaders();
+    const QUrlQuery& query() const
+    {
+        return mData.mQuery;
+    }
 
-  static int on_message_begin(http_parser *parser);
-  static int on_url(http_parser *parser, const char *at, size_t length);
-  static int on_status(http_parser *parser, const char *at, size_t length);
-  static int on_header_field(http_parser *parser, const char *at, size_t length);
-  static int on_header_value(http_parser *parser, const char *at, size_t length);
-  static int on_headers_complete(http_parser *parser);
-  static int on_body(http_parser *parser, const char *at, size_t length);
-  static int on_message_complete(http_parser *parser);
-  static int on_chunk_header(http_parser *parser);
-  static int on_chunk_complete(http_parser *parser);
+    qint64 contentLength() const
+    {
+        return mContentLength;
+    }
 
-  static HttpRequestData *data(http_parser *parser) { return static_cast<HttpRequestData *>(parser->data); }
-  static Logger *dataLogger(http_parser *parser) { return static_cast<HttpRequestData *>(parser->data)->mHttpRquest->logger(); }
+    const QMap<QString, QString>& requestHeaders() const
+    {
+        return mData.mHeaders;
+    }
 
+    Logger* logger()
+    {
+        return mLogger;
+    }
 
-  QTcpSocket *mCli;
-  http_parser mParser;
-  http_parser_settings mParserSettings;
-  HttpRequestData mData;
-  bool mDone { false };
-  qint64 mContentLength { 0 };
-  qint64 alreadyRead { 0 };
-  QMap<QString, QString> mHeaders;
-  Logger *mLogger;
+    QString toString() const;
 
+    void addHeader(const QString& key, const QString& value);
+    void write(int status, const QByteArray& data, const QString& contentType);
+    void write(int status, const QJsonValue& jsonValue);
+    DataStream* createDataStreamFromClient(QIODevice* to, qint64 fileSize, qint64 bufferSize = 1024 * 1024);
+    DataStream* createDataStreamToClient(int status, const QString& contentType, QIODevice* from, qint64 fileSize,
+                                         qint64 bufferSize = 1024 * 1024);
 
-private slots:
-  void slotReadyRead();
+    friend class DataStream;
 
+  private:
+    friend class AbstractServer;
 
-signals:
-  void signalUpgrade(QTcpSocket *sock);
-  void signalReady();
+    void writeStatusHeader(int status);
+    void writeHeaders();
 
+    static int on_message_begin(http_parser* parser);
+    static int on_url(http_parser* parser, const char* at, size_t length);
+    static int on_status(http_parser* parser, const char* at, size_t length);
+    static int on_header_field(http_parser* parser, const char* at, size_t length);
+    static int on_header_value(http_parser* parser, const char* at, size_t length);
+    static int on_headers_complete(http_parser* parser);
+    static int on_body(http_parser* parser, const char* at, size_t length);
+    static int on_message_complete(http_parser* parser);
+    static int on_chunk_header(http_parser* parser);
+    static int on_chunk_complete(http_parser* parser);
+
+    static HttpRequestData* data(http_parser* parser)
+    {
+        return static_cast<HttpRequestData*>(parser->data);
+    }
+
+    static Logger* dataLogger(http_parser* parser)
+    {
+        return static_cast<HttpRequestData*>(parser->data)->mHttpRquest->logger();
+    }
+
+    QTcpSocket* mCli;
+    http_parser mParser;
+    http_parser_settings mParserSettings;
+    HttpRequestData mData;
+    bool mDone{false};
+    qint64 mContentLength{0};
+    qint64 alreadyRead{0};
+    QMap<QString, QString> mHeaders;
+    Logger* mLogger;
+
+  private slots:
+    void slotReadyRead();
+
+  signals:
+    void signalUpgrade(QTcpSocket* sock);
+    void signalReady();
 };
-}
+} // namespace httq

qt6-after/qt6-migrated-legatus/Lts/Common/httq/include/httq/Logger.h

@@ -3,50 +3,45 @@
 #include "httq_export.h"
 
 #include <QObject>
-#include <QScopedPointer>
 #include <QPointer>
-
+#include <QScopedPointer>
 
 namespace httq
 {
 class Logger;
 
-
 class HTTQ_EXPORT LoggerFactory : public QObject
 {
-  Q_OBJECT
+    Q_OBJECT
 
-public:
-  LoggerFactory(QObject *parent)
-    : QObject(parent)
-  {}
+  public:
+    LoggerFactory(QObject* parent) : QObject(parent) {}
 
-  virtual Logger *createLogger(QObject *parent);
+    virtual Logger* createLogger(QObject* parent);
 };
 
-
 class HTTQ_EXPORT Logger : public QObject
 {
-  Q_OBJECT
-public:
-  Logger(LoggerFactory *loggerFactory, QObject *parent);
+    Q_OBJECT
+  public:
+    Logger(LoggerFactory* loggerFactory, QObject* parent);
 
-  virtual void debug(const QString &message);
-  virtual void warning(const QString &message);
-  virtual void error(const QString &message);
+    virtual void debug(const QString& message);
+    virtual void warning(const QString& message);
+    virtual void error(const QString& message);
 
-  virtual LoggerFactory *getLoggerFactory() const
-  {
-    Q_ASSERT(mLoggerFactory);
-    return mLoggerFactory;
-  }
+    virtual LoggerFactory* getLoggerFactory() const
+    {
+        Q_ASSERT(mLoggerFactory);
+        return mLoggerFactory;
+    }
 
-protected:
-  QPointer<LoggerFactory> mLoggerFactory;
+  protected:
+    QPointer<LoggerFactory> mLoggerFactory;
 
-private:
-  QDebug qtLogger(const QString &type, QDebug debug);
+  private:
+    QDebug qtLogger(const QString& type, QDebug debug);
 
-  QString mPath;
+    QString mPath;
 };
-}
+} // namespace httq