ENH: Convert signal parameters to be const reference

Refactor signal definitions to use `const` reference types, ensuring
improved performance and adherence to modern Qt coding standards

```python
import re
import sys

PRIMITIVE = {
    "bool","char","signed char","unsigned char",
    "short","unsigned short","int","unsigned int",
    "long","unsigned long","long long","unsigned long long",
    "float","double","long double",
    "char16_t","char32_t","wchar_t"
}

signal_proto = re.compile(
    r'^(?P<indent>\s*)void\s+(?P<function_name>[\w:<>]+)\s*\(\s*(?P<variable_type>[\w:<>]+)\s*(?P<variable_name>[\w:<>]*)\)\s*;\s*$'
)

def is_primitive(typ: str) -> bool:
    t = typ.strip()
    # ignore parameter names
    t = re.sub(r'\b\w+\s*$', '', t).strip()
    return t in PRIMITIVE

def process(lines):
    out = []
    in_signals = False
    for line in lines:
        if re.match(r'^\s*Q_SIGNALS\s*:', line): # Q_SIGNALS indicates the start of a block
            in_signals = True
            out.append(line)
            continue
        elif re.match(r'^\s*.*:\s*$', line):
            in_signals = False
            out.append(line)
            continue
        if in_signals:
            pm = signal_proto.match(line)
            if not pm:
                out.append(line)
                continue
            else:
              indent = pm.group('indent')
              function_name = pm.group('function_name')
              variable_type = pm.group('variable_type').strip()
              variable_name = pm.group('variable_name').strip()
              if len(variable_name) > 1:
                variable_name = f" {variable_name}" # insert space before name
              if variable_type.strip() in PRIMITIVE:
                out.append(line)
                continue
              if "*" in variable_type: # Skip pointers
                out.append(line)
                continue
              if "&" in variable_type: # Skip references
                out.append(line)
                continue
              if pm:
                new = f"{indent}void {function_name}(const {variable_type} &{variable_name});\n"
                out.append(new)
                continue
        out.append(line)
    return out

def convert(src, dst=None):
    with open(src) as f:
        lines = f.readlines()
    transformed = process(lines)
    out = open(dst, 'w') if dst else sys.stdout
    out.writelines(transformed)
    if dst:
        out.close()

if __name__ == '__main__':
    if len(sys.argv) < 2:
        print(f"Usage: {sys.argv[0]} <header.h> [<out.h>]")
        sys.exit(1)
    convert(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else None)
```

Author: hjmjohnson

Applications/ctkEventBusDemo/ctkEventBusDemoMainWindow.h

@@ -14,8 +14,8 @@ class ctkEventDemo : public QObject {
     Q_OBJECT
 
 Q_SIGNALS:
-    void receiveEventSignal(QVariantList l);
-    void updateMessageSignal(QString message);
+    void receiveEventSignal(const QVariantList &l);
+    void updateMessageSignal(const QString & message);
 
 public Q_SLOTS:
     void receiveEvent(QVariantList l);

Libs/Core/ctkAbstractJob.h

@@ -196,14 +196,14 @@ class CTK_CORE_EXPORT ctkAbstractJob : public QObject
   void failed();
   void finished();
   void jobUIDChanged();
-  void statusChanged(ctkAbstractJob::JobStatus status);
+  void statusChanged(const ctkAbstractJob::JobStatus & status);
   void isPersistentChanged(bool persistent);
   void retryCounterChanged(bool retryCounter);
   void maximumConcurrentJobsPerTypeChanged(bool maximumConcurrentJobsPerType);
   void maximumNumberOfRetryChanged(int maximumNumberOfRetry);
   void retryDelayChanged(int retryDelay);
-  void priorityChanged(QThread::Priority priority);
-  void runningThreadIDChanged(QString runningThreadID);
+  void priorityChanged(const QThread::Priority & priority);
+  void runningThreadIDChanged(const QString & runningThreadID);
   void destroyAfterUseChanged(bool destroyAfterUse);
 
 protected:

Libs/Core/ctkCoreSettings.h

@@ -62,8 +62,8 @@ class CTK_CORE_EXPORT ctkCoreSettings : public QSettings
   Q_PROPERTY(QString applicationHomePlaceholder READ applicationHomePlaceholder WRITE setApplicationHomePlaceholder NOTIFY applicationHomePlaceholderChanged);
 
 Q_SIGNALS:
-  void applicationHomeDirectoryChanged(QString);
-  void applicationHomePlaceholderChanged(QString);
+  void applicationHomeDirectoryChanged(const QString &);
+  void applicationHomePlaceholderChanged(const QString &);
 public:
   /// \see QSettings::QSettings(const QString& ,const QString& , QObject* )
   ctkCoreSettings(

Libs/Core/ctkErrorLogAbstractModel.h

@@ -163,7 +163,7 @@ public Q_SLOTS:
   /// Since an entryAdded() signal with more parameters was added, this signal is somewhat redundant,
   /// but it is kept for backward compatibility.
   /// \sa addEntry()
-  void entryAdded(ctkErrorLogLevel::LogLevel logLevel);
+  void entryAdded(const ctkErrorLogLevel::LogLevel & logLevel);
 
   /// Called when an entry is added.
   /// \sa addEntry()
@@ -178,7 +178,7 @@ public Q_SLOTS:
     const QString& origin, const ctkErrorLogContext& context, const QString& text);
 
   void logEntryGroupingChanged(bool);
-  void terminalOutputsChanged(ctkErrorLogTerminalOutput::TerminalOutputs);
+  void terminalOutputsChanged(const ctkErrorLogTerminalOutput::TerminalOutputs &);
   void asynchronousLoggingChanged(bool);
   void filePathChanged(const QString& filePath);
   void numberOfFilesToKeepChanged(int);

Libs/Core/ctkFileLogger.h

@@ -40,7 +40,7 @@ class CTK_CORE_EXPORT ctkFileLogger : public QObject
 
 Q_SIGNALS:
   void enabledChanged(bool);
-  void filePathChanged(QString);
+  void filePathChanged(const QString &);
 public:
   typedef QObject Superclass;
   typedef ctkFileLogger Self;

Libs/Core/ctkJobScheduler.h

@@ -117,14 +117,14 @@ class CTK_CORE_EXPORT ctkJobScheduler : public QObject
   QSharedPointer<QThreadPool> threadPoolShared() const;
 
 Q_SIGNALS:
-  void jobInitialized(QVariant);
-  void jobQueued(QVariant);
-  void jobStarted(QList<QVariant>);
-  void jobUserStopped(QList<QVariant>);
-  void jobFinished(QList<QVariant>);
-  void jobAttemptFailed(QList<QVariant>);
-  void jobFailed(QList<QVariant>);
-  void progressJobDetail(QList<QVariant>);
+  void jobInitialized(const QVariant &);
+  void jobQueued(const QVariant &);
+  void jobStarted(const QList<QVariant> &);
+  void jobUserStopped(const QList<QVariant> &);
+  void jobFinished(const QList<QVariant> &);
+  void jobAttemptFailed(const QList<QVariant> &);
+  void jobFailed(const QList<QVariant> &);
+  void progressJobDetail(const QList<QVariant> &);
   void freezeJobsSchedulingChanged(bool);
   void maximumThreadCountChanged(int);
   void maximumNumberOfRetryChanged(int);

Libs/Core/ctkLogger.h

@@ -37,7 +37,7 @@ class CTK_CORE_EXPORT ctkLogger : public QObject
   Q_OBJECT
   Q_PROPERTY(ctkErrorLogLevel::LogLevel level READ logLevel WRITE setLogLevel NOTIFY logLevelChanged);
 Q_SIGNALS:
-  void logLevelChanged(ctkErrorLogLevel::LogLevel newlevel);
+  void logLevelChanged(const ctkErrorLogLevel::LogLevel & newlevel);
 public:
   typedef QObject Superclass;
 

Libs/DICOM/Core/ctkDICOMDisplayedFieldGeneratorRuleFactory.h

@@ -1,84 +1,84 @@
-/*==============================================================================
-
-  Library:   CTK
-
-  Copyright (c) Pixel Medical Inc. 2021
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0.txt
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-  ==============================================================================*/
-
-#ifndef __ctkDICOMDisplayedFieldGeneratorRuleFactory_h_
-#define __ctkDICOMDisplayedFieldGeneratorRuleFactory_h_
-
-#include "ctkDICOMCoreExport.h"
-
-// Qt includes
-#include <QObject>
-#include <QList>
-
-class ctkDICOMDatabase;
-class ctkDICOMDisplayedFieldGeneratorAbstractRule;
-class ctkDICOMDisplayedFieldGeneratorRuleFactoryCleanup;
-
-/// \ingroup SlicerRt_QtModules_Segmentations
-/// \class ctkDICOMDisplayedFieldGeneratorRuleFactory
-/// \brief Singleton class managing displayed field generator rules
-class CTK_DICOM_CORE_EXPORT ctkDICOMDisplayedFieldGeneratorRuleFactory : public QObject
-{
-  Q_OBJECT
-
-public:
-  /// Instance getter for the singleton class
-  /// \return Instance object
-  Q_INVOKABLE static ctkDICOMDisplayedFieldGeneratorRuleFactory* instance();
-
-public:
-  /// Register a displayed field generator rule. The factory takes ownership of the object (caller must not delete it).
-  /// \return True if rule is registered successfully, false otherwise
-  Q_INVOKABLE bool registerDisplayedFieldGeneratorRule(ctkDICOMDisplayedFieldGeneratorAbstractRule* rule);
-
-  /// Return the list of displayed field generator rules registered.
-  Q_INVOKABLE const QList<ctkDICOMDisplayedFieldGeneratorAbstractRule*>& displayedFieldGeneratorRules()
-    { return this->DisplayedFieldGeneratorRules; }
-
-  /// Return a list with the copies of displayed field generator rules that are enabled according to the database.
-  /// \param database DICOM database in which the DisplayedFieldGeneratorRules table is used to decide if a rule is
-  ///   enabled or not. If the table itself or an entry with a particular rule name is missing then the rule is treated as enabled.
-  Q_INVOKABLE QList<ctkDICOMDisplayedFieldGeneratorAbstractRule*> copyEnabledDisplayedFieldGeneratorRules(ctkDICOMDatabase* database);
-
-signals:
-  void displayedFieldGeneratorRuleRegistered();
-  void displayedFieldGeneratorRuleUnregistered();
-
-protected:
-  QList<ctkDICOMDisplayedFieldGeneratorAbstractRule*> DisplayedFieldGeneratorRules;
-
-private:
-  /// Allows cleanup of the singleton at application exit
-  static void cleanup();
-
-private:
-  ctkDICOMDisplayedFieldGeneratorRuleFactory(QObject* parent=nullptr);
-  ~ctkDICOMDisplayedFieldGeneratorRuleFactory() override;
-
-  Q_DISABLE_COPY(ctkDICOMDisplayedFieldGeneratorRuleFactory);
-  friend class ctkDICOMDisplayedFieldGeneratorRuleFactoryCleanup;
-  friend class PythonQtWrapper_ctkDICOMDisplayedFieldGeneratorRuleFactory; // Allow Python wrapping without enabling direct instantiation
-
-private:
-  /// Instance of the singleton
-  static ctkDICOMDisplayedFieldGeneratorRuleFactory* Instance;
-};
-
-#endif // __ctkDICOMDisplayedFieldGeneratorRuleFactory_h_
+/*==============================================================================
+
+  Library:   CTK
+
+  Copyright (c) Pixel Medical Inc. 2021
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0.txt
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  ==============================================================================*/
+
+#ifndef __ctkDICOMDisplayedFieldGeneratorRuleFactory_h_
+#define __ctkDICOMDisplayedFieldGeneratorRuleFactory_h_
+
+#include "ctkDICOMCoreExport.h"
+
+// Qt includes
+#include <QObject>
+#include <QList>
+
+class ctkDICOMDatabase;
+class ctkDICOMDisplayedFieldGeneratorAbstractRule;
+class ctkDICOMDisplayedFieldGeneratorRuleFactoryCleanup;
+
+/// \ingroup SlicerRt_QtModules_Segmentations
+/// \class ctkDICOMDisplayedFieldGeneratorRuleFactory
+/// \brief Singleton class managing displayed field generator rules
+class CTK_DICOM_CORE_EXPORT ctkDICOMDisplayedFieldGeneratorRuleFactory : public QObject
+{
+  Q_OBJECT
+
+public:
+  /// Instance getter for the singleton class
+  /// \return Instance object
+  Q_INVOKABLE static ctkDICOMDisplayedFieldGeneratorRuleFactory* instance();
+
+public:
+  /// Register a displayed field generator rule. The factory takes ownership of the object (caller must not delete it).
+  /// \return True if rule is registered successfully, false otherwise
+  Q_INVOKABLE bool registerDisplayedFieldGeneratorRule(ctkDICOMDisplayedFieldGeneratorAbstractRule* rule);
+
+  /// Return the list of displayed field generator rules registered.
+  Q_INVOKABLE const QList<ctkDICOMDisplayedFieldGeneratorAbstractRule*>& displayedFieldGeneratorRules()
+    { return this->DisplayedFieldGeneratorRules; }
+
+  /// Return a list with the copies of displayed field generator rules that are enabled according to the database.
+  /// \param database DICOM database in which the DisplayedFieldGeneratorRules table is used to decide if a rule is
+  ///   enabled or not. If the table itself or an entry with a particular rule name is missing then the rule is treated as enabled.
+  Q_INVOKABLE QList<ctkDICOMDisplayedFieldGeneratorAbstractRule*> copyEnabledDisplayedFieldGeneratorRules(ctkDICOMDatabase* database);
+
+signals:
+  void displayedFieldGeneratorRuleRegistered();
+  void displayedFieldGeneratorRuleUnregistered();
+
+protected:
+  QList<ctkDICOMDisplayedFieldGeneratorAbstractRule*> DisplayedFieldGeneratorRules;
+
+private:
+  /// Allows cleanup of the singleton at application exit
+  static void cleanup();
+
+private:
+  ctkDICOMDisplayedFieldGeneratorRuleFactory(QObject* parent=nullptr);
+  ~ctkDICOMDisplayedFieldGeneratorRuleFactory() override;
+
+  Q_DISABLE_COPY(ctkDICOMDisplayedFieldGeneratorRuleFactory);
+  friend class ctkDICOMDisplayedFieldGeneratorRuleFactoryCleanup;
+  friend class PythonQtWrapper_ctkDICOMDisplayedFieldGeneratorRuleFactory; // Allow Python wrapping without enabling direct instantiation
+
+private:
+  /// Instance of the singleton
+  static ctkDICOMDisplayedFieldGeneratorRuleFactory* Instance;
+};
+
+#endif // __ctkDICOMDisplayedFieldGeneratorRuleFactory_h_

Libs/DICOM/Core/ctkDICOMEcho.h

@@ -47,13 +47,13 @@ class CTK_DICOM_CORE_EXPORT ctkDICOMEcho : public QObject
   Q_PROPERTY(QString jobUID READ jobUID WRITE setJobUID NOTIFY jobUIDChanged);
 
 Q_SIGNALS:
-  void connectionNameChanged(QString);
-  void callingAETitleChanged(QString);
-  void calledAETitleChanged(QString);
-  void hostChanged(QString);
+  void connectionNameChanged(const QString &);
+  void callingAETitleChanged(const QString &);
+  void calledAETitleChanged(const QString &);
+  void hostChanged(const QString &);
   void portChanged(int);
   void connectionTimeoutChanged(int);
-  void jobUIDChanged(QString);
+  void jobUIDChanged(const QString &);
 public:
   explicit ctkDICOMEcho(QObject* parent = 0);
   virtual ~ctkDICOMEcho();

Libs/DICOM/Core/ctkDICOMIndexer.h

@@ -123,9 +123,9 @@ class CTK_DICOM_CORE_EXPORT ctkDICOMIndexer : public QObject
 
 Q_SIGNALS:
   /// Description of current phase of the indexing (parsing, importing, ...)
-  void progressStep(QString);
+  void progressStep(const QString &);
   /// Detailed information about the current progress (e.g., name of currently processed file)
-  void progressDetail(QString);
+  void progressDetail(const QString &);
   /// Progress in percentage
   void progress(int);
   /// Indexing is completed.
@@ -153,4 +153,4 @@ protected Q_SLOTS:
 
 };
 
-#endif
+#endif