From 975f1bf07f2a0e55bc41e5af05bc2e54a8079d44 Mon Sep 17 00:00:00 2001 From: sangelovic Date: Sat, 1 Feb 2020 22:47:04 +0100 Subject: [PATCH] Switch to fully supported C++17 --- include/sdbus-c++/ConvenienceApiClasses.h | 17 ++---- include/sdbus-c++/ConvenienceApiClasses.inl | 67 +++++++++------------ include/sdbus-c++/IConnection.h | 14 ++--- include/sdbus-c++/IObject.h | 12 ++-- include/sdbus-c++/IProxy.h | 26 ++++---- include/sdbus-c++/Message.h | 18 +----- include/sdbus-c++/MethodResult.h | 5 -- include/sdbus-c++/TypeTraits.h | 33 +++------- include/sdbus-c++/Types.h | 4 -- src/Connection.cpp | 10 +-- src/Connection.h | 4 +- src/IConnection.h | 26 ++++---- src/ISdBus.h | 4 +- src/Object.cpp | 4 +- src/Object.h | 4 +- src/Proxy.cpp | 4 +- src/Proxy.h | 9 ++- src/SdBus.cpp | 56 ++++++++--------- src/SdBus.h | 4 +- 19 files changed, 129 insertions(+), 192 deletions(-) diff --git a/include/sdbus-c++/ConvenienceApiClasses.h b/include/sdbus-c++/ConvenienceApiClasses.h index 53c3663..280e465 100644 --- a/include/sdbus-c++/ConvenienceApiClasses.h +++ b/include/sdbus-c++/ConvenienceApiClasses.h @@ -46,9 +46,6 @@ namespace sdbus { namespace sdbus { - template - inline constexpr bool are_strings_v = std::conjunction...>::value; - class MethodRegistrator { public: @@ -57,16 +54,11 @@ namespace sdbus { ~MethodRegistrator() noexcept(false); MethodRegistrator& onInterface(std::string interfaceName); - template - std::enable_if_t, MethodRegistrator&> implementedAs(_Function&& callback); - template - std::enable_if_t, MethodRegistrator&> implementedAs(_Function&& callback); + template MethodRegistrator& implementedAs(_Function&& callback); MethodRegistrator& withInputParamNames(std::vector paramNames); - template - std::enable_if_t, MethodRegistrator&> withInputParamNames(_String... paramNames); + template MethodRegistrator& withInputParamNames(_String... paramNames); MethodRegistrator& withOutputParamNames(std::vector paramNames); - template - std::enable_if_t, MethodRegistrator&> withOutputParamNames(_String... paramNames); + template MethodRegistrator& withOutputParamNames(_String... paramNames); MethodRegistrator& markAsDeprecated(); MethodRegistrator& markAsPrivileged(); MethodRegistrator& withNoReply(); @@ -94,8 +86,7 @@ namespace sdbus { SignalRegistrator& onInterface(std::string interfaceName); template SignalRegistrator& withParameters(); template SignalRegistrator& withParameters(std::vector paramNames); - template - std::enable_if_t, SignalRegistrator&> withParameters(_String... paramNames); + template SignalRegistrator& withParameters(_String... paramNames); SignalRegistrator& markAsDeprecated(); private: diff --git a/include/sdbus-c++/ConvenienceApiClasses.inl b/include/sdbus-c++/ConvenienceApiClasses.inl index f4a3b40..977dcdf 100644 --- a/include/sdbus-c++/ConvenienceApiClasses.inl +++ b/include/sdbus-c++/ConvenienceApiClasses.inl @@ -88,38 +88,7 @@ namespace sdbus { } template - inline std::enable_if_t, MethodRegistrator&> - MethodRegistrator::implementedAs(_Function&& callback) - { - inputSignature_ = signature_of_function_input_arguments<_Function>::str(); - outputSignature_ = signature_of_function_output_arguments<_Function>::str(); - methodCallback_ = [callback = std::forward<_Function>(callback)](MethodCall call) - { - // Create a tuple of callback input arguments' types, which will be used - // as a storage for the argument values deserialized from the message. - tuple_of_function_input_arg_types_t<_Function> inputArgs; - - // Deserialize input arguments from the message into the tuple - call >> inputArgs; - - // Invoke callback with input arguments from the tuple. - // For callbacks returning a non-void value, `apply' also returns that value. - // For callbacks returning void, `apply' returns an empty tuple. - auto ret = sdbus::apply(callback, inputArgs); // We don't yet have C++17's std::apply :-( - - // The return value is stored to the reply message. - // In case of void functions, ret is an empty tuple and thus nothing is stored. - auto reply = call.createReply(); - reply << ret; - reply.send(); - }; - - return *this; - } - - template - inline std::enable_if_t, MethodRegistrator&> - MethodRegistrator::implementedAs(_Function&& callback) + MethodRegistrator& MethodRegistrator::implementedAs(_Function&& callback) { inputSignature_ = signature_of_function_input_arguments<_Function>::str(); outputSignature_ = signature_of_function_output_arguments<_Function>::str(); @@ -132,8 +101,22 @@ namespace sdbus { // Deserialize input arguments from the message into the tuple. call >> inputArgs; - // Invoke callback with input arguments from the tuple. - sdbus::apply(callback, typename function_traits<_Function>::async_result_t{std::move(call)}, std::move(inputArgs)); + if constexpr (!is_async_method_v<_Function>) + { + // Invoke callback with input arguments from the tuple. + auto ret = sdbus::apply(callback, inputArgs); + + // Store output arguments to the reply message and send it back. + auto reply = call.createReply(); + reply << ret; + reply.send(); + } + else + { + // Invoke callback with input arguments from the tuple and with result object to be set later + using AsyncResult = typename function_traits<_Function>::async_result_t; + sdbus::apply(callback, AsyncResult{std::move(call)}, std::move(inputArgs)); + } }; return *this; @@ -147,8 +130,10 @@ namespace sdbus { } template - inline std::enable_if_t, MethodRegistrator&> MethodRegistrator::withInputParamNames(_String... paramNames) + inline MethodRegistrator& MethodRegistrator::withInputParamNames(_String... paramNames) { + static_assert(std::conjunction_v...>, "Parameter names must be (convertible to) strings"); + return withInputParamNames({paramNames...}); } @@ -160,8 +145,10 @@ namespace sdbus { } template - inline std::enable_if_t, MethodRegistrator&> MethodRegistrator::withOutputParamNames(_String... paramNames) + inline MethodRegistrator& MethodRegistrator::withOutputParamNames(_String... paramNames) { + static_assert(std::conjunction_v...>, "Parameter names must be (convertible to) strings"); + return withOutputParamNames({paramNames...}); } @@ -245,9 +232,9 @@ namespace sdbus { } template - inline std::enable_if_t, SignalRegistrator&> - SignalRegistrator::withParameters(_String... paramNames) + inline SignalRegistrator& SignalRegistrator::withParameters(_String... paramNames) { + static_assert(std::conjunction_v...>, "Parameter names must be (convertible to) strings"); static_assert(sizeof...(_Args) == sizeof...(_String), "Numbers of signal parameters and their names don't match"); return withParameters<_Args...>({paramNames...}); @@ -604,7 +591,7 @@ namespace sdbus { reply >> args; // Invoke callback with input arguments from the tuple. - sdbus::apply(callback, error, args); // TODO: Use std::apply when switching to full C++17 support + sdbus::apply(callback, error, args); }; proxy_.callMethod(method_, std::move(asyncReplyHandler), timeout_); @@ -644,7 +631,7 @@ namespace sdbus { signal >> signalArgs; // Invoke callback with input arguments from the tuple. - sdbus::apply(callback, signalArgs); // We don't yet have C++17's std::apply :-( + sdbus::apply(callback, signalArgs); }); } diff --git a/include/sdbus-c++/IConnection.h b/include/sdbus-c++/IConnection.h index 462d771..1132cdf 100644 --- a/include/sdbus-c++/IConnection.h +++ b/include/sdbus-c++/IConnection.h @@ -200,7 +200,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - std::unique_ptr createConnection(); + [[nodiscard]] std::unique_ptr createConnection(); /*! * @brief Creates/opens D-Bus system connection with a name @@ -210,7 +210,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - std::unique_ptr createConnection(const std::string& name); + [[nodiscard]] std::unique_ptr createConnection(const std::string& name); /*! * @brief Creates/opens D-Bus system connection @@ -219,7 +219,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - std::unique_ptr createSystemBusConnection(); + [[nodiscard]] std::unique_ptr createSystemBusConnection(); /*! * @brief Creates/opens D-Bus system connection with a name @@ -229,7 +229,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - std::unique_ptr createSystemBusConnection(const std::string& name); + [[nodiscard]] std::unique_ptr createSystemBusConnection(const std::string& name); /*! * @brief Creates/opens D-Bus session connection @@ -238,7 +238,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - std::unique_ptr createSessionBusConnection(); + [[nodiscard]] std::unique_ptr createSessionBusConnection(); /*! * @brief Creates/opens D-Bus session connection with a name @@ -248,7 +248,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - std::unique_ptr createSessionBusConnection(const std::string& name); + [[nodiscard]] std::unique_ptr createSessionBusConnection(const std::string& name); /*! * @brief Creates/opens D-Bus system connection on a remote host using ssh @@ -258,7 +258,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - std::unique_ptr createRemoteSystemBusConnection(const std::string& host); + [[nodiscard]] std::unique_ptr createRemoteSystemBusConnection(const std::string& host); } #endif /* SDBUS_CXX_ICONNECTION_H_ */ diff --git a/include/sdbus-c++/IObject.h b/include/sdbus-c++/IObject.h index 78d6b9e..dec1801 100644 --- a/include/sdbus-c++/IObject.h +++ b/include/sdbus-c++/IObject.h @@ -358,7 +358,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - MethodRegistrator registerMethod(const std::string& methodName); + [[nodiscard]] MethodRegistrator registerMethod(const std::string& methodName); /*! * @brief Registers signal that the object will provide on D-Bus @@ -377,7 +377,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - SignalRegistrator registerSignal(const std::string& signalName); + [[nodiscard]] SignalRegistrator registerSignal(const std::string& signalName); /*! * @brief Registers property that the object will provide on D-Bus @@ -396,7 +396,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - PropertyRegistrator registerProperty(const std::string& propertyName); + [[nodiscard]] PropertyRegistrator registerProperty(const std::string& propertyName); /*! * @brief Sets flags (annotations) for a given interface @@ -413,7 +413,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - InterfaceFlagsSetter setInterfaceFlags(const std::string& interfaceName); + [[nodiscard]] InterfaceFlagsSetter setInterfaceFlags(const std::string& interfaceName); /*! * @brief Emits signal on D-Bus @@ -434,7 +434,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - SignalEmitter emitSignal(const std::string& signalName); + [[nodiscard]] SignalEmitter emitSignal(const std::string& signalName); }; // Out-of-line member definitions @@ -482,7 +482,7 @@ namespace sdbus { * auto proxy = sdbus::createObject(connection, "/com/kistler/foo"); * @endcode */ - std::unique_ptr createObject(sdbus::IConnection& connection, std::string objectPath); + [[nodiscard]] std::unique_ptr createObject(sdbus::IConnection& connection, std::string objectPath); } diff --git a/include/sdbus-c++/IProxy.h b/include/sdbus-c++/IProxy.h index 054fd33..7d51b64 100644 --- a/include/sdbus-c++/IProxy.h +++ b/include/sdbus-c++/IProxy.h @@ -178,7 +178,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - MethodInvoker callMethod(const std::string& methodName); + [[nodiscard]] MethodInvoker callMethod(const std::string& methodName); /*! * @brief Calls method on the proxied D-Bus object asynchronously @@ -202,7 +202,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - AsyncMethodInvoker callMethodAsync(const std::string& methodName); + [[nodiscard]] AsyncMethodInvoker callMethodAsync(const std::string& methodName); /*! * @brief Registers signal handler for a given signal of the proxied D-Bus object @@ -222,7 +222,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - SignalSubscriber uponSignal(const std::string& signalName); + [[nodiscard]] SignalSubscriber uponSignal(const std::string& signalName); /*! * @brief Gets value of a property of the proxied D-Bus object @@ -241,7 +241,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - PropertyGetter getProperty(const std::string& propertyName); + [[nodiscard]] PropertyGetter getProperty(const std::string& propertyName); /*! * @brief Sets value of a property of the proxied D-Bus object @@ -260,7 +260,7 @@ namespace sdbus { * * @throws sdbus::Error in case of failure */ - PropertySetter setProperty(const std::string& propertyName); + [[nodiscard]] PropertySetter setProperty(const std::string& propertyName); }; // Out-of-line member definitions @@ -323,9 +323,9 @@ namespace sdbus { * auto proxy = sdbus::createProxy(connection, "com.kistler.foo", "/com/kistler/foo"); * @endcode */ - std::unique_ptr createProxy( sdbus::IConnection& connection - , std::string destination - , std::string objectPath ); + [[nodiscard]] std::unique_ptr createProxy( sdbus::IConnection& connection + , std::string destination + , std::string objectPath ); /*! * @brief Creates a proxy object for a specific remote D-Bus object @@ -346,9 +346,9 @@ namespace sdbus { * auto proxy = sdbus::createProxy(std::move(connection), "com.kistler.foo", "/com/kistler/foo"); * @endcode */ - std::unique_ptr createProxy( std::unique_ptr&& connection - , std::string destination - , std::string objectPath ); + [[nodiscard]] std::unique_ptr createProxy( std::unique_ptr&& connection + , std::string destination + , std::string objectPath ); /*! * @brief Creates a proxy object for a specific remote D-Bus object @@ -367,8 +367,8 @@ namespace sdbus { * auto proxy = sdbus::createProxy("com.kistler.foo", "/com/kistler/foo"); * @endcode */ - std::unique_ptr createProxy( std::string destination - , std::string objectPath ); + [[nodiscard]] std::unique_ptr createProxy( std::string destination + , std::string objectPath ); } diff --git a/include/sdbus-c++/Message.h b/include/sdbus-c++/Message.h index 7f6840b..55455df 100644 --- a/include/sdbus-c++/Message.h +++ b/include/sdbus-c++/Message.h @@ -55,11 +55,7 @@ namespace sdbus { // Assume the caller has already obtained message ownership struct adopt_message_t { explicit adopt_message_t() = default; }; -#ifdef __cpp_inline_variables inline constexpr adopt_message_t adopt_message{}; -#else - constexpr adopt_message_t adopt_message{}; -#endif /********************************************//** * @class Message @@ -166,11 +162,7 @@ namespace sdbus { }; struct dont_request_slot_t { explicit dont_request_slot_t() = default; }; -#ifdef __cpp_inline_variables inline constexpr dont_request_slot_t dont_request_slot{}; -#else - constexpr dont_request_slot_t dont_request_slot{}; -#endif class MethodCall : public Message { @@ -283,10 +275,7 @@ namespace sdbus { template void serialize_pack(Message& msg, _Args&&... args) { - // Use initializer_list because it guarantees left to right order, and can be empty - using _ = std::initializer_list; - // We are not interested in the list itself, but in the side effects - (void)_{(void(msg << std::forward<_Args>(args)), 0)...}; + (msg << ... << args); } template @@ -378,10 +367,7 @@ namespace sdbus { template void deserialize_pack(Message& msg, _Args&... args) { - // Use initializer_list because it guarantees left to right order, and can be empty - using _ = std::initializer_list; - // We are not interested in the list itself, but in the side effects - (void)_{(void(msg >> args), 0)...}; + (msg >> ... >> args); } template diff --git a/include/sdbus-c++/MethodResult.h b/include/sdbus-c++/MethodResult.h index 1428310..bf4c177 100644 --- a/include/sdbus-c++/MethodResult.h +++ b/include/sdbus-c++/MethodResult.h @@ -76,12 +76,7 @@ namespace sdbus { { assert(call_.isValid()); auto reply = call_.createReply(); -#ifdef __cpp_fold_expressions (reply << ... << results); -#else - using _ = std::initializer_list; - (void)_{(void(reply << results), 0)...}; -#endif reply.send(); } diff --git a/include/sdbus-c++/TypeTraits.h b/include/sdbus-c++/TypeTraits.h index 11a930b..db1f85c 100644 --- a/include/sdbus-c++/TypeTraits.h +++ b/include/sdbus-c++/TypeTraits.h @@ -245,11 +245,9 @@ namespace sdbus { static const std::string str() { - std::initializer_list signatures{signature_of<_ValueTypes>::str()...}; std::string signature; signature += "("; - for (const auto& item : signatures) - signature += item; + (signature += ... += signature_of<_ValueTypes>::str()); signature += ")"; return signature; } @@ -489,11 +487,8 @@ namespace sdbus { { static const std::string str() { - // TODO: This could be a fold expression in C++17... - std::initializer_list signatures{signature_of>::str()...}; std::string signature; - for (const auto& item : signatures) - signature += item; + (signature += ... += signature_of>::str()); return signature; } }; @@ -536,27 +531,17 @@ namespace sdbus { return std::forward<_Function>(f)(e, std::get<_I>(std::forward<_Tuple>(t))...); } - // Version of apply_impl for functions returning non-void values. - // In this case just forward function return value. + // For non-void returning functions, apply_impl simply returns function return value (a tuple of values). + // For void-returning functions, apply_impl returns an empty tuple. template constexpr decltype(auto) apply_impl( _Function&& f , _Tuple&& t - , std::index_sequence<_I...> - , std::enable_if_t>::value>* = nullptr) + , std::index_sequence<_I...> ) { - return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...); - } - - // Version of apply_impl for functions returning void. - // In this case, to have uniform code on the caller side, return empty tuple, our synonym for `void'. - template - constexpr decltype(auto) apply_impl( _Function&& f - , _Tuple&& t - , std::index_sequence<_I...> - , std::enable_if_t>::value>* = nullptr) - { - std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...); - return std::tuple<>{}; + if constexpr (!std::is_void_v>) + return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...); + else + return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...), std::tuple<>{}; } } diff --git a/include/sdbus-c++/Types.h b/include/sdbus-c++/Types.h index 7027170..74eaef5 100644 --- a/include/sdbus-c++/Types.h +++ b/include/sdbus-c++/Types.h @@ -178,11 +178,7 @@ namespace sdbus { }; struct adopt_fd_t { explicit adopt_fd_t() = default; }; -#ifdef __cpp_inline_variables inline constexpr adopt_fd_t adopt_fd{}; -#else - constexpr adopt_fd_t adopt_fd{}; -#endif /********************************************//** * @struct UnixFd diff --git a/src/Connection.cpp b/src/Connection.cpp index a11a4c6..eca5b5c 100644 --- a/src/Connection.cpp +++ b/src/Connection.cpp @@ -35,7 +35,7 @@ #include #include -namespace sdbus { namespace internal { +namespace sdbus::internal { Connection::Connection(std::unique_ptr&& 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 createConnection() { auto connection = sdbus::createConnection(); @@ -466,8 +465,11 @@ std::unique_ptr createConnection() auto connectionInternal = dynamic_cast(connection.get()); return std::unique_ptr(connectionInternal); } + } +namespace sdbus { + std::unique_ptr createConnection() { return createSystemBusConnection(); diff --git a/src/Connection.h b/src/Connection.h index b374290..24cf4fb 100644 --- a/src/Connection.h +++ b/src/Connection.h @@ -40,7 +40,7 @@ #include #include -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_ */ diff --git a/src/IConnection.h b/src/IConnection.h index a0d289f..f50ccf7 100644 --- a/src/IConnection.h +++ b/src/IConnection.h @@ -44,8 +44,7 @@ namespace sdbus { } } -namespace sdbus { -namespace internal { +namespace sdbus::internal { using SlotPtr = std::unique_ptr>; @@ -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& 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 createConnection(); + [[nodiscard]] std::unique_ptr createConnection(); } -} #endif /* SDBUS_CXX_INTERNAL_ICONNECTION_H_ */ diff --git a/src/ISdBus.h b/src/ISdBus.h index a5dc994..5044b06 100644 --- a/src/ISdBus.h +++ b/src/ISdBus.h @@ -30,7 +30,7 @@ #include -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 diff --git a/src/Object.cpp b/src/Object.cpp index b1a4bc8..2a2c54f 100644 --- a/src/Object.cpp +++ b/src/Object.cpp @@ -37,7 +37,7 @@ #include #include -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 { diff --git a/src/Object.h b/src/Object.h index f5b4545..1641769 100644 --- a/src/Object.h +++ b/src/Object.h @@ -37,8 +37,7 @@ #include #include -namespace sdbus { -namespace internal { +namespace sdbus::internal { class Object : public IObject @@ -173,6 +172,5 @@ namespace internal { }; } -} #endif /* SDBUS_CXX_INTERNAL_OBJECT_H_ */ diff --git a/src/Proxy.cpp b/src/Proxy.cpp index dbcfe21..b404842 100644 --- a/src/Proxy.cpp +++ b/src/Proxy.cpp @@ -36,7 +36,7 @@ #include #include -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 { diff --git a/src/Proxy.h b/src/Proxy.h index 1b0dfbc..4c35997 100644 --- a/src/Proxy.h +++ b/src/Proxy.h @@ -37,8 +37,7 @@ #include #include -namespace sdbus { -namespace internal { +namespace sdbus::internal { class Proxy : public IProxy @@ -122,13 +121,13 @@ namespace internal { bool addCall(void* slot, std::unique_ptr&& asyncCallData) { - std::lock_guard lock(mutex_); + std::lock_guard lock(mutex_); return calls_.emplace(slot, std::move(asyncCallData)).second; } bool removeCall(void* slot) { - std::lock_guard 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_ */ diff --git a/src/SdBus.cpp b/src/SdBus.cpp index 5acee87..3bc689c 100644 --- a/src/SdBus.cpp +++ b/src/SdBus.cpp @@ -28,74 +28,74 @@ #include "SdBus.h" #include -namespace sdbus { namespace internal { +namespace sdbus::internal { sd_bus_message* SdBus::sd_bus_message_ref(sd_bus_message *m) { - std::unique_lock 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); } -}} +} diff --git a/src/SdBus.h b/src/SdBus.h index ef8d461..ebc0a3c 100644 --- a/src/SdBus.h +++ b/src/SdBus.h @@ -31,7 +31,7 @@ #include "ISdBus.h" #include -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