fix: address other clang-tidy suggestions

sangelovic · sangelovic · commit 8d332203ffcb · 2026-01-15T13:46:48.000+01:00
diff --git a/include/sdbus-c++/AdaptorInterfaces.h b/include/sdbus-c++/AdaptorInterfaces.h
@@ -126,7 +126,7 @@ namespace sdbus {
         }
 
         /*!
-         * @brief Unregisters adaptors's API and removes it from the bus
+         * @brief Unregisters adaptor's API and removes it from the bus
          *
          * This function must be called in the destructor of the final adaptor class that implements AdaptorInterfaces.
          *
diff --git a/include/sdbus-c++/IConnection.h b/include/sdbus-c++/IConnection.h
@@ -92,7 +92,7 @@ namespace sdbus {
         virtual void leaveEventLoop() = 0;
 
         /*!
-         * @brief Attaches the bus connection to an sd-event event loop
+         * @brief Attaches the bus connection to a sd-event event loop
          *
          * @param[in] event sd-event event loop object
          * @param[in] priority Specified priority
@@ -104,7 +104,7 @@ namespace sdbus {
         virtual void attachSdEventLoop(sd_event *event, int priority = 0) = 0;
 
         /*!
-         * @brief Detaches the bus connection from an sd-event event loop
+         * @brief Detaches the bus connection from a sd-event event loop
          *
          * @throws sdbus::Error in case of failure
          */
@@ -144,7 +144,7 @@ namespace sdbus {
          * in a form that can be passed to poll(2).
          *
          * The bus connection conveniently integrates sd-event event loop.
-         * To attach the bus connection to an sd-event event loop, use
+         * To attach the bus connection to a sd-event event loop, use
          * attachSdEventLoop() function.
          *
          * @throws sdbus::Error in case of failure
@@ -168,7 +168,7 @@ namespace sdbus {
          * You don't need to directly call this method or getEventLoopPollData() method
          * when using convenient, internal bus connection event loops through
          * enterEventLoop() or enterEventLoopAsync() calls, or when the bus is
-         * connected to an sd-event event loop through attachSdEventLoop().
+         * connected to a sd-event event loop through attachSdEventLoop().
          * It is invoked automatically when necessary.
          *
          * @throws sdbus::Error in case of failure
diff --git a/include/sdbus-c++/IProxy.h b/include/sdbus-c++/IProxy.h
@@ -557,7 +557,6 @@ namespace sdbus {
          * @brief Calls method on the D-Bus object asynchronously
          *
          * @param[in] message Message representing an async method call
-         * @param[in] Tag denoting a std::future-based overload
          * @return Future object providing access to the future method reply message
          *
          * This is a std::future-based way of asynchronously calling a remote D-Bus method.
@@ -579,7 +578,6 @@ namespace sdbus {
          *
          * @param[in] message Message representing an async method call
          * @param[in] timeout Method call timeout
-         * @param[in] Tag denoting a std::future-based overload
          * @return Future object providing access to the future method reply message
          *
          * This is a std::future-based way of asynchronously calling a remote D-Bus method.
diff --git a/include/sdbus-c++/ProxyInterfaces.h b/include/sdbus-c++/ProxyInterfaces.h
@@ -29,7 +29,6 @@
 
 #include <sdbus-c++/IProxy.h>
 #include <cassert>
-#include <string>
 #include <memory>
 
 // Forward declarations
@@ -215,4 +214,4 @@ namespace sdbus {
 
 } // namespace sdbus
 
-#endif /* SDBUS_CXX_INTERFACES_H_ */
+#endif /* SDBUS_CXX_PROXYINTERFACES_H_ */
diff --git a/include/sdbus-c++/StandardInterfaces.h b/include/sdbus-c++/StandardInterfaces.h
@@ -458,8 +458,8 @@ namespace sdbus {
      * will extend the resulting object adaptor with emitInterfacesAddedSignal()/emitInterfacesRemovedSignal()
      * according to org.freedesktop.DBus.ObjectManager.InterfacesAdded/.InterfacesRemoved.
      *
-     * Note that objects which implement this adaptor require an object manager (e.g via ObjectManager_adaptor) to be
-     * instantiated on one of it's parent object paths or the same path. InterfacesAdded/InterfacesRemoved
+     * Note that objects which implement this adaptor require an object manager (e.g., via ObjectManager_adaptor) to be
+     * instantiated on one of its parent object paths or the same path. InterfacesAdded/InterfacesRemoved
      * signals are sent from the closest object manager at either the same path or the closest parent path of an object.
      */
     class ManagedObject_adaptor
diff --git a/include/sdbus-c++/TypeTraits.h b/include/sdbus-c++/TypeTraits.h
@@ -351,7 +351,7 @@ namespace sdbus {
 #endif
 
     template <typename Enum> // is_const_v and is_volatile_v to avoid ambiguity conflicts with const and volatile specializations of signature_of
-    struct signature_of<Enum, typename std::enable_if_t<std::is_enum_v<Enum> && !std::is_const_v<Enum> && !std::is_volatile_v<Enum>>>
+    struct signature_of<Enum, std::enable_if_t<std::is_enum_v<Enum> && !std::is_const_v<Enum> && !std::is_volatile_v<Enum>>>
         : signature_of<std::underlying_type_t<Enum>>
     {};
 
@@ -665,7 +665,7 @@ namespace sdbus {
     {
         return detail::apply_impl( std::forward<Function>(fun)
                                  , std::forward<Tuple>(tuple)
-                                 , std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{} );
+                                 , std::make_index_sequence<std::tuple_size_v<std::decay_t<Tuple>>>{} );
     }
 
     // Convert tuple `t' of values into a list of arguments
@@ -676,7 +676,7 @@ namespace sdbus {
         return detail::apply_impl( std::forward<Function>(fun)
                                  , std::move(res)
                                  , std::forward<Tuple>(tuple)
-                                 , std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{} );
+                                 , std::make_index_sequence<std::tuple_size_v<std::decay_t<Tuple>>>{} );
     }
 
     // Convert tuple `t' of values into a list of arguments
@@ -687,7 +687,7 @@ namespace sdbus {
         return detail::apply_impl( std::forward<Function>(fun)
                                  , std::move(err)
                                  , std::forward<Tuple>(tuple)
-                                 , std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{} );
+                                 , std::make_index_sequence<std::tuple_size_v<std::decay_t<Tuple>>>{} );
     }
 
     // Convenient concatenation of arrays
diff --git a/include/sdbus-c++/Types.h b/include/sdbus-c++/Types.h
@@ -36,7 +36,6 @@
 #include <string>
 #include <tuple>
 #include <type_traits>
-#include <typeinfo>
 #include <utility>
 
 namespace sdbus {
@@ -50,7 +49,7 @@ namespace sdbus {
      * Some const methods are conceptually const, but not physically const,
      * thus are not thread-safe. This is by design: normally, clients
      * should process a single Variant object in a single thread at a time.
-     * Otherwise they need to take care of synchronization by themselves.
+     * Otherwise, they need to take care of synchronization by themselves.
      *
      ***********************************************/
     class Variant
@@ -188,7 +187,7 @@ namespace sdbus {
     constexpr Struct<std::decay_t<Elements>...>
     make_struct(Elements&&... args)
     {
-        typedef Struct<std::decay_t<Elements>...> result_type;
+        using result_type = Struct<std::decay_t<Elements>...>;
         return result_type(std::forward<Elements>(args)...);
     }
 
diff --git a/include/sdbus-c++/VTableItems.inl b/include/sdbus-c++/VTableItems.inl
@@ -189,7 +189,7 @@ namespace sdbus {
     inline PropertyVTableItem& PropertyVTableItem::withGetter(Function&& callback)
     {
         static_assert(function_argument_count_v<Function> == 0, "Property getter function must not take any arguments");
-        static_assert(!std::is_void<function_result_t<Function>>::value, "Property getter function must return property value");
+        static_assert(!std::is_void_v<function_result_t<Function>>, "Property getter function must return property value");
 
         if (signature.empty())
             signature = signature_of_function_output_arguments_v<Function>;
@@ -207,7 +207,7 @@ namespace sdbus {
     inline PropertyVTableItem& PropertyVTableItem::withSetter(Function&& callback)
     {
         static_assert(function_argument_count_v<Function> == 1, "Property setter function must take one parameter - the property value");
-        static_assert(std::is_void<function_result_t<Function>>::value, "Property setter function must not return any value");
+        static_assert(std::is_void_v<function_result_t<Function>>, "Property setter function must not return any value");
 
         if (signature.empty())
             signature = signature_of_function_input_arguments_v<Function>;
diff --git a/src/Connection.h b/src/Connection.h
@@ -33,7 +33,6 @@
 
 #include "IConnection.h"
 #include "ISdBus.h"
-#include "ScopeGuard.h"
 
 #include <memory>
 #include <string>
diff --git a/src/IConnection.h b/src/IConnection.h
@@ -31,9 +31,7 @@
 
 #include "sdbus-c++/TypeTraits.h"
 
-#include <functional>
 #include <memory>
-#include <string>
 #include SDBUS_HEADER
 #include <vector>
 
diff --git a/src/Object.h b/src/Object.h
@@ -29,7 +29,6 @@
 
 #include "sdbus-c++/IObject.h"
 
-#include "IConnection.h"
 #include "sdbus-c++/Types.h"
 
 #include <cassert>
@@ -41,6 +40,14 @@
 #include SDBUS_HEADER
 #include <vector>
 
+// Forward declarations
+namespace sdbus {
+    class IConnection;
+    namespace internal {
+        class IConnection;
+    } // namespace internal
+} // namespace sdbus
+
 namespace sdbus::internal {
 
     class Object
diff --git a/src/ScopeGuard.h b/src/ScopeGuard.h
@@ -118,7 +118,7 @@ namespace sdbus::internal {
         ScopeGuard() = delete;
         ScopeGuard(const ScopeGuard&) = delete;
         ScopeGuard& operator=(const ScopeGuard&) = delete;
-        ScopeGuard(ScopeGuard&& rhs)  noexcept : fnc_(std::move(rhs.fnc_)), active_(rhs.active_), exceptions_(rhs.exceptions_)
+        ScopeGuard(ScopeGuard&& rhs)  noexcept : fnc_(std::move(rhs.fnc_)), exceptions_(rhs.exceptions_), active_(rhs.active_)
         {
             rhs.dismiss();
         }
diff --git a/src/SdBus.h b/src/SdBus.h
@@ -107,4 +107,4 @@ class SdBus final : public ISdBus
 
 } // namespace sdbus::internal
 
-#endif //SDBUS_C_SDBUS_H
+#endif // SDBUS_CXX_SDBUS_H
diff --git a/tests/integrationtests/DBusAsyncMethodsTests.cpp b/tests/integrationtests/DBusAsyncMethodsTests.cpp
@@ -95,15 +95,15 @@ TYPED_TEST(AsyncSdbusTestObject, RunsServerSideAsynchronousMethodAsynchronously)
     // Yeah, this is kinda timing-dependent test, but times should be safe...
     std::mutex mtx;
     std::vector<uint32_t> results;
-    std::atomic<bool> invoke{};
-    std::atomic<int> startedCount{};
+    std::atomic invoke{false};
+    std::atomic startedCount{0};
     auto call = [&](uint32_t param)
     {
         TestProxy proxy{SERVICE_NAME, OBJECT_PATH};
         ++startedCount;
         while (!invoke) ;
         auto result = proxy.doOperationAsync(param);
-        std::lock_guard<std::mutex> const guard(mtx);
+        std::lock_guard const guard(mtx);
         results.push_back(result);
     };
 
@@ -117,9 +117,9 @@ TYPED_TEST(AsyncSdbusTestObject, RunsServerSideAsynchronousMethodAsynchronously)
 
 TYPED_TEST(AsyncSdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncMethods)
 {
-    std::atomic<size_t> resultCount{};
-    std::atomic<bool> invoke{};
-    std::atomic<int> startedCount{};
+    std::atomic resultCount{(size_t)0};
+    std::atomic invoke{false};
+    std::atomic startedCount{0};
     auto call = [&]()
     {
         TestProxy proxy{SERVICE_NAME, OBJECT_PATH};
diff --git a/tests/integrationtests/DBusGeneralTests.cpp b/tests/integrationtests/DBusGeneralTests.cpp
@@ -76,7 +76,7 @@ TEST(AnAdaptor, DoesNotSupportMoveSemantics)
 TYPED_TEST(AConnection, WillCallCallbackHandlerForIncomingMessageMatchingMatchRule)
 {
     auto matchRule = "sender='" + SERVICE_NAME + "',path='" + OBJECT_PATH + "'";
-    std::atomic<bool> matchingMessageReceived{false};
+    std::atomic matchingMessageReceived{false};
     auto slot = this->s_proxyConnection->addMatch(matchRule, [&](const sdbus::Message& msg)
     {
         if(msg.getPath() == OBJECT_PATH)
@@ -91,8 +91,8 @@ TYPED_TEST(AConnection, WillCallCallbackHandlerForIncomingMessageMatchingMatchRu
 TYPED_TEST(AConnection, CanInstallMatchRuleAsynchronously)
 {
     auto matchRule = "sender='" + SERVICE_NAME + "',path='" + OBJECT_PATH + "'";
-    std::atomic<bool> matchingMessageReceived{false};
-    std::atomic<bool> matchRuleInstalled{false};
+    std::atomic matchingMessageReceived{false};
+    std::atomic matchRuleInstalled{false};
     auto slot = this->s_proxyConnection->addMatchAsync( matchRule
                                                       , [&](const sdbus::Message& msg)
                                                         {
@@ -115,7 +115,7 @@ TYPED_TEST(AConnection, CanInstallMatchRuleAsynchronously)
 TYPED_TEST(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedSlot)
 {
     auto matchRule = "sender='" + SERVICE_NAME + "',path='" + OBJECT_PATH + "'";
-    std::atomic<bool> matchingMessageReceived{false};
+    std::atomic matchingMessageReceived{false};
     auto slot = this->s_proxyConnection->addMatch(matchRule, [&](const sdbus::Message& msg)
     {
         if(msg.getPath() == OBJECT_PATH)
@@ -131,7 +131,7 @@ TYPED_TEST(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedS
 TYPED_TEST(AConnection, CanAddFloatingMatchRule)
 {
     auto matchRule = "sender='" + SERVICE_NAME + "',path='" + OBJECT_PATH + "'";
-    std::atomic<bool> matchingMessageReceived{false};
+    std::atomic matchingMessageReceived{false};
     auto con = sdbus::createBusConnection();
     con->enterEventLoopAsync();
     auto callback = [&](const sdbus::Message& msg)
diff --git a/tests/integrationtests/DBusMethodsTests.cpp b/tests/integrationtests/DBusMethodsTests.cpp
@@ -115,7 +115,7 @@ TYPED_TEST(SdbusTestObject, CallsMethodWithStdVariantSuccessfully)
 
 TYPED_TEST(SdbusTestObject, CallsMethodWithStructVariantsAndGetMapSuccessfully)
 {
-    std::vector<int32_t> const vec{-2, 0, 2};
+    std::vector const vec{-2, 0, 2};
     sdbus::Struct<sdbus::Variant, sdbus::Variant> const strct{false, true};
     std::map<int32_t, sdbus::Variant> mapOfVariants = this->m_proxy->getMapOfVariants(vec, strct);
     decltype(mapOfVariants) res{ {-2, sdbus::Variant{false}}
diff --git a/tests/integrationtests/DBusStandardInterfacesTests.cpp b/tests/integrationtests/DBusStandardInterfacesTests.cpp
@@ -205,7 +205,7 @@ TYPED_TEST(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterfac
 
 TYPED_TEST(SdbusTestObject, EmitsPropertyChangedSignalForSelectedProperties)
 {
-    std::atomic<bool> signalReceived{false};
+    std::atomic signalReceived{false};
     this->m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const sdbus::InterfaceName& interfaceName
                                                                    , const std::map<sdbus::PropertyName, sdbus::Variant>& changedProperties
                                                                    , const std::vector<sdbus::PropertyName>& /*invalidatedProperties*/ )
@@ -225,7 +225,7 @@ TYPED_TEST(SdbusTestObject, EmitsPropertyChangedSignalForSelectedProperties)
 
 TYPED_TEST(SdbusTestObject, EmitsPropertyChangedSignalForAllProperties) // NOLINT(readability-function-cognitive-complexity)
 {
-    std::atomic<bool> signalReceived{false};
+    std::atomic signalReceived{false};
     this->m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const sdbus::InterfaceName& interfaceName
                                                                    , const std::map<sdbus::PropertyName, sdbus::Variant>& changedProperties
                                                                    , const std::vector<sdbus::PropertyName>& invalidatedProperties )
@@ -338,7 +338,7 @@ TYPED_TEST(SdbusTestObject, EmitsInterfacesAddedSignalForSelectedObjectInterface
 
 TYPED_TEST(SdbusTestObject, EmitsInterfacesAddedSignalForAllObjectInterfaces) // NOLINT(readability-function-cognitive-complexity)
 {
-    std::atomic<bool> signalReceived{false};
+    std::atomic signalReceived{false};
     this->m_objectManagerProxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
                                                                               , const std::map<sdbus::InterfaceName, std::map<sdbus::PropertyName, sdbus::Variant>>& interfacesAndProperties )
     {
@@ -376,7 +376,7 @@ TYPED_TEST(SdbusTestObject, EmitsInterfacesAddedSignalForAllObjectInterfaces) //
 
 TYPED_TEST(SdbusTestObject, EmitsInterfacesRemovedSignalForSelectedObjectInterfaces)
 {
-    std::atomic<bool> signalReceived{false};
+    std::atomic signalReceived{false};
     this->m_objectManagerProxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
                                                                                 , const std::vector<sdbus::InterfaceName>& interfaces )
     {
@@ -393,7 +393,7 @@ TYPED_TEST(SdbusTestObject, EmitsInterfacesRemovedSignalForSelectedObjectInterfa
 
 TYPED_TEST(SdbusTestObject, EmitsInterfacesRemovedSignalForAllObjectInterfaces)
 {
-    std::atomic<bool> signalReceived{false};
+    std::atomic signalReceived{false};
     this->m_objectManagerProxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
                                                                                 , const std::vector<sdbus::InterfaceName>& interfaces )
     {
diff --git a/tests/stresstests/sdbus-c++-stress-tests.cpp b/tests/stresstests/sdbus-c++-stress-tests.cpp
@@ -158,7 +158,7 @@ class FahrenheitThermometerAdaptor final : public sdbus::AdaptorInterfaces< org:
                         {
                             // Destroy existing delegate object
                             // Here we are testing dynamic removal of a D-Bus object in an async way
-                            const std::lock_guard<std::mutex> lock{childrenMutex_};
+                            const std::lock_guard lock{childrenMutex_};
                             children_.erase(request.delegateObjectPath);
                         }
                     }
@@ -406,7 +406,7 @@ int main(int argc, char *argv[]) // NOLINT(bugprone-exception-escape, readabilit
     std::atomic<uint32_t> concatenationSignalsReceived{0};
     std::atomic<uint32_t> thermometerCallsMade{0};
 
-    std::atomic<bool> exitLogger{};
+    std::atomic exitLogger{false};
     std::thread loggerThread([&]()
     {
         while (!exitLogger)
@@ -423,7 +423,7 @@ int main(int argc, char *argv[]) // NOLINT(bugprone-exception-escape, readabilit
         std::cout << "Entering loop " << loop+1 << '\n';
 
         auto service2Connection = sdbus::createSystemBusConnection(SERVICE_2_BUS_NAME);
-        std::atomic<bool> service2ThreadReady{};
+        std::atomic service2ThreadReady{false};
         std::thread service2Thread([&con = *service2Connection, &service2ThreadReady]()
         {
             // NOLINTNEXTLINE(misc-const-correctness)
@@ -433,7 +433,7 @@ int main(int argc, char *argv[]) // NOLINT(bugprone-exception-escape, readabilit
         });
 
         auto service1Connection = sdbus::createSystemBusConnection(SERVICE_1_BUS_NAME);
-        std::atomic<bool> service1ThreadReady{};
+        std::atomic service1ThreadReady{false};
         std::thread service1Thread([&con = *service1Connection, &service1ThreadReady]()
         {
             // NOLINTNEXTLINE(misc-const-correctness)
@@ -454,7 +454,7 @@ int main(int argc, char *argv[]) // NOLINT(bugprone-exception-escape, readabilit
         bool clientThreadExit{};
         std::thread clientThread([&, &con = *clientConnection]()
         {
-            std::atomic<bool> stopClients{false};
+            std::atomic stopClients{false};
 
             std::thread concatenatorThread([&]()
             {

Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ namespace sdbus {`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`/*!`
`129`		`- * @brief Unregisters adaptors's API and removes it from the bus`
	`129`	`+ * @brief Unregisters adaptor's API and removes it from the bus`
`130`	`130`	`*`
`131`	`131`	`* This function must be called in the destructor of the final adaptor class that implements AdaptorInterfaces.`
`132`	`132`	`*`
Original file line number	Diff line number	Diff line change
`@@ -557,7 +557,6 @@ namespace sdbus {`
`557`	`557`	`* @brief Calls method on the D-Bus object asynchronously`
`558`	`558`	`*`
`559`	`559`	`* @param[in] message Message representing an async method call`
`560`		`- * @param[in] Tag denoting a std::future-based overload`
`561`	`560`	`* @return Future object providing access to the future method reply message`
`562`	`561`	`*`
`563`	`562`	`* This is a std::future-based way of asynchronously calling a remote D-Bus method.`
`@@ -579,7 +578,6 @@ namespace sdbus {`
`579`	`578`	`*`
`580`	`579`	`* @param[in] message Message representing an async method call`
`581`	`580`	`* @param[in] timeout Method call timeout`
`582`		`- * @param[in] Tag denoting a std::future-based overload`
`583`	`581`	`* @return Future object providing access to the future method reply message`
`584`	`582`	`*`
`585`	`583`	`* This is a std::future-based way of asynchronously calling a remote D-Bus method.`