From cbbfd495e3924984c26942c0e8f20bb0c548390a Mon Sep 17 00:00:00 2001 From: sithlord48 Date: Mon, 30 Jun 2025 17:25:35 -0400 Subject: [PATCH] refactor: make ESignal an enum Class IArchMultiThread::ThreadSignal, conform ThreadSignal items to naming conventions --- src/lib/arch/IArchMultithread.h | 20 ++++++------- src/lib/arch/unix/ArchMultithreadPosix.cpp | 29 +++++++++++-------- src/lib/arch/unix/ArchMultithreadPosix.h | 8 ++--- src/lib/arch/win32/ArchMultithreadWindows.cpp | 19 +++++++----- src/lib/arch/win32/ArchMultithreadWindows.h | 8 ++--- src/lib/base/EventQueue.cpp | 10 +++---- src/lib/deskflow/ServerApp.cpp | 4 +-- src/lib/deskflow/ServerApp.h | 2 +- 8 files changed, 54 insertions(+), 46 deletions(-) diff --git a/src/lib/arch/IArchMultithread.h b/src/lib/arch/IArchMultithread.h index 649f0feb4..9756db96d 100644 --- a/src/lib/arch/IArchMultithread.h +++ b/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) - kTERMINATE, //!< Terminate (e.g. Ctrl+Break) - kHANGUP, //!< Hangup (SIGHUP) - kUSER, //!< User (SIGUSR2) - kNUM_SIGNALS + Interrupt, //!< Interrupt (e.g. Ctrl+C) + Terminate, //!< Terminate (e.g. Ctrl+Break) + Hangup, //!< Hangup (SIGHUP) + User, //!< User (SIGUSR2) + 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; //@} }; diff --git a/src/lib/arch/unix/ArchMultithreadPosix.cpp b/src/lib/arch/unix/ArchMultithreadPosix.cpp index a4021f298..0532d499f 100644 --- a/src/lib/arch/unix/ArchMultithreadPosix.cpp +++ b/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(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; - m_signalUserData[signal] = userData; + const auto index = static_cast(signal); + 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) { - m_signalFunc[signal](signal, m_signalUserData[signal]); + const auto index = static_cast(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: diff --git a/src/lib/arch/unix/ArchMultithreadPosix.h b/src/lib/arch/unix/ArchMultithreadPosix.h index 924ac7fae..bb4bbfb6c 100644 --- a/src/lib/arch/unix/ArchMultithreadPosix.h +++ b/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 raiseSignal(ESignal) override; + void setSignalHandler(ThreadSignal, SignalFunc, void *) 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]; - void *m_signalUserData[kNUM_SIGNALS]; + SignalFunc m_signalFunc[static_cast(ThreadSignal::MaxSignals)]; + void *m_signalUserData[static_cast(ThreadSignal::MaxSignals)]; }; diff --git a/src/lib/arch/win32/ArchMultithreadWindows.cpp b/src/lib/arch/win32/ArchMultithreadWindows.cpp index 6128434f2..9067d6aec 100644 --- a/src/lib/arch/win32/ArchMultithreadWindows.cpp +++ b/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(ThreadSignal::MaxSignals); ++i) { m_signalFunc[i] = nullptr; m_signalUserData[i] = nullptr; } @@ -474,20 +474,23 @@ IArchMultithread::ThreadID ArchMultithreadWindows::getIDOfThread(ArchThread thre return static_cast(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; - m_signalUserData[signal] = userData; + const auto index = static_cast(signal); + 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) { - m_signalFunc[signal](signal, m_signalUserData[signal]); + const auto index = static_cast(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); } } diff --git a/src/lib/arch/win32/ArchMultithreadWindows.h b/src/lib/arch/win32/ArchMultithreadWindows.h index 4cdc8a976..d34dac8fa 100644 --- a/src/lib/arch/win32/ArchMultithreadWindows.h +++ b/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 raiseSignal(ESignal) override; + void setSignalHandler(ThreadSignal, SignalFunc, void *) 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]; - void *m_signalUserData[kNUM_SIGNALS]; + SignalFunc m_signalFunc[static_cast(ThreadSignal::MaxSignals)]; + void *m_signalUserData[static_cast(ThreadSignal::MaxSignals)]; }; diff --git a/src/lib/base/EventQueue.cpp b/src/lib/base/EventQueue.cpp index 6f93aa9d1..65ebfa354 100644 --- a/src/lib/base/EventQueue.cpp +++ b/src/lib/base/EventQueue.cpp @@ -17,7 +17,7 @@ #include // 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(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(m_readyMutex, false)) { - ARCH->setSignalHandler(Arch::kINTERRUPT, &interrupt, this); - ARCH->setSignalHandler(Arch::kTERMINATE, &interrupt, this); + ARCH->setSignalHandler(Arch::ThreadSignal::Interrupt, &interrupt, this); + ARCH->setSignalHandler(Arch::ThreadSignal::Terminate, &interrupt, this); m_buffer = std::make_unique(); } @@ -39,8 +39,8 @@ EventQueue::~EventQueue() delete m_readyCondVar; delete m_readyMutex; - ARCH->setSignalHandler(Arch::kINTERRUPT, nullptr, nullptr); - ARCH->setSignalHandler(Arch::kTERMINATE, nullptr, nullptr); + ARCH->setSignalHandler(Arch::ThreadSignal::Interrupt, nullptr, nullptr); + ARCH->setSignalHandler(Arch::ThreadSignal::Terminate, nullptr, nullptr); } void EventQueue::loop() diff --git a/src/lib/deskflow/ServerApp.cpp b/src/lib/deskflow/ServerApp.cpp index 0328d145f..5a5c53cff 100644 --- a/src/lib/deskflow/ServerApp.cpp +++ b/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(); }); diff --git a/src/lib/deskflow/ServerApp.h b/src/lib/deskflow/ServerApp.h index 9de386eb6..7dcacd7c7 100644 --- a/src/lib/deskflow/ServerApp.h +++ b/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();