refactor: make ESignal an enum Class IArchMultiThread::ThreadSignal, conform ThreadSignal items to naming conventions

src/lib/arch/IArchMultithread.h

@@ -69,16 +69,16 @@ public:
   Not all platforms support all signals.  Unsupported signals are
   ignored.
   */
-  enum ESignal
+  enum class ThreadSignal : uint8_t
   {
-    kINTERRUPT, //!< Interrupt (e.g. Ctrl+C)
+    Interrupt, //!< Interrupt (e.g. Ctrl+C)
-    kTERMINATE, //!< Terminate (e.g. Ctrl+Break)
+    Terminate, //!< Terminate (e.g. Ctrl+Break)
-    kHANGUP,    //!< Hangup (SIGHUP)
+    Hangup,    //!< Hangup (SIGHUP)
-    kUSER,      //!< User (SIGUSR2)
+    User,      //!< User (SIGUSR2)
-    kNUM_SIGNALS
+    MaxSignals //!< Number of differnt signals
   };
   //! Type of signal handler function
-  using SignalFunc = void (*)(ESignal, void *userData);
+  using SignalFunc = void (*)(ThreadSignal, void *userData);
 
   //! @name manipulators
   //@{
@@ -249,15 +249,15 @@ public:
   Sets the function to call on receipt of an external interrupt.
   By default and when \p func is nullptr, the main thread is cancelled.
   */
-  virtual void setSignalHandler(ESignal, SignalFunc func, void *userData) = 0;
+  virtual void setSignalHandler(ThreadSignal, SignalFunc func, void *userData) = 0;
 
   //! Invoke the signal handler
   /*!
   Invokes the signal handler for \p signal, if any.  If no handler
-  cancels the main thread for \c kINTERRUPT and \c kTERMINATE and
+  cancels the main thread for \c ThreadSignal::Interrupt and \c ThreadSignal::Terminate and
   ignores the call otherwise.
   */
-  virtual void raiseSignal(ESignal signal) = 0;
+  virtual void raiseSignal(ThreadSignal signal) = 0;
 
   //@}
 };

src/lib/arch/unix/ArchMultithreadPosix.cpp

@@ -61,7 +61,7 @@ ArchMultithreadPosix::ArchMultithreadPosix()
   s_instance = this;
 
   // no signal handlers
-  for (size_t i = 0; i < kNUM_SIGNALS; ++i) {
+  for (size_t i = 0; i < static_cast<size_t>(ThreadSignal::MaxSignals); ++i) {
     m_signalFunc[i] = nullptr;
     m_signalUserData[i] = nullptr;
   }
@@ -467,20 +467,24 @@ IArchMultithread::ThreadID ArchMultithreadPosix::getIDOfThread(ArchThread thread
   return thread->m_id;
 }
 
-void ArchMultithreadPosix::setSignalHandler(ESignal signal, SignalFunc func, void *userData)
+void ArchMultithreadPosix::setSignalHandler(ThreadSignal signal, SignalFunc func, void *userData)
 {
   std::scoped_lock lock{m_threadMutex};
-  m_signalFunc[signal] = func;
+  const auto index = static_cast<int>(signal);
-  m_signalUserData[signal] = userData;
+  m_signalFunc[index] = func;
+  m_signalUserData[index] = userData;
 }
 
-void ArchMultithreadPosix::raiseSignal(ESignal signal)
+void ArchMultithreadPosix::raiseSignal(ThreadSignal signal)
 {
+  using enum ThreadSignal;
+
   std::scoped_lock lock{m_threadMutex};
-  if (m_signalFunc[signal] != nullptr) {
+  const auto index = static_cast<int>(signal);
-    m_signalFunc[signal](signal, m_signalUserData[signal]);
+  if (m_signalFunc[index] != nullptr) {
+    m_signalFunc[index](signal, m_signalUserData[index]);
     pthread_kill(m_mainThread->m_thread, SIGWAKEUP);
-  } else if (signal == kINTERRUPT || signal == kTERMINATE) {
+  } else if (signal == Interrupt || signal == Terminate) {
     ARCH->cancelThread(m_mainThread);
   }
 }
@@ -677,20 +681,21 @@ void *ArchMultithreadPosix::threadSignalHandler(void *)
 
     // if we get here then the signal was raised
     switch (signal) {
+      using enum ThreadSignal;
     case SIGINT:
-      ARCH->raiseSignal(kINTERRUPT);
+      ARCH->raiseSignal(Interrupt);
       break;
 
     case SIGTERM:
-      ARCH->raiseSignal(kTERMINATE);
+      ARCH->raiseSignal(Terminate);
       break;
 
     case SIGHUP:
-      ARCH->raiseSignal(kHANGUP);
+      ARCH->raiseSignal(Hangup);
       break;
 
     case SIGUSR2:
-      ARCH->raiseSignal(kUSER);
+      ARCH->raiseSignal(User);
       break;
 
     default:

src/lib/arch/unix/ArchMultithreadPosix.h

@@ -76,8 +76,8 @@ public:
   bool isExitedThread(ArchThread) override;
   void *getResultOfThread(ArchThread) override;
   ThreadID getIDOfThread(ArchThread) override;
-  void setSignalHandler(ESignal, SignalFunc, void *) override;
+  void setSignalHandler(ThreadSignal, SignalFunc, void *) override;
-  void raiseSignal(ESignal) override;
+  void raiseSignal(ThreadSignal) override;
 
 private:
   void startSignalHandler();
@@ -108,6 +108,6 @@ private:
   ThreadID m_nextID = 0;
 
   pthread_t m_signalThread;
-  SignalFunc m_signalFunc[kNUM_SIGNALS];
+  SignalFunc m_signalFunc[static_cast<int>(ThreadSignal::MaxSignals)];
-  void *m_signalUserData[kNUM_SIGNALS];
+  void *m_signalUserData[static_cast<int>(ThreadSignal::MaxSignals)];
 };

src/lib/arch/win32/ArchMultithreadWindows.cpp

@@ -80,7 +80,7 @@ ArchMultithreadWindows::ArchMultithreadWindows()
   s_instance = this;
 
   // no signal handlers
-  for (size_t i = 0; i < kNUM_SIGNALS; ++i) {
+  for (size_t i = 0; i < static_cast<size_t>(ThreadSignal::MaxSignals); ++i) {
     m_signalFunc[i] = nullptr;
     m_signalUserData[i] = nullptr;
   }
@@ -474,20 +474,23 @@ IArchMultithread::ThreadID ArchMultithreadWindows::getIDOfThread(ArchThread thre
   return static_cast<ThreadID>(thread->m_id);
 }
 
-void ArchMultithreadWindows::setSignalHandler(ESignal signal, SignalFunc func, void *userData)
+void ArchMultithreadWindows::setSignalHandler(ThreadSignal signal, SignalFunc func, void *userData)
 {
   std::scoped_lock lock{m_threadMutex};
-  m_signalFunc[signal] = func;
+  const auto index = static_cast<int>(signal);
-  m_signalUserData[signal] = userData;
+  m_signalFunc[index] = func;
+  m_signalUserData[index] = userData;
 }
 
-void ArchMultithreadWindows::raiseSignal(ESignal signal)
+void ArchMultithreadWindows::raiseSignal(ThreadSignal signal)
 {
+  using enum IArchMultithread::ThreadSignal;
   std::scoped_lock lock{m_threadMutex};
-  if (m_signalFunc[signal] != nullptr) {
+  const auto index = static_cast<int>(signal);
-    m_signalFunc[signal](signal, m_signalUserData[signal]);
+  if (m_signalFunc[index] != nullptr) {
+    m_signalFunc[index](signal, m_signalUserData[index]);
     ARCH->unblockPollSocket(m_mainThread);
-  } else if (signal == kINTERRUPT || signal == kTERMINATE) {
+  } else if (signal == Interrupt || signal == Terminate) {
     ARCH->cancelThread(m_mainThread);
   }
 }

src/lib/arch/win32/ArchMultithreadWindows.h

@@ -83,8 +83,8 @@ public:
   bool isExitedThread(ArchThread) override;
   void *getResultOfThread(ArchThread) override;
   ThreadID getIDOfThread(ArchThread) override;
-  void setSignalHandler(ESignal, SignalFunc, void *) override;
+  void setSignalHandler(ThreadSignal, SignalFunc, void *) override;
-  void raiseSignal(ESignal) override;
+  void raiseSignal(ThreadSignal) override;
 
 private:
   ArchThreadImpl *find(DWORD id);
@@ -109,6 +109,6 @@ private:
   ThreadList m_threadList;
   ArchThread m_mainThread;
 
-  SignalFunc m_signalFunc[kNUM_SIGNALS];
+  SignalFunc m_signalFunc[static_cast<int>(ThreadSignal::MaxSignals)];
-  void *m_signalUserData[kNUM_SIGNALS];
+  void *m_signalUserData[static_cast<int>(ThreadSignal::MaxSignals)];
 };

src/lib/base/EventQueue.cpp

@@ -17,7 +17,7 @@
 #include <stdexcept>
 
 // interrupt handler.  this just adds a quit event to the queue.
-static void interrupt(Arch::ESignal, void *data)
+static void interrupt(Arch::ThreadSignal, void *data)
 {
   auto *events = static_cast<EventQueue *>(data);
   events->addEvent(Event(EventTypes::Quit));
@@ -29,8 +29,8 @@ static void interrupt(Arch::ESignal, void *data)
 
 EventQueue::EventQueue() : m_readyMutex(new Mutex), m_readyCondVar(new CondVar<bool>(m_readyMutex, false))
 {
-  ARCH->setSignalHandler(Arch::kINTERRUPT, &interrupt, this);
+  ARCH->setSignalHandler(Arch::ThreadSignal::Interrupt, &interrupt, this);
-  ARCH->setSignalHandler(Arch::kTERMINATE, &interrupt, this);
+  ARCH->setSignalHandler(Arch::ThreadSignal::Terminate, &interrupt, this);
   m_buffer = std::make_unique<SimpleEventQueueBuffer>();
 }
 
@@ -39,8 +39,8 @@ EventQueue::~EventQueue()
   delete m_readyCondVar;
   delete m_readyMutex;
 
-  ARCH->setSignalHandler(Arch::kINTERRUPT, nullptr, nullptr);
+  ARCH->setSignalHandler(Arch::ThreadSignal::Interrupt, nullptr, nullptr);
-  ARCH->setSignalHandler(Arch::kTERMINATE, nullptr, nullptr);
+  ARCH->setSignalHandler(Arch::ThreadSignal::Terminate, nullptr, nullptr);
 }
 
 void EventQueue::loop()

src/lib/deskflow/ServerApp.cpp

@@ -140,7 +140,7 @@ void ServerApp::help()
   LOG((CLOG_PRINT "%s", help.str().c_str()));
 }
 
-void ServerApp::reloadSignalHandler(Arch::ESignal, void *)
+void ServerApp::reloadSignalHandler(Arch::ThreadSignal, void *)
 {
   IEventQueue *events = App::instance().getEvents();
   events->addEvent(Event(EventTypes::ServerAppReloadConfig, events->getSystemTarget()));
@@ -608,7 +608,7 @@ int ServerApp::mainLoop()
   appUtil().startNode();
 
   // handle hangup signal by reloading the server's configuration
-  ARCH->setSignalHandler(Arch::kHANGUP, &reloadSignalHandler, nullptr);
+  ARCH->setSignalHandler(Arch::ThreadSignal::Hangup, &reloadSignalHandler, nullptr);
   m_events->addHandler(EventTypes::ServerAppReloadConfig, m_events->getSystemTarget(), [this](const auto &) {
     reloadConfig();
   });

src/lib/deskflow/ServerApp.h

@@ -118,7 +118,7 @@ public:
   // Static functions
   //
 
-  static void reloadSignalHandler(Arch::ESignal, void *);
+  static void reloadSignalHandler(Arch::ThreadSignal, void *);
   static ServerApp &instance()
   {
     return (ServerApp &)App::instance();