Kistler-Group/sdbus-cpp
1
0
Fork 1
mirror of https://github.com/Kistler-Group/sdbus-cpp.git synced 2025-07-30 18:17:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Switch to fully supported C++17

Browse Source
This commit is contained in:
sangelovic
2020-02-01 22:47:04 +01:00
committed by Stanislav Angelovič
parent d591b69f92
commit 975f1bf07f
19 changed files with 129 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
include/sdbus-c++/ConvenienceApiClasses.h
View File

@ -46,9 +46,6 @@ namespace sdbus {
namespace sdbus { namespace sdbus {
template <typename... _Args>
inline constexpr bool are_strings_v = std::conjunction<std::is_convertible<_Args, std::string>...>::value;
class MethodRegistrator class MethodRegistrator
{ {
public: public:
@ -57,16 +54,11 @@ namespace sdbus {
~MethodRegistrator() noexcept(false); ~MethodRegistrator() noexcept(false);
MethodRegistrator& onInterface(std::string interfaceName); MethodRegistrator& onInterface(std::string interfaceName);
template <typename _Function> template <typename _Function> MethodRegistrator& implementedAs(_Function&& callback);
std::enable_if_t<!is_async_method_v<_Function>, MethodRegistrator&> implementedAs(_Function&& callback);
template <typename _Function>
std::enable_if_t<is_async_method_v<_Function>, MethodRegistrator&> implementedAs(_Function&& callback);
MethodRegistrator& withInputParamNames(std::vector<std::string> paramNames); MethodRegistrator& withInputParamNames(std::vector<std::string> paramNames);
template <typename... _String> template <typename... _String> MethodRegistrator& withInputParamNames(_String... paramNames);
std::enable_if_t<are_strings_v<_String...>, MethodRegistrator&> withInputParamNames(_String... paramNames);
MethodRegistrator& withOutputParamNames(std::vector<std::string> paramNames); MethodRegistrator& withOutputParamNames(std::vector<std::string> paramNames);
template <typename... _String> template <typename... _String> MethodRegistrator& withOutputParamNames(_String... paramNames);
std::enable_if_t<are_strings_v<_String...>, MethodRegistrator&> withOutputParamNames(_String... paramNames);
MethodRegistrator& markAsDeprecated(); MethodRegistrator& markAsDeprecated();
MethodRegistrator& markAsPrivileged(); MethodRegistrator& markAsPrivileged();
MethodRegistrator& withNoReply(); MethodRegistrator& withNoReply();
@ -94,8 +86,7 @@ namespace sdbus {
SignalRegistrator& onInterface(std::string interfaceName); SignalRegistrator& onInterface(std::string interfaceName);
template <typename... _Args> SignalRegistrator& withParameters(); template <typename... _Args> SignalRegistrator& withParameters();
template <typename... _Args> SignalRegistrator& withParameters(std::vector<std::string> paramNames); template <typename... _Args> SignalRegistrator& withParameters(std::vector<std::string> paramNames);
template <typename... _Args, typename... _String> template <typename... _Args, typename... _String> SignalRegistrator& withParameters(_String... paramNames);
std::enable_if_t<are_strings_v<_String...>, SignalRegistrator&> withParameters(_String... paramNames);
SignalRegistrator& markAsDeprecated(); SignalRegistrator& markAsDeprecated();
private: private:

67
include/sdbus-c++/ConvenienceApiClasses.inl
View File

@ -88,38 +88,7 @@ namespace sdbus {
} }
template <typename _Function> template <typename _Function>
inline std::enable_if_t<!is_async_method_v<_Function>, MethodRegistrator&> MethodRegistrator& MethodRegistrator::implementedAs(_Function&& callback)
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 <typename _Function>
inline std::enable_if_t<is_async_method_v<_Function>, MethodRegistrator&>
MethodRegistrator::implementedAs(_Function&& callback)
{ {
inputSignature_ = signature_of_function_input_arguments<_Function>::str(); inputSignature_ = signature_of_function_input_arguments<_Function>::str();
outputSignature_ = signature_of_function_output_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. // Deserialize input arguments from the message into the tuple.
call >> inputArgs; call >> inputArgs;
// Invoke callback with input arguments from the tuple. if constexpr (!is_async_method_v<_Function>)
sdbus::apply(callback, typename function_traits<_Function>::async_result_t{std::move(call)}, std::move(inputArgs)); {
// 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; return *this;
@ -147,8 +130,10 @@ namespace sdbus {
} }
template <typename... _String> template <typename... _String>
inline std::enable_if_t<are_strings_v<_String...>, MethodRegistrator&> MethodRegistrator::withInputParamNames(_String... paramNames) inline MethodRegistrator& MethodRegistrator::withInputParamNames(_String... paramNames)
{ {
static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
return withInputParamNames({paramNames...}); return withInputParamNames({paramNames...});
} }
@ -160,8 +145,10 @@ namespace sdbus {
} }
template <typename... _String> template <typename... _String>
inline std::enable_if_t<are_strings_v<_String...>, MethodRegistrator&> MethodRegistrator::withOutputParamNames(_String... paramNames) inline MethodRegistrator& MethodRegistrator::withOutputParamNames(_String... paramNames)
{ {
static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
return withOutputParamNames({paramNames...}); return withOutputParamNames({paramNames...});
} }
@ -245,9 +232,9 @@ namespace sdbus {
} }
template <typename... _Args, typename... _String> template <typename... _Args, typename... _String>
inline std::enable_if_t<are_strings_v<_String...>, SignalRegistrator&> inline SignalRegistrator& SignalRegistrator::withParameters(_String... paramNames)
SignalRegistrator::withParameters(_String... paramNames)
{ {
static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
static_assert(sizeof...(_Args) == sizeof...(_String), "Numbers of signal parameters and their names don't match"); static_assert(sizeof...(_Args) == sizeof...(_String), "Numbers of signal parameters and their names don't match");
return withParameters<_Args...>({paramNames...}); return withParameters<_Args...>({paramNames...});
@ -604,7 +591,7 @@ namespace sdbus {
reply >> args; reply >> args;
// Invoke callback with input arguments from the tuple. // 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_); proxy_.callMethod(method_, std::move(asyncReplyHandler), timeout_);
@ -644,7 +631,7 @@ namespace sdbus {
signal >> signalArgs; signal >> signalArgs;
// Invoke callback with input arguments from the tuple. // 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);
}); });
} }

14
include/sdbus-c++/IConnection.h
View File

@ -200,7 +200,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @throws sdbus::Error in case of failure
*/ */
std::unique_ptr<sdbus::IConnection> createConnection(); [[nodiscard]] std::unique_ptr<sdbus::IConnection> createConnection();
/*! /*!
* @brief Creates/opens D-Bus system connection with a name * @brief Creates/opens D-Bus system connection with a name
@ -210,7 +210,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @throws sdbus::Error in case of failure
*/ */
std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name); [[nodiscard]] std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name);
/*! /*!
* @brief Creates/opens D-Bus system connection * @brief Creates/opens D-Bus system connection
@ -219,7 +219,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @throws sdbus::Error in case of failure
*/ */
std::unique_ptr<sdbus::IConnection> createSystemBusConnection(); [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSystemBusConnection();
/*! /*!
* @brief Creates/opens D-Bus system connection with a name * @brief Creates/opens D-Bus system connection with a name
@ -229,7 +229,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @throws sdbus::Error in case of failure
*/ */
std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name); [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name);
/*! /*!
* @brief Creates/opens D-Bus session connection * @brief Creates/opens D-Bus session connection
@ -238,7 +238,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @throws sdbus::Error in case of failure
*/ */
std::unique_ptr<sdbus::IConnection> createSessionBusConnection(); [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSessionBusConnection();
/*! /*!
* @brief Creates/opens D-Bus session connection with a name * @brief Creates/opens D-Bus session connection with a name
@ -248,7 +248,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @throws sdbus::Error in case of failure
*/ */
std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name); [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name);
/*! /*!
* @brief Creates/opens D-Bus system connection on a remote host using ssh * @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 * @throws sdbus::Error in case of failure
*/ */
std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host); [[nodiscard]] std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host);
} }
#endif /* SDBUS_CXX_ICONNECTION_H_ */ #endif /* SDBUS_CXX_ICONNECTION_H_ */

12
include/sdbus-c++/IObject.h
View File

@ -358,7 +358,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @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 * @brief Registers signal that the object will provide on D-Bus
@ -377,7 +377,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @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 * @brief Registers property that the object will provide on D-Bus
@ -396,7 +396,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @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 * @brief Sets flags (annotations) for a given interface
@ -413,7 +413,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @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 * @brief Emits signal on D-Bus
@ -434,7 +434,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @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 // Out-of-line member definitions
@ -482,7 +482,7 @@ namespace sdbus {
* auto proxy = sdbus::createObject(connection, "/com/kistler/foo"); * auto proxy = sdbus::createObject(connection, "/com/kistler/foo");
* @endcode * @endcode
*/ */
std::unique_ptr<sdbus::IObject> createObject(sdbus::IConnection& connection, std::string objectPath); [[nodiscard]] std::unique_ptr<sdbus::IObject> createObject(sdbus::IConnection& connection, std::string objectPath);
} }

26
include/sdbus-c++/IProxy.h
View File

@ -178,7 +178,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @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 * @brief Calls method on the proxied D-Bus object asynchronously
@ -202,7 +202,7 @@ namespace sdbus {
* *
* @throws sdbus::Error in case of failure * @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 * @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 * @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 * @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 * @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 * @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 * @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 // Out-of-line member definitions
@ -323,9 +323,9 @@ namespace sdbus {
* auto proxy = sdbus::createProxy(connection, "com.kistler.foo", "/com/kistler/foo"); * auto proxy = sdbus::createProxy(connection, "com.kistler.foo", "/com/kistler/foo");
* @endcode * @endcode
*/ */
std::unique_ptr<sdbus::IProxy> createProxy( sdbus::IConnection& connection [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( sdbus::IConnection& connection
, std::string destination , std::string destination
, std::string objectPath ); , std::string objectPath );
/*! /*!
* @brief Creates a proxy object for a specific remote D-Bus object * @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"); * auto proxy = sdbus::createProxy(std::move(connection), "com.kistler.foo", "/com/kistler/foo");
* @endcode * @endcode
*/ */
std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<sdbus::IConnection>&& connection [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<sdbus::IConnection>&& connection
, std::string destination , std::string destination
, std::string objectPath ); , std::string objectPath );
/*! /*!
* @brief Creates a proxy object for a specific remote D-Bus object * @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"); * auto proxy = sdbus::createProxy("com.kistler.foo", "/com/kistler/foo");
* @endcode * @endcode
*/ */
std::unique_ptr<sdbus::IProxy> createProxy( std::string destination [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
, std::string objectPath ); , std::string objectPath );
} }

18
include/sdbus-c++/Message.h
View File

@ -55,11 +55,7 @@ namespace sdbus {
// Assume the caller has already obtained message ownership // Assume the caller has already obtained message ownership
struct adopt_message_t { explicit adopt_message_t() = default; }; struct adopt_message_t { explicit adopt_message_t() = default; };
#ifdef __cpp_inline_variables
inline constexpr adopt_message_t adopt_message{}; inline constexpr adopt_message_t adopt_message{};
#else
constexpr adopt_message_t adopt_message{};
#endif
/********************************************//** /********************************************//**
* @class Message * @class Message
@ -166,11 +162,7 @@ namespace sdbus {
}; };
struct dont_request_slot_t { explicit dont_request_slot_t() = default; }; struct dont_request_slot_t { explicit dont_request_slot_t() = default; };
#ifdef __cpp_inline_variables
inline constexpr dont_request_slot_t dont_request_slot{}; inline constexpr dont_request_slot_t dont_request_slot{};
#else
constexpr dont_request_slot_t dont_request_slot{};
#endif
class MethodCall : public Message class MethodCall : public Message
{ {
@ -283,10 +275,7 @@ namespace sdbus {
template <typename... _Args> template <typename... _Args>
void serialize_pack(Message& msg, _Args&&... args) void serialize_pack(Message& msg, _Args&&... args)
{ {
// Use initializer_list because it guarantees left to right order, and can be empty (msg << ... << args);
using _ = std::initializer_list<int>;
// We are not interested in the list itself, but in the side effects
(void)_{(void(msg << std::forward<_Args>(args)), 0)...};
} }
template <class _Tuple, std::size_t... _Is> template <class _Tuple, std::size_t... _Is>
@ -378,10 +367,7 @@ namespace sdbus {
template <typename... _Args> template <typename... _Args>
void deserialize_pack(Message& msg, _Args&... args) void deserialize_pack(Message& msg, _Args&... args)
{ {
// Use initializer_list because it guarantees left to right order, and can be empty (msg >> ... >> args);
using _ = std::initializer_list<int>;
// We are not interested in the list itself, but in the side effects
(void)_{(void(msg >> args), 0)...};
} }
template <class _Tuple, std::size_t... _Is> template <class _Tuple, std::size_t... _Is>

5
include/sdbus-c++/MethodResult.h
View File

@ -76,12 +76,7 @@ namespace sdbus {
{ {
assert(call_.isValid()); assert(call_.isValid());
auto reply = call_.createReply(); auto reply = call_.createReply();
#ifdef __cpp_fold_expressions
(reply << ... << results); (reply << ... << results);
#else
using _ = std::initializer_list<int>;
(void)_{(void(reply << results), 0)...};
#endif
reply.send(); reply.send();
} }

33
include/sdbus-c++/TypeTraits.h
View File

@ -245,11 +245,9 @@ namespace sdbus {
static const std::string str() static const std::string str()
{ {
std::initializer_list<std::string> signatures{signature_of<_ValueTypes>::str()...};
std::string signature; std::string signature;
signature += "("; signature += "(";
for (const auto& item : signatures) (signature += ... += signature_of<_ValueTypes>::str());
signature += item;
signature += ")"; signature += ")";
return signature; return signature;
} }
@ -489,11 +487,8 @@ namespace sdbus {
{ {
static const std::string str() static const std::string str()
{ {
// TODO: This could be a fold expression in C++17...
std::initializer_list<std::string> signatures{signature_of<std::decay_t<_Types>>::str()...};
std::string signature; std::string signature;
for (const auto& item : signatures) (signature += ... += signature_of<std::decay_t<_Types>>::str());
signature += item;
return signature; return signature;
} }
}; };
@ -536,27 +531,17 @@ namespace sdbus {
return std::forward<_Function>(f)(e, std::get<_I>(std::forward<_Tuple>(t))...); return std::forward<_Function>(f)(e, std::get<_I>(std::forward<_Tuple>(t))...);
} }
// Version of apply_impl for functions returning non-void values. // For non-void returning functions, apply_impl simply returns function return value (a tuple of values).
// In this case just forward function return value. // For void-returning functions, apply_impl returns an empty tuple.
template <class _Function, class _Tuple, std::size_t... _I> template <class _Function, class _Tuple, std::size_t... _I>
constexpr decltype(auto) apply_impl( _Function&& f constexpr decltype(auto) apply_impl( _Function&& f
, _Tuple&& t , _Tuple&& t
, std::index_sequence<_I...> , std::index_sequence<_I...> )
, std::enable_if_t<!std::is_void<function_result_t<_Function>>::value>* = nullptr)
{ {
return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...); if constexpr (!std::is_void_v<function_result_t<_Function>>)
} return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...);
else
// Version of apply_impl for functions returning void. return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...), std::tuple<>{};
// In this case, to have uniform code on the caller side, return empty tuple, our synonym for `void'.
template <class _Function, class _Tuple, std::size_t... _I>
constexpr decltype(auto) apply_impl( _Function&& f
, _Tuple&& t
, std::index_sequence<_I...>
, std::enable_if_t<std::is_void<function_result_t<_Function>>::value>* = nullptr)
{
std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...);
return std::tuple<>{};
} }
} }

4
include/sdbus-c++/Types.h
View File

@ -178,11 +178,7 @@ namespace sdbus {
}; };
struct adopt_fd_t { explicit adopt_fd_t() = default; }; struct adopt_fd_t { explicit adopt_fd_t() = default; };
#ifdef __cpp_inline_variables
inline constexpr adopt_fd_t adopt_fd{}; inline constexpr adopt_fd_t adopt_fd{};
#else
constexpr adopt_fd_t adopt_fd{};
#endif
/********************************************//** /********************************************//**
* @struct UnixFd * @struct UnixFd

10
src/Connection.cpp
View File

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

4
src/Connection.h
View File

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

26
src/IConnection.h
View File

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

4
src/ISdBus.h
View File

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

4
src/Object.cpp
View File

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

4
src/Object.h
View File

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

4
src/Proxy.cpp
View File

@ -36,7 +36,7 @@
#include <chrono> #include <chrono>
#include <thread> #include <thread>
namespace sdbus { namespace internal { namespace sdbus::internal {
Proxy::Proxy(sdbus::internal::IConnection& connection, std::string destination, std::string objectPath) Proxy::Proxy(sdbus::internal::IConnection& connection, std::string destination, std::string objectPath)
: connection_(&connection, [](sdbus::internal::IConnection *){ /* Intentionally left empty */ }) : 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; return 1;
} }
}} }
namespace sdbus { namespace sdbus {

9
src/Proxy.h
View File

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

56
src/SdBus.cpp
View File

@ -28,74 +28,74 @@
#include "SdBus.h" #include "SdBus.h"
#include <sdbus-c++/Error.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) 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); return ::sd_bus_message_ref(m);
} }
sd_bus_message* SdBus::sd_bus_message_unref(sd_bus_message *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); return ::sd_bus_message_unref(m);
} }
int SdBus::sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) 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); 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) 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); 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) 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); 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) 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); 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) 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); 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) 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); 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) 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); 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) 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); 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) int SdBus::sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec)
{ {
#if LIBSYSTEMD_VERSION>=240 #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); return ::sd_bus_set_method_call_timeout(bus, usec);
#else #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) int SdBus::sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret)
{ {
#if LIBSYSTEMD_VERSION>=240 #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); return ::sd_bus_get_method_call_timeout(bus, ret);
#else #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) 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); return ::sd_bus_emit_properties_changed_strv(bus, path, interface, names);
} }
int SdBus::sd_bus_emit_object_added(sd_bus *bus, const char *path) 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); return ::sd_bus_emit_object_added(bus, path);
} }
int SdBus::sd_bus_emit_object_removed(sd_bus *bus, const char *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); return ::sd_bus_emit_object_removed(bus, path);
} }
int SdBus::sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path, char **interfaces) 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); 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) 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); 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) 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); return ::sd_bus_request_name(bus, name, flags);
} }
int SdBus::sd_bus_release_name(sd_bus *bus, const char *name) 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); return ::sd_bus_release_name(bus, name);
} }
int SdBus::sd_bus_get_unique_name(sd_bus *bus, const char **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); 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) 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); 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) 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); 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) 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); return :: sd_bus_add_match(bus, slot, match, callback, userdata);
} }
sd_bus_slot* SdBus::sd_bus_slot_unref(sd_bus_slot *slot) 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); return ::sd_bus_slot_unref(slot);
} }
int SdBus::sd_bus_process(sd_bus *bus, sd_bus_message **r) 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); return ::sd_bus_process(bus, r);
} }
int SdBus::sd_bus_get_poll_data(sd_bus *bus, PollData* data) 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); auto r = ::sd_bus_get_fd(bus);
if (r < 0) 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); return ::sd_bus_flush_close_unref(bus);
} }
}} }

4
src/SdBus.h
View File

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