Switch to fully supported C++17

src/Connection.cpp

@@ -35,7 +35,7 @@
 #include <poll.h>
 #include <sys/eventfd.h>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 Connection::Connection(std::unique_ptr<ISdBus>&& interface, const BusFactory& busFactory)
     : iface_(std::move(interface))
@@ -454,11 +454,10 @@ Connection::LoopExitEventFd::~LoopExitEventFd()
     close(fd);
 }
 
-}}
+}
 
-namespace sdbus {
+namespace sdbus::internal {
 
-namespace internal {
 std::unique_ptr<sdbus::internal::IConnection> createConnection()
 {
     auto connection = sdbus::createConnection();
@@ -466,8 +465,11 @@ std::unique_ptr<sdbus::internal::IConnection> createConnection()
     auto connectionInternal = dynamic_cast<sdbus::internal::IConnection*>(connection.get());
     return std::unique_ptr<sdbus::internal::IConnection>(connectionInternal);
 }
+
 }
 
+namespace sdbus {
+
 std::unique_ptr<sdbus::IConnection> createConnection()
 {
     return createSystemBusConnection();

src/Connection.h

@@ -40,7 +40,7 @@
 #include <atomic>
 #include <mutex>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
     class Connection
         : public sdbus::IConnection           // External, public interface
@@ -139,6 +139,6 @@ namespace sdbus { namespace internal {
         LoopExitEventFd loopExitFd_;
     };
 
-}}
+}
 
 #endif /* SDBUS_CXX_INTERNAL_CONNECTION_H_ */

src/IConnection.h

@@ -44,8 +44,7 @@ namespace sdbus {
     }
 }
 
-namespace sdbus {
-namespace internal {
+namespace sdbus::internal {
 
     using SlotPtr = std::unique_ptr<void, std::function<void(void*)>>;
 
@@ -57,10 +56,10 @@ namespace internal {
         virtual const ISdBus& getSdBusInterface() const = 0;
         virtual ISdBus& getSdBusInterface() = 0;
 
-        virtual SlotPtr addObjectVTable( const std::string& objectPath
-                                       , const std::string& interfaceName
-                                       , const sd_bus_vtable* vtable
-                                       , void* userData ) = 0;
+        [[nodiscard]] virtual SlotPtr addObjectVTable( const std::string& objectPath
+                                                     , const std::string& interfaceName
+                                                     , const sd_bus_vtable* vtable
+                                                     , void* userData ) = 0;
 
         virtual PlainMessage createPlainMessage() const = 0;
         virtual MethodCall createMethodCall( const std::string& destination
@@ -81,13 +80,13 @@ namespace internal {
         virtual void emitInterfacesRemovedSignal( const std::string& objectPath
                                                 , const std::vector<std::string>& interfaces ) = 0;
 
-        virtual SlotPtr addObjectManager(const std::string& objectPath, void* /*dummy*/ = nullptr) = 0;
+        [[nodiscard]] virtual SlotPtr addObjectManager(const std::string& objectPath, void* /*dummy*/ = nullptr) = 0;
 
-        virtual SlotPtr registerSignalHandler( const std::string& objectPath
-                                             , const std::string& interfaceName
-                                             , const std::string& signalName
-                                             , sd_bus_message_handler_t callback
-                                             , void* userData ) = 0;
+        [[nodiscard]] virtual SlotPtr registerSignalHandler( const std::string& objectPath
+                                                           , const std::string& interfaceName
+                                                           , const std::string& signalName
+                                                           , sd_bus_message_handler_t callback
+                                                           , void* userData ) = 0;
 
         virtual void enterProcessingLoopAsync() = 0;
         virtual void leaveProcessingLoop() = 0;
@@ -95,9 +94,8 @@ namespace internal {
         virtual MethodReply tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout) = 0;
     };
 
-    std::unique_ptr<sdbus::internal::IConnection> createConnection();
+    [[nodiscard]] std::unique_ptr<sdbus::internal::IConnection> createConnection();
 
 }
-}
 
 #endif /* SDBUS_CXX_INTERNAL_ICONNECTION_H_ */

src/ISdBus.h

@@ -30,7 +30,7 @@
 
 #include <systemd/sd-bus.h>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
     class ISdBus
     {
@@ -84,6 +84,6 @@ namespace sdbus { namespace internal {
         virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) = 0;
     };
 
-}}
+}
 
 #endif //SDBUS_CXX_ISDBUS_H

src/Object.cpp

@@ -37,7 +37,7 @@
 #include <utility>
 #include <cassert>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 Object::Object(sdbus::internal::IConnection& connection, std::string objectPath)
     : connection_(connection), objectPath_(std::move(objectPath))
@@ -391,7 +391,7 @@ int Object::sdbus_property_set_callback( sd_bus */*bus*/
     return 1;
 }
 
-}}
+}
 
 namespace sdbus {
 

src/Object.h

@@ -37,8 +37,7 @@
 #include <memory>
 #include <cassert>
 
-namespace sdbus {
-namespace internal {
+namespace sdbus::internal {
 
     class Object
         : public IObject
@@ -173,6 +172,5 @@ namespace internal {
     };
 
 }
-}
 
 #endif /* SDBUS_CXX_INTERNAL_OBJECT_H_ */

src/Proxy.cpp

@@ -36,7 +36,7 @@
 #include <chrono>
 #include <thread>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 Proxy::Proxy(sdbus::internal::IConnection& connection, std::string destination, std::string objectPath)
     : connection_(&connection, [](sdbus::internal::IConnection *){ /* Intentionally left empty */ })
@@ -241,7 +241,7 @@ int Proxy::sdbus_signal_handler(sd_bus_message *sdbusMessage, void *userData, sd
     return 1;
 }
 
-}}
+}
 
 namespace sdbus {
 

src/Proxy.h

@@ -37,8 +37,7 @@
 #include <mutex>
 #include <condition_variable>
 
-namespace sdbus {
-namespace internal {
+namespace sdbus::internal {
 
     class Proxy
         : public IProxy
@@ -122,13 +121,13 @@ namespace internal {
 
             bool addCall(void* slot, std::unique_ptr<CallData>&& asyncCallData)
             {
-                std::lock_guard<std::mutex> lock(mutex_);
+                std::lock_guard lock(mutex_);
                 return calls_.emplace(slot, std::move(asyncCallData)).second;
             }
 
             bool removeCall(void* slot)
             {
-                std::lock_guard<std::mutex> lock(mutex_);
+                std::lock_guard lock(mutex_);
                 return calls_.erase(slot) > 0;
             }
 
@@ -147,6 +146,6 @@ namespace internal {
         } pendingAsyncCalls_;
     };
 
-}}
+}
 
 #endif /* SDBUS_CXX_INTERNAL_PROXY_H_ */

src/SdBus.cpp

@@ -28,74 +28,74 @@
 #include "SdBus.h"
 #include <sdbus-c++/Error.h>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 sd_bus_message* SdBus::sd_bus_message_ref(sd_bus_message *m)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_ref(m);
 }
 
 sd_bus_message* SdBus::sd_bus_message_unref(sd_bus_message *m)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_unref(m);
 }
 
 int SdBus::sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_send(bus, m, cookie);
 }
 
 int SdBus::sd_bus_call(sd_bus *bus, sd_bus_message *m, uint64_t usec, sd_bus_error *ret_error, sd_bus_message **reply)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_call(bus, m, usec, ret_error, reply);
 }
 
 int SdBus::sd_bus_call_async(sd_bus *bus, sd_bus_slot **slot, sd_bus_message *m, sd_bus_message_handler_t callback, void *userdata, uint64_t usec)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_call_async(bus, slot, m, callback, userdata, usec);
 }
 
 int SdBus::sd_bus_message_new(sd_bus *bus, sd_bus_message **m, uint8_t type)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_new(bus, m, type);
 }
 
 int SdBus::sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_new_method_call(bus, m, destination, path, interface, member);
 }
 
 int SdBus::sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_new_signal(bus, m, path, interface, member);
 }
 
 int SdBus::sd_bus_message_new_method_return(sd_bus_message *call, sd_bus_message **m)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_new_method_return(call, m);
 }
 
 int SdBus::sd_bus_message_new_method_error(sd_bus_message *call, sd_bus_message **m, const sd_bus_error *e)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_new_method_error(call, m, e);
 }
@@ -103,7 +103,7 @@ int SdBus::sd_bus_message_new_method_error(sd_bus_message *call, sd_bus_message
 int SdBus::sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec)
 {
 #if LIBSYSTEMD_VERSION>=240
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_set_method_call_timeout(bus, usec);
 #else
@@ -116,7 +116,7 @@ int SdBus::sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec)
 int SdBus::sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret)
 {
 #if LIBSYSTEMD_VERSION>=240
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_get_method_call_timeout(bus, ret);
 #else
@@ -128,35 +128,35 @@ int SdBus::sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret)
 
 int SdBus::sd_bus_emit_properties_changed_strv(sd_bus *bus, const char *path, const char *interface, char **names)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_emit_properties_changed_strv(bus, path, interface, names);
 }
 
 int SdBus::sd_bus_emit_object_added(sd_bus *bus, const char *path)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_emit_object_added(bus, path);
 }
 
 int SdBus::sd_bus_emit_object_removed(sd_bus *bus, const char *path)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_emit_object_removed(bus, path);
 }
 
 int SdBus::sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path, char **interfaces)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_emit_interfaces_added_strv(bus, path, interfaces);
 }
 
 int SdBus::sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_emit_interfaces_removed_strv(bus, path, interfaces);
 }
@@ -178,62 +178,62 @@ int SdBus::sd_bus_open_system_remote(sd_bus **ret, const char *host)
 
 int SdBus::sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_request_name(bus, name, flags);
 }
 
 int SdBus::sd_bus_release_name(sd_bus *bus, const char *name)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_release_name(bus, name);
 }
 
 int SdBus::sd_bus_get_unique_name(sd_bus *bus, const char **name)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
     return ::sd_bus_get_unique_name(bus, name);
 }
 
 int SdBus::sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_add_object_vtable(bus, slot, path, interface,  vtable, userdata);
 }
 
 int SdBus::sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_add_object_manager(bus, slot, path);
 }
 
 int SdBus::sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return :: sd_bus_add_match(bus, slot, match, callback, userdata);
 }
 
 sd_bus_slot* SdBus::sd_bus_slot_unref(sd_bus_slot *slot)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_slot_unref(slot);
 }
 
 int SdBus::sd_bus_process(sd_bus *bus, sd_bus_message **r)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_process(bus, r);
 }
 
 int SdBus::sd_bus_get_poll_data(sd_bus *bus, PollData* data)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     auto r = ::sd_bus_get_fd(bus);
     if (r < 0)
@@ -260,4 +260,4 @@ sd_bus* SdBus::sd_bus_flush_close_unref(sd_bus *bus)
     return ::sd_bus_flush_close_unref(bus);
 }
 
-}}
+}

src/SdBus.h

@@ -31,7 +31,7 @@
 #include "ISdBus.h"
 #include <mutex>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 class SdBus final : public ISdBus
 {
@@ -79,6 +79,6 @@ private:
     std::recursive_mutex sdbusMutex_;
 };
 
-}}
+}
 
 #endif //SDBUS_C_SDBUS_H