Move some leftover raw spdlog calls to macros

Change-Id: I8900936d5aa5648ab75c15decab8099b98274809 Reviewed-on: https://codereview.kdab.com/c/kdab/kdutils/+/136228 Tested-by: Continuous Integration <[email protected]> Reviewed-by: Sean Harmer <[email protected]>
KDAB · Jan 11, 2024 · 20ef5a3 · 20ef5a3
1 parent eea8e1e
commit 20ef5a3
Show file tree

Hide file tree

Showing 12 changed files with 77 additions and 77 deletions.
diff --git a/examples/gui_window/gui_window.cpp b/examples/gui_window/gui_window.cpp
@@ -16,47 +16,47 @@ class ExampleWindow : public KDGui::Window
 {
     void mouseMoveEvent(KDGui::MouseMoveEvent *ev) override
     {
-        spdlog::info("{}() buttons = {} at pos = ({}, {})",
-                     __FUNCTION__,
-                     ev->buttons().toInt(),
-                     ev->xPos(),
-                     ev->yPos());
+        SPDLOG_INFO("{}() buttons = {} at pos = ({}, {})",
+                    __FUNCTION__,
+                    ev->buttons().toInt(),
+                    ev->xPos(),
+                    ev->yPos());
     }
 
     void mousePressEvent(KDGui::MousePressEvent *ev) override
     {
-        spdlog::info("{}() buttons = {} at pos = ({}, {})",
-                     __FUNCTION__,
-                     ev->buttons().toInt(),
-                     ev->xPos(),
-                     ev->yPos());
+        SPDLOG_INFO("{}() buttons = {} at pos = ({}, {})",
+                    __FUNCTION__,
+                    ev->buttons().toInt(),
+                    ev->xPos(),
+                    ev->yPos());
     }
 
     void mouseReleaseEvent(KDGui::MouseReleaseEvent *ev) override
     {
-        spdlog::info("{}() buttons = {} at pos = ({}, {})",
-                     __FUNCTION__,
-                     ev->buttons().toInt(),
-                     ev->xPos(),
-                     ev->yPos());
+        SPDLOG_INFO("{}() buttons = {} at pos = ({}, {})",
+                    __FUNCTION__,
+                    ev->buttons().toInt(),
+                    ev->xPos(),
+                    ev->yPos());
     }
 
     void mouseWheelEvent(KDGui::MouseWheelEvent *ev) override
     {
-        spdlog::info("{}() xDelta = {} yDelta = {}",
-                     __FUNCTION__,
-                     ev->xDelta(),
-                     ev->yDelta());
+        SPDLOG_INFO("{}() xDelta = {} yDelta = {}",
+                    __FUNCTION__,
+                    ev->xDelta(),
+                    ev->yDelta());
     }
 
     void keyPressEvent(KDGui::KeyPressEvent *ev) override
     {
-        spdlog::info("{}() key = {}", __FUNCTION__, ev->key());
+        SPDLOG_INFO("{}() key = {}", __FUNCTION__, ev->key());
     }
 
     void keyReleaseEvent(KDGui::KeyReleaseEvent *ev) override
     {
-        spdlog::info("{}() key = {}", __FUNCTION__, ev->key());
+        SPDLOG_INFO("{}() key = {}", __FUNCTION__, ev->key());
     }
 };
 

diff --git a/src/KDFoundation/file_descriptor_notifier.cpp b/src/KDFoundation/file_descriptor_notifier.cpp
@@ -31,7 +31,7 @@ FileDescriptorNotifier::FileDescriptorNotifier(int fd, NotificationType type)
     // Get hold of the event loop from the application
     auto app = CoreApplication::instance();
     if (!app) {
-        spdlog::warn("No application object exists yet. The notifier for fd {} will not be registered", m_fd);
+        SPDLOG_WARN("No application object exists yet. The notifier for fd {} will not be registered", m_fd);
         return;
     }
 
@@ -44,7 +44,7 @@ FileDescriptorNotifier::~FileDescriptorNotifier()
 {
     auto app = CoreApplication::instance();
     if (!app) {
-        spdlog::warn("No application object exists yet we still have a notifier for fd {} alive", m_fd);
+        SPDLOG_WARN("No application object exists yet we still have a notifier for fd {} alive", m_fd);
         return;
     }
 

diff --git a/src/KDFoundation/platform/linux/linux_platform_event_loop.cpp b/src/KDFoundation/platform/linux/linux_platform_event_loop.cpp
@@ -71,7 +71,7 @@ void LinuxPlatformEventLoop::waitForEvents(int timeout)
 
     // Let interested parties know if something happened.
     if (!m_postman) {
-        spdlog::warn("No postman set. Cannot deliver events");
+        SPDLOG_WARN("No postman set. Cannot deliver events");
         return;
     }
 

diff --git a/src/KDFoundation/platform/linux/linux_platform_event_loop.h b/src/KDFoundation/platform/linux/linux_platform_event_loop.h
@@ -76,7 +76,7 @@ class KDFOUNDATION_API LinuxPlatformEventLoop : public AbstractPlatformEventLoop
             case FileDescriptorNotifier::NotificationType::Exception:
                 return !hasNotifier(FileDescriptorNotifier::NotificationType::Read) && !hasNotifier(FileDescriptorNotifier::NotificationType::Write);
             }
-            spdlog::critical("Error in determining if notifier set is empty");
+            SPDLOG_CRITICAL("Error in determining if notifier set is empty");
             return false;
         }
 

diff --git a/src/KDFoundation/platform/win32/win32_platform_event_loop.cpp b/src/KDFoundation/platform/win32/win32_platform_event_loop.cpp
@@ -43,15 +43,15 @@ Win32PlatformEventLoop::Win32PlatformEventLoop()
 {
     m_wakeUpEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
     if (!m_wakeUpEvent)
-        spdlog::critical("Failed to create wake up event");
+        SPDLOG_CRITICAL("Failed to create wake up event");
 
     WNDCLASS wc = {};
     wc.lpfnWndProc = messageWindowProc;
     wc.lpszClassName = s_msgWindowClassName;
 
     ATOM atom = RegisterClass(&wc);
     if (!atom)
-        spdlog::critical("Failed to register message window class");
+        SPDLOG_CRITICAL("Failed to register message window class");
 
     // The GetLastError() returns error code 6 ("The handle is invalid") here but
     // the created message window is fine and works anyway. It's like that even
@@ -65,7 +65,7 @@ Win32PlatformEventLoop::Win32PlatformEventLoop()
             0);
 
     if (!m_msgWindow)
-        spdlog::critical("Failed to create window for socket events");
+        SPDLOG_CRITICAL("Failed to create window for socket events");
     SetWindowLongPtr(m_msgWindow, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));
 }
 
@@ -76,7 +76,7 @@ Win32PlatformEventLoop::~Win32PlatformEventLoop()
     if (m_msgWindow)
         DestroyWindow(m_msgWindow);
     if (!UnregisterClass(s_msgWindowClassName, GetModuleHandle(0)))
-        spdlog::warn("Failed to unregister message window class");
+        SPDLOG_WARN("Failed to unregister message window class");
 }
 
 void Win32PlatformEventLoop::waitForEvents(int timeout)
@@ -116,7 +116,7 @@ void Win32PlatformEventLoop::wakeUp()
 {
     if (m_wakeUpEvent) {
         if (!SetEvent(m_wakeUpEvent))
-            spdlog::critical("Failed to signal wake up event");
+            SPDLOG_CRITICAL("Failed to signal wake up event");
     }
 }
 
@@ -126,7 +126,7 @@ bool Win32PlatformEventLoop::registerNotifier(FileDescriptorNotifier *notifier)
         return false;
 
     if (notifier->fileDescriptor() < 0) {
-        spdlog::warn("Attempting to register invalid notifier socket = {}", notifier->fileDescriptor());
+        SPDLOG_WARN("Attempting to register invalid notifier socket = {}", notifier->fileDescriptor());
         return false;
     }
 
@@ -187,12 +187,12 @@ void Win32PlatformEventLoop::handleSocketMessage(WPARAM wparam, LPARAM lparam)
     const int op = WSAGETSELECTEVENT(lparam);
 
     if (err) {
-        spdlog::warn("Error when receiving message on socket {}, Err = {}", sockId, err);
+        SPDLOG_WARN("Error when receiving message on socket {}, Err = {}", sockId, err);
         return;
     }
 
     if (!m_postman) {
-        spdlog::warn("No postman set. Cannot deliver events");
+        SPDLOG_WARN("No postman set. Cannot deliver events");
         return;
     }
 
@@ -251,7 +251,7 @@ bool KDFoundation::Win32PlatformEventLoop::registerWithWSAAsyncSelect(int fd, co
 
     const int result = WSAAsyncSelect(fd, m_msgWindow, WM_KD_SOCKETEVENT, eventsToSubscribe);
     if (result != 0) {
-        spdlog::error("Failed to register notifier for socket = {}. Error = {}", fd, result);
+        SPDLOG_ERROR("Failed to register notifier for socket = {}. Error = {}", fd, result);
         return false;
     }
 

diff --git a/src/KDGui/platform/cocoa/cocoa_platform_window.mm b/src/KDGui/platform/cocoa/cocoa_platform_window.mm
@@ -410,7 +410,7 @@ - (void)keyUp:(NSEvent *)event
                                                        backing:NSBackingStoreBuffered
                                                          defer:NO];
         if (m_nativeWindow == nil) {
-            spdlog::critical("Failed to create native window");
+            SPDLOG_CRITICAL("Failed to create native window");
             return false;
         }
 

diff --git a/src/KDGui/platform/win32/win32_gui_platform_integration.cpp b/src/KDGui/platform/win32/win32_gui_platform_integration.cpp
@@ -66,7 +66,7 @@ bool Win32GuiPlatformIntegration::registerWindowClass(const std::wstring &classN
 
     const auto atom = RegisterClassEx(&wc);
     if (!atom) {
-        spdlog::critical("Failed to register window class: {}", windowsErrorMessage(GetLastError()));
+        SPDLOG_CRITICAL("Failed to register window class: {}", windowsErrorMessage(GetLastError()));
     }
 
     m_windowClasses.insert(className);
@@ -80,7 +80,7 @@ void Win32GuiPlatformIntegration::unregisterWindowClasses()
 
     for (const auto &name : m_windowClasses) {
         if (!UnregisterClass(name.c_str(), appInstance)) {
-            spdlog::critical("Failed to unregister class: {}", windowsErrorMessage(GetLastError()));
+            SPDLOG_CRITICAL("Failed to unregister class: {}", windowsErrorMessage(GetLastError()));
         }
     }
 

diff --git a/src/KDGui/platform/win32/win32_utils.cpp b/src/KDGui/platform/win32/win32_utils.cpp
@@ -32,13 +32,13 @@ std::wstring utf8StringToWide(std::string_view source)
 {
     const auto count = MultiByteToWideChar(CP_UTF8, 0, source.data(), static_cast<int>(source.size()), nullptr, 0);
     if (!count) {
-        spdlog::warn("Failed to convert string from UTF-8");
+        SPDLOG_WARN("Failed to convert string from UTF-8");
         return {};
     }
 
     std::wstring result(count, 0);
     if (!MultiByteToWideChar(CP_UTF8, 0, source.data(), static_cast<int>(source.size()), result.data(), count)) {
-        spdlog::warn("Failed to convert string from UTF-8");
+        SPDLOG_WARN("Failed to convert string from UTF-8");
         return {};
     }
 
@@ -49,13 +49,13 @@ std::string wideStringToUtf8(std::wstring_view source)
 {
     const auto count = WideCharToMultiByte(CP_UTF8, 0, source.data(), static_cast<int>(source.size()), nullptr, 0, nullptr, nullptr);
     if (!count) {
-        spdlog::warn("Failed to convert string to UTF-8");
+        SPDLOG_WARN("Failed to convert string to UTF-8");
         return {};
     }
 
     std::string result(count, 0);
     if (!WideCharToMultiByte(CP_UTF8, 0, source.data(), static_cast<int>(source.size()), result.data(), count, nullptr, nullptr)) {
-        spdlog::warn("Failed to convert string to UTF-8");
+        SPDLOG_WARN("Failed to convert string to UTF-8");
         return {};
     }
 

diff --git a/tests/auto/foundation/core_application/tst_core_application.cpp b/tests/auto/foundation/core_application/tst_core_application.cpp
@@ -216,31 +216,31 @@ TEST_CASE("Main event loop")
         std::condition_variable cond;
         bool ready = false;
         auto quitTheApp = [&mutex, &cond, &ready, &app]() {
-            spdlog::info("Launched worker thread");
+            SPDLOG_INFO("Launched worker thread");
             std::unique_lock lock(mutex);
             cond.wait(lock, [&ready] { return ready == true; });
-            spdlog::info("Worker thread going to sleep before quitting the app event loop");
+            SPDLOG_INFO("Worker thread going to sleep before quitting the app event loop");
 
             std::this_thread::sleep_for(std::chrono::milliseconds(500));
-            spdlog::info("Worker thread requesting the app to quit");
+            SPDLOG_INFO("Worker thread requesting the app to quit");
             app.quit();
         };
         std::thread t1(quitTheApp);
 
         {
-            spdlog::info("Waking up helper thread");
+            SPDLOG_INFO("Waking up helper thread");
             std::unique_lock lock(mutex);
             ready = true;
             cond.notify_all();
         }
 
         const auto startTime = std::chrono::steady_clock::now();
-        spdlog::info("Main thread entering event loop");
+        SPDLOG_INFO("Main thread entering event loop");
         app.exec();
         const auto endTime = std::chrono::steady_clock::now();
 
         auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
-        spdlog::info("elapsedTime = {}", elapsedTime);
+        SPDLOG_INFO("elapsedTime = {}", elapsedTime);
         REQUIRE(elapsedTime < 1000);
 
         t1.join();