Introduce sdbus-c++ v0.2.3

src/Connection.cpp

@@ -0,0 +1,272 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Connection.cpp
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Connection.h"
+#include <sdbus-c++/Message.h>
+#include <sdbus-c++/Error.h>
+#include "ScopeGuard.h"
+#include <systemd/sd-bus.h>
+#include <unistd.h>
+#include <poll.h>
+#include <sys/eventfd.h>
+
+namespace {
+    std::map<sdbus::internal::Connection::BusType, int(*)(sd_bus **)> busTypeToFactory
+    {
+        {sdbus::internal::Connection::BusType::eSystem, &sd_bus_open_system},
+        {sdbus::internal::Connection::BusType::eSession, &sd_bus_open_user}
+    };
+}
+
+namespace sdbus { namespace internal {
+
+Connection::Connection(Connection::BusType type)
+    : busType_(type)
+{
+    sd_bus* bus{};
+    auto r = busTypeToFactory[busType_](&bus);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to open system bus", -r);
+
+    bus_.reset(bus);
+
+    // Process all requests that are part of the initial handshake,
+    // like processing the Hello message response, authentication etc.,
+    // to avoid connection authentication timeout in dbus daemon.
+    r = sd_bus_flush(bus_.get());
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to flush system bus on opening", -r);
+
+    r = eventfd(0, EFD_SEMAPHORE);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create event object", -errno);
+    runFd_ = r;
+}
+
+Connection::~Connection()
+{
+    leaveProcessingLoop();
+    close(runFd_);
+}
+
+void Connection::requestName(const std::string& name)
+{
+    auto r = sd_bus_request_name(bus_.get(), name.c_str(), 0);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to request bus name", -r);
+}
+
+void Connection::releaseName(const std::string& name)
+{
+    auto r = sd_bus_release_name(bus_.get(), name.c_str());
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to release bus name", -r);
+}
+
+void Connection::enterProcessingLoop()
+{
+    int semaphoreFd = runFd_;
+    short int semaphoreEvents = POLLIN;
+
+    while (true)
+    {
+        /* Process requests */
+        int r = sd_bus_process(bus_.get(), nullptr);
+        SDBUS_THROW_ERROR_IF(r < 0, "Failed to process bus requests", -r);
+        if (r > 0) /* we processed a request, try to process another one, right-away */
+            continue;
+
+        r = sd_bus_get_fd(bus_.get());
+        SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus descriptor", -r);
+        auto sdbusFd = r;
+
+        r = sd_bus_get_events(bus_.get());
+        SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus descriptor", -r);
+        short int sdbusEvents = r;
+
+        struct pollfd fds[] = {{sdbusFd, sdbusEvents, 0}, {semaphoreFd, semaphoreEvents, 0}};
+
+        /* Wait for the next request to process */
+        uint64_t usec;
+        sd_bus_get_timeout(bus_.get(), &usec);
+
+        auto fdsCount = sizeof(fds)/sizeof(fds[0]);
+        r = poll(fds, fdsCount, usec == (uint64_t) -1 ? -1 : (usec+999)/1000);
+        SDBUS_THROW_ERROR_IF(r < 0, "Failed to wait on the bus", -errno);
+
+        if (fds[1].revents & POLLIN)
+            break;
+    }
+}
+
+void Connection::enterProcessingLoopAsync()
+{
+    asyncLoopThread_ = std::thread([this](){ enterProcessingLoop(); });
+}
+
+void Connection::leaveProcessingLoop()
+{
+    assert(runFd_ >= 0);
+    uint64_t value = 1;
+    write(runFd_, &value, sizeof(value));
+
+    if (asyncLoopThread_.joinable())
+        asyncLoopThread_.join();
+}
+
+void* Connection::addObjectVTable( const std::string& objectPath
+                                 , const std::string& interfaceName
+                                 , const void* vtable
+                                 , void* userData )
+{
+    sd_bus_slot *slot{};
+    auto r = sd_bus_add_object_vtable( bus_.get()
+                                     , &slot
+                                     , objectPath.c_str()
+                                     , interfaceName.c_str()
+                                     , static_cast<const sd_bus_vtable*>(vtable)
+                                     , userData );
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to register object vtable", -r);
+
+    return slot;
+}
+
+void Connection::removeObjectVTable(void* vtableHandle)
+{
+    sd_bus_slot_unref((sd_bus_slot *)vtableHandle);
+}
+
+sdbus::Message Connection::createMethodCall( const std::string& destination
+                                           , const std::string& objectPath
+                                           , const std::string& interfaceName
+                                           , const std::string& methodName ) const
+{
+    sd_bus_message *sdbusMsg{};
+    SCOPE_EXIT{ sd_bus_message_unref(sdbusMsg); }; // Returned message will become an owner of sdbusMsg
+    auto r = sd_bus_message_new_method_call( bus_.get()
+                                           , &sdbusMsg
+                                           , destination.c_str()
+                                           , objectPath.c_str()
+                                           , interfaceName.c_str()
+                                           , methodName.c_str() );
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to create method call", -r);
+
+    return Message(sdbusMsg, Message::Type::eMethodCall);
+}
+
+sdbus::Message Connection::createSignal( const std::string& objectPath
+                                       , const std::string& interfaceName
+                                       , const std::string& signalName ) const
+{
+    sd_bus_message *sdbusSignal{};
+    SCOPE_EXIT{ sd_bus_message_unref(sdbusSignal); }; // Returned message will become an owner of sdbusSignal
+    auto r = sd_bus_message_new_signal( bus_.get()
+                                      , &sdbusSignal
+                                      , objectPath.c_str()
+                                      , interfaceName.c_str()
+                                      , signalName.c_str() );
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to create signal", -r);
+
+    return Message(sdbusSignal, Message::Type::eSignal);
+}
+
+void* Connection::registerSignalHandler( const std::string& objectPath
+                                       , const std::string& interfaceName
+                                       , const std::string& signalName
+                                       , sd_bus_message_handler_t callback
+                                       , void* userData )
+{
+    sd_bus_slot *slot{};
+    auto filter = composeSignalMatchFilter(objectPath, interfaceName, signalName);
+    auto r = sd_bus_add_match(bus_.get(), &slot, filter.c_str(), callback, userData);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to register signal handler", -r);
+
+    return slot;
+}
+
+void Connection::unregisterSignalHandler(void* handlerCookie)
+{
+    sd_bus_slot_unref((sd_bus_slot *)handlerCookie);
+}
+
+std::unique_ptr<sdbus::internal::IConnection> Connection::clone() const
+{
+    return std::make_unique<sdbus::internal::Connection>(busType_);
+}
+
+std::string Connection::composeSignalMatchFilter( const std::string& objectPath
+                                                , const std::string& interfaceName
+                                                , const std::string& signalName )
+{
+    std::string filter;
+    filter += "type='signal',";
+    filter += "interface='" + interfaceName + "',";
+    filter += "member='" + signalName + "',";
+    filter += "path='" + objectPath + "'";
+    return filter;
+}
+
+}}
+
+namespace sdbus {
+
+std::unique_ptr<sdbus::IConnection> createConnection()
+{
+    return createSystemBusConnection();
+}
+
+std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name)
+{
+    return createSystemBusConnection(name);
+}
+
+std::unique_ptr<sdbus::IConnection> createSystemBusConnection()
+{
+    return std::make_unique<sdbus::internal::Connection>(sdbus::internal::Connection::BusType::eSystem);
+}
+
+std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name)
+{
+    auto conn = createSystemBusConnection();
+    conn->requestName(name);
+    return conn;
+}
+
+std::unique_ptr<sdbus::IConnection> createSessionBusConnection()
+{
+    return std::make_unique<sdbus::internal::Connection>(sdbus::internal::Connection::BusType::eSession);
+}
+
+std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name)
+{
+    auto conn = createSessionBusConnection();
+    conn->requestName(name);
+    return conn;
+}
+
+}

src/Connection.h

@@ -0,0 +1,98 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Connection.h
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CXX_INTERNAL_CONNECTION_H_
+#define SDBUS_CXX_INTERNAL_CONNECTION_H_
+
+#include <sdbus-c++/IConnection.h>
+#include <systemd/sd-bus.h>
+#include <memory>
+#include <atomic>
+#include <thread>
+
+#include "IConnection.h"
+
+namespace sdbus { namespace internal {
+
+    class Connection
+        : public sdbus::IConnection           // External, public interface
+        , public sdbus::internal::IConnection // Internal, private interface
+    {
+    public:
+        enum class BusType
+        {
+            eSystem,
+            eSession
+        };
+
+        Connection(BusType type);
+        ~Connection();
+
+        void requestName(const std::string& name) override;
+        void releaseName(const std::string& name) override;
+        void enterProcessingLoop() override;
+        void enterProcessingLoopAsync() override;
+        void leaveProcessingLoop() override;
+
+        void* addObjectVTable( const std::string& objectPath
+                             , const std::string& interfaceName
+                             , const void* vtable
+                             , void* userData ) override;
+        void removeObjectVTable(void* vtableHandle) override;
+
+        sdbus::Message createMethodCall( const std::string& destination
+                                       , const std::string& objectPath
+                                       , const std::string& interfaceName
+                                       , const std::string& methodName ) const override;
+        sdbus::Message createSignal( const std::string& objectPath
+                                   , const std::string& interfaceName
+                                   , const std::string& signalName ) const override;
+
+        void* registerSignalHandler( const std::string& objectPath
+                                   , const std::string& interfaceName
+                                   , const std::string& signalName
+                                   , sd_bus_message_handler_t callback
+                                   , void* userData ) override;
+        void unregisterSignalHandler(void* handlerCookie) override;
+
+        std::unique_ptr<sdbus::internal::IConnection> clone() const override;
+
+    private:
+        static std::string composeSignalMatchFilter( const std::string& objectPath
+                                                   , const std::string& interfaceName
+                                                   , const std::string& signalName );
+
+    private:
+        std::unique_ptr<sd_bus, decltype(&sd_bus_flush_close_unref)> bus_{nullptr, &sd_bus_flush_close_unref};
+        std::thread asyncLoopThread_;
+        std::atomic<int> runFd_{-1};
+        BusType busType_;
+
+        static constexpr const uint64_t POLL_TIMEOUT_USEC = 500000;
+    };
+
+}}
+
+#endif /* SDBUS_CXX_INTERNAL_CONNECTION_H_ */

src/ConvenienceClasses.cpp

@@ -0,0 +1,150 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file ConvenienceClasses.cpp
+ *
+ * Created on: Jan 19, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sdbus-c++/ConvenienceClasses.h>
+#include <sdbus-c++/IObject.h>
+#include <sdbus-c++/IObjectProxy.h>
+#include <string>
+#include <exception>
+
+namespace sdbus {
+
+SignalRegistrator::SignalRegistrator(IObject& object, const std::string& signalName)
+    : object_(object)
+    , signalName_(signalName)
+    , exceptions_(std::uncaught_exceptions()) // Needs C++17
+{
+}
+
+SignalRegistrator::~SignalRegistrator() noexcept(false) // since C++11, destructors must
+{                                                       // explicitly be allowed to throw
+    // Don't register the signal if SignalRegistrator threw an exception in one of its methods
+    if (std::uncaught_exceptions() != exceptions_)
+        return;
+
+    SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus signal", EINVAL);
+
+    // registerSignal() can throw. But as the SignalRegistrator shall always be used as an unnamed,
+    // temporary object, i.e. not as a stack-allocated object, the double-exception situation
+    // shall never happen. I.e. it should not happen that this destructor is directly called
+    // in the stack-unwinding process of another flying exception (which would lead to immediate
+    // termination). It can be called indirectly in the destructor of another object, but that's
+    // fine and safe provided that the caller catches exceptions thrown from here.
+    // Therefore, we can allow registerSignal() to throw even if we are in the destructor.
+    // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
+    // to the exception thrown from here if the caller is a destructor itself.
+    object_.registerSignal(interfaceName_, signalName_, signalSignature_);
+}
+
+
+PropertyRegistrator::PropertyRegistrator(IObject& object, const std::string& propertyName)
+    : object_(object)
+    , propertyName_(propertyName)
+    , exceptions_(std::uncaught_exceptions())
+{
+}
+
+PropertyRegistrator::~PropertyRegistrator() noexcept(false) // since C++11, destructors must
+{                                                           // explicitly be allowed to throw
+    // Don't register the property if PropertyRegistrator threw an exception in one of its methods
+    if (std::uncaught_exceptions() != exceptions_)
+        return;
+
+    SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus property", EINVAL);
+
+    // registerProperty() can throw. But as the PropertyRegistrator shall always be used as an unnamed,
+    // temporary object, i.e. not as a stack-allocated object, the double-exception situation
+    // shall never happen. I.e. it should not happen that this destructor is directly called
+    // in the stack-unwinding process of another flying exception (which would lead to immediate
+    // termination). It can be called indirectly in the destructor of another object, but that's
+    // fine and safe provided that the caller catches exceptions thrown from here.
+    // Therefore, we can allow registerProperty() to throw even if we are in the destructor.
+    // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
+    // to the exception thrown from here if the caller is a destructor itself.
+    object_.registerProperty( std::move(interfaceName_)
+                            , std::move(propertyName_)
+                            , std::move(propertySignature_)
+                            , std::move(getter_)
+                            , std::move(setter_) );
+}
+
+
+SignalEmitter::SignalEmitter(IObject& object, const std::string& signalName)
+    : object_(object)
+    , signalName_(signalName)
+    , exceptions_(std::uncaught_exceptions()) // Needs C++17
+{
+}
+
+SignalEmitter::~SignalEmitter() noexcept(false) // since C++11, destructors must
+{                                               // explicitly be allowed to throw
+    // Don't emit the signal if SignalEmitter threw an exception in one of its methods
+    if (std::uncaught_exceptions() != exceptions_)
+        return;
+
+    SDBUS_THROW_ERROR_IF(!signal_.isValid(), "DBus interface not specified when emitting a DBus signal", EINVAL);
+
+    // emitSignal() can throw. But as the SignalEmitter shall always be used as an unnamed,
+    // temporary object, i.e. not as a stack-allocated object, the double-exception situation
+    // shall never happen. I.e. it should not happen that this destructor is directly called
+    // in the stack-unwinding process of another flying exception (which would lead to immediate
+    // termination). It can be called indirectly in the destructor of another object, but that's
+    // fine and safe provided that the caller catches exceptions thrown from here.
+    // Therefore, we can allow emitSignal() to throw even if we are in the destructor.
+    // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
+    // to the exception thrown from here if the caller is a destructor itself.
+    object_.emitSignal(signal_);
+}
+
+
+MethodInvoker::MethodInvoker(IObjectProxy& objectProxy, const std::string& methodName)
+    : objectProxy_(objectProxy)
+    , methodName_(methodName)
+    , exceptions_(std::uncaught_exceptions()) // Needs C++17
+{
+}
+
+MethodInvoker::~MethodInvoker() noexcept(false) // since C++11, destructors must
+{                                               // explicitly be allowed to throw
+    // Don't call the method if it has been called already or if MethodInvoker
+    // threw an exception in one of its methods
+    if (methodCalled_ || std::uncaught_exceptions() != exceptions_)
+        return;
+
+    SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+
+    // callMethod() can throw. But as the MethodInvoker shall always be used as an unnamed,
+    // temporary object, i.e. not as a stack-allocated object, the double-exception situation
+    // shall never happen. I.e. it should not happen that this destructor is directly called
+    // in the stack-unwinding process of another flying exception (which would lead to immediate
+    // termination). It can be called indirectly in the destructor of another object, but that's
+    // fine and safe provided that the caller catches exceptions thrown from here.
+    // Therefore, we can allow callMethod() to throw even if we are in the destructor.
+    // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
+    // to the exception thrown from here if the caller is a destructor itself.
+    objectProxy_.callMethod(method_);
+}
+
+}

src/Error.cpp

@@ -0,0 +1,40 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Error.cpp
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sdbus-c++/Error.h>
+#include <systemd/sd-bus.h>
+
+namespace sdbus
+{
+    sdbus::Error createError(int errNo, const std::string& customMsg)
+    {
+        sd_bus_error sdbusError = SD_BUS_ERROR_NULL;
+        sd_bus_error_set_errno(&sdbusError, errNo);
+        std::string name(sdbusError.name);
+        std::string message(customMsg + " (" + sdbusError.message + ")");
+        sd_bus_error_free(&sdbusError);
+        return sdbus::Error(name, message);
+    }
+}

src/IConnection.h

@@ -0,0 +1,77 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file IConnection.h
+ *
+ * Created on: Nov 9, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CXX_INTERNAL_ICONNECTION_H_
+#define SDBUS_CXX_INTERNAL_ICONNECTION_H_
+
+#include <systemd/sd-bus.h>
+#include <string>
+#include <memory>
+
+// Forward declaration
+namespace sdbus {
+    class Message;
+}
+
+namespace sdbus {
+namespace internal {
+
+    class IConnection
+    {
+    public:
+        virtual void* addObjectVTable( const std::string& objectPath
+                                     , const std::string& interfaceName
+                                     , const void* vtable
+                                     , void* userData ) = 0;
+        virtual void removeObjectVTable(void* vtableHandle) = 0;
+
+        virtual sdbus::Message createMethodCall( const std::string& destination
+                                               , const std::string& objectPath
+                                               , const std::string& interfaceName
+                                               , const std::string& methodName ) const = 0;
+
+        virtual sdbus::Message createSignal( const std::string& objectPath
+                                           , const std::string& interfaceName
+                                           , const std::string& signalName ) const = 0;
+
+        virtual void* registerSignalHandler( const std::string& objectPath
+                                           , const std::string& interfaceName
+                                           , const std::string& signalName
+                                           , sd_bus_message_handler_t callback
+                                           , void* userData ) = 0;
+        virtual void unregisterSignalHandler(void* handlerCookie) = 0;
+
+        virtual void enterProcessingLoopAsync() = 0;
+        virtual void leaveProcessingLoop() = 0;
+
+        virtual std::unique_ptr<sdbus::internal::IConnection> clone() const = 0;
+
+        virtual ~IConnection() = default;
+    };
+
+}
+}
+
+#endif /* SDBUS_CXX_INTERNAL_ICONNECTION_H_ */

src/Makefile.am

@@ -0,0 +1,26 @@
+
+lib_LTLIBRARIES = libsdbus-c++.la
+
+libsdbus_c___la_SOURCES = \
+	Connection.cpp \
+	ConvenienceClasses.cpp \
+	Message.cpp \
+	Object.cpp \
+	ObjectProxy.cpp \
+	Types.cpp \
+	Error.cpp \
+	VTableUtils.c
+
+libsdbus_c___la_LIBADD = @SYSTEMD_LIBS@
+
+# Setting per-file flags
+AM_CPPFLAGS = -I$(top_srcdir)/include
+AM_CXXFLAGS = @libsdbus_cpp_CFLAGS@ @SYSTEMD_CFLAGS@ -std=c++17 -pipe -pedantic -W -Wall
+AM_LDFLAGS = @libsdbus_cpp_LIBS@ @SYSTEMD_LIBS@ 
+
+libsdbus_c___la_LDFLAGS = -version-info 0:0:0
+
+# Cleaning
+CLEANFILES = *~ *.lo *.la
+MOSTLYCLEANFILES = *.o
+DISTCLEANFILES = Makefile Makefile.in

src/Message.cpp

@@ -0,0 +1,676 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Message.cpp
+ *
+ * Created on: Nov 9, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sdbus-c++/Message.h>
+#include <sdbus-c++/Types.h>
+#include <sdbus-c++/Error.h>
+#include "MessageUtils.h"
+#include "ScopeGuard.h"
+#include <systemd/sd-bus.h>
+#include <cassert>
+
+namespace sdbus { /*namespace internal {*/
+
+Message::Message(void *msg, Type type) noexcept
+    : msg_(msg)
+    , type_(type)
+{
+    assert(msg_ != nullptr);
+    sd_bus_message_ref((sd_bus_message*)msg_);
+}
+
+Message::Message(const Message& other) noexcept
+{
+    *this = other;
+}
+
+Message& Message::operator=(const Message& other) noexcept
+{
+    msg_ = other.msg_;
+    type_ = other.type_;
+    ok_ = other.ok_;
+
+    sd_bus_message_ref((sd_bus_message*)msg_);
+
+    return *this;
+}
+
+Message::Message(Message&& other) noexcept
+{
+    *this = std::move(other);
+}
+
+Message& Message::operator=(Message&& other) noexcept
+{
+    msg_ = other.msg_;
+    other.msg_ = nullptr;
+    type_ = other.type_;
+    other.type_ = {};
+    ok_ = other.ok_;
+    other.ok_ = true;
+
+    return *this;
+}
+
+Message::~Message()
+{
+    if (msg_)
+        sd_bus_message_unref((sd_bus_message*)msg_);
+}
+
+Message& Message::operator<<(bool item)
+{
+    int intItem = item;
+
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_BOOLEAN, &intItem);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a bool value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(int16_t item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_INT16, &item);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a int16_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(int32_t item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_INT32, &item);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a int32_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(int64_t item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_INT64, &item);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a int64_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(uint8_t item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_BYTE, &item);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a byte value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(uint16_t item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_UINT16, &item);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a uint16_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(uint32_t item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_UINT32, &item);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a uint32_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(uint64_t item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_UINT64, &item);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a uint64_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(double item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_DOUBLE, &item);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a double value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(const char* item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_STRING, item);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a C-string value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(const std::string& item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_STRING, item.c_str());
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize a string value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(const Variant &item)
+{
+    item.serializeTo(*this);
+
+    return *this;
+}
+
+Message& Message::operator<<(const ObjectPath &item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_OBJECT_PATH, item.c_str());
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize an ObjectPath value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(const Signature &item)
+{
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_SIGNATURE, item.c_str());
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to serialize an Signature value", -r);
+
+    return *this;
+}
+
+
+Message& Message::operator>>(bool& item)
+{
+    int intItem;
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_BOOLEAN, &intItem);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a bool value", -r);
+
+    item = static_cast<bool>(intItem);
+
+    return *this;
+}
+
+Message& Message::operator>>(int16_t& item)
+{
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_INT16, &item);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a int16_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator>>(int32_t& item)
+{
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_INT32, &item);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a int32_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator>>(int64_t& item)
+{
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_INT64, &item);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a bool value", -r);
+
+    return *this;
+}
+
+Message& Message::operator>>(uint8_t& item)
+{
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_BYTE, &item);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a byte value", -r);
+
+    return *this;
+}
+
+Message& Message::operator>>(uint16_t& item)
+{
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_UINT16, &item);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a uint16_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator>>(uint32_t& item)
+{
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_UINT32, &item);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a uint32_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator>>(uint64_t& item)
+{
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_UINT64, &item);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a uint64_t value", -r);
+
+    return *this;
+}
+
+Message& Message::operator>>(double& item)
+{
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_DOUBLE, &item);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a double value", -r);
+
+    return *this;
+}
+
+Message& Message::operator>>(char*& item)
+{
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_STRING, &item);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a string value", -r);
+
+    return *this;
+}
+
+Message& Message::operator>>(std::string& item)
+{
+    char* str{};
+    (*this) >> str;
+
+    if (str != nullptr)
+        item = str;
+
+    return *this;
+}
+
+Message& Message::operator>>(Variant &item)
+{
+    item.deserializeFrom(*this);
+
+    // Empty variant is normally prohibited. Users cannot send empty variants.
+    // Therefore in this context an empty variant means that we are at the end
+    // of deserializing a container, and thus we shall set ok_ flag to false.
+    if (item.isEmpty())
+        ok_ = false;
+
+    return *this;
+}
+
+Message& Message::operator>>(ObjectPath &item)
+{
+    char* str{};
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_OBJECT_PATH, &str);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize an ObjectPath value", -r);
+
+    if (str != nullptr)
+        item = str;
+
+    return *this;
+}
+
+Message& Message::operator>>(Signature &item)
+{
+    char* str{};
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_SIGNATURE, &str);
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to deserialize a Signature value", -r);
+
+    if (str != nullptr)
+        item = str;
+
+    return *this;
+}
+
+
+Message& Message::openContainer(const std::string& signature)
+{
+    auto r = sd_bus_message_open_container((sd_bus_message*)msg_, SD_BUS_TYPE_ARRAY, signature.c_str());
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to open a container", -r);
+
+    return *this;
+}
+
+Message& Message::closeContainer()
+{
+    auto r = sd_bus_message_close_container((sd_bus_message*)msg_);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to close a container", -r);
+
+    return *this;
+}
+
+Message& Message::openDictEntry(const std::string& signature)
+{
+    auto r = sd_bus_message_open_container((sd_bus_message*)msg_, SD_BUS_TYPE_DICT_ENTRY, signature.c_str());
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to open a dictionary entry", -r);
+
+    return *this;
+}
+
+Message& Message::closeDictEntry()
+{
+    auto r = sd_bus_message_close_container((sd_bus_message*)msg_);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to close a dictionary entry", -r);
+
+    return *this;
+}
+
+Message& Message::openVariant(const std::string& signature)
+{
+    auto r = sd_bus_message_open_container((sd_bus_message*)msg_, SD_BUS_TYPE_VARIANT, signature.c_str());
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to open a variant", -r);
+
+    return *this;
+}
+
+Message& Message::closeVariant()
+{
+    auto r = sd_bus_message_close_container((sd_bus_message*)msg_);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to close a variant", -r);
+
+    return *this;
+}
+
+Message& Message::openStruct(const std::string& signature)
+{
+    auto r = sd_bus_message_open_container((sd_bus_message*)msg_, SD_BUS_TYPE_STRUCT, signature.c_str());
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to open a struct", -r);
+
+    return *this;
+}
+
+Message& Message::closeStruct()
+{
+    auto r = sd_bus_message_close_container((sd_bus_message*)msg_);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to close a struct", -r);
+
+    return *this;
+}
+
+
+Message& Message::enterContainer(const std::string& signature)
+{
+    auto r = sd_bus_message_enter_container((sd_bus_message*)msg_, SD_BUS_TYPE_ARRAY, signature.c_str());
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to enter a container", -r);
+
+    return *this;
+}
+
+Message& Message::exitContainer()
+{
+    auto r = sd_bus_message_exit_container((sd_bus_message*)msg_);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to exit a container", -r);
+
+    return *this;
+}
+
+Message& Message::enterDictEntry(const std::string& signature)
+{
+    auto r = sd_bus_message_enter_container((sd_bus_message*)msg_, SD_BUS_TYPE_DICT_ENTRY, signature.c_str());
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to enter a dictionary entry", -r);
+
+    return *this;
+}
+
+Message& Message::exitDictEntry()
+{
+    auto r = sd_bus_message_exit_container((sd_bus_message*)msg_);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to exit a dictionary entry", -r);
+
+    return *this;
+}
+
+Message& Message::enterVariant(const std::string& signature)
+{
+    auto r = sd_bus_message_enter_container((sd_bus_message*)msg_, SD_BUS_TYPE_VARIANT, signature.c_str());
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to enter a variant", -r);
+
+    return *this;
+}
+
+Message& Message::exitVariant()
+{
+    auto r = sd_bus_message_exit_container((sd_bus_message*)msg_);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to exit a variant", -r);
+
+    return *this;
+}
+
+Message& Message::enterStruct(const std::string& signature)
+{
+    auto r = sd_bus_message_enter_container((sd_bus_message*)msg_, SD_BUS_TYPE_STRUCT, signature.c_str());
+    if (r == 0)
+        ok_ = false;
+    else if (r < 0)
+        SDBUS_THROW_ERROR("Failed to enter a struct", -r);
+
+    return *this;
+}
+
+Message& Message::exitStruct()
+{
+    auto r = sd_bus_message_exit_container((sd_bus_message*)msg_);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to exit a struct", -r);
+
+    return *this;
+}
+
+
+Message::operator bool() const
+{
+    return ok_;
+}
+
+void Message::clearFlags()
+{
+    ok_ = true;
+}
+
+void Message::copyTo(Message& destination, bool complete) const
+{
+    auto r = sd_bus_message_copy((sd_bus_message*)destination.msg_, (sd_bus_message*)msg_, complete);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to copy the message", -r);
+}
+
+void Message::seal()
+{
+    const auto messageCookie = 1;
+    const auto sealTimeout = 0;
+    auto r = sd_bus_message_seal((sd_bus_message*)msg_, messageCookie, sealTimeout);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to seal the message", -r);
+}
+
+void Message::rewind(bool complete)
+{
+    auto r = sd_bus_message_rewind((sd_bus_message*)msg_, complete);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to rewind the message", -r);
+}
+
+Message Message::send() const
+{
+    if (type_ == Type::eMethodCall)
+    {
+        sd_bus_message* sdbusReply{};
+        SCOPE_EXIT{ sd_bus_message_unref(sdbusReply); }; // Returned message will become an owner of sdbusReply
+        sd_bus_error sdbusError = SD_BUS_ERROR_NULL;
+        SCOPE_EXIT{ sd_bus_error_free(&sdbusError); };
+
+        auto r = sd_bus_call(nullptr, (sd_bus_message*)msg_, 0, &sdbusError, &sdbusReply);
+
+        if (sd_bus_error_is_set(&sdbusError))
+        {
+            throw sdbus::Error(sdbusError.name, sdbusError.message);
+        }
+
+        SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method", -r);
+
+        return Message(sdbusReply);
+    }
+    else if (type_ == Type::eMethodReply)
+    {
+        auto r = sd_bus_send(nullptr, (sd_bus_message*)msg_, nullptr);
+        if (r < 0)
+            SDBUS_THROW_ERROR("Failed to send reply", -r);
+
+        return Message();
+    }
+    else if (type_ == Type::eSignal)
+    {
+        auto r = sd_bus_send(nullptr, (sd_bus_message*)msg_, nullptr);
+        if (r < 0)
+            SDBUS_THROW_ERROR("Failed to emit signal", -r);
+
+        return Message();
+    }
+    else
+    {
+        assert(false);
+        return Message();
+    }
+}
+
+Message Message::createReply() const
+{
+    sd_bus_message *sdbusReply{};
+    SCOPE_EXIT{ sd_bus_message_unref(sdbusReply); }; // Returned message will become an owner of sdbusReply
+    auto r = sd_bus_message_new_method_return((sd_bus_message*)msg_, &sdbusReply);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to create method reply", -r);
+
+    assert(sdbusReply != nullptr);
+
+    return Message(sdbusReply, Type::eMethodReply);
+}
+
+std::string Message::getInterfaceName() const
+{
+    return sd_bus_message_get_interface((sd_bus_message*)msg_);
+}
+
+std::string Message::getMemberName() const
+{
+    return sd_bus_message_get_member((sd_bus_message*)msg_);
+}
+
+void Message::peekType(std::string& type, std::string& contents) const
+{
+    char typeSig;
+    const char* contentsSig;
+    auto r = sd_bus_message_peek_type((sd_bus_message*)msg_, &typeSig, &contentsSig);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to peek message type", -r);
+    type = typeSig;
+    contents = contentsSig;
+}
+
+bool Message::isValid() const
+{
+    return msg_ != nullptr;
+}
+
+bool Message::isEmpty() const
+{
+    return sd_bus_message_is_empty((sd_bus_message*)msg_);
+}
+
+Message::Type Message::getType() const
+{
+    return type_;
+}
+
+Message createPlainMessage()
+{
+    int r;
+
+    sd_bus* bus{};
+    SCOPE_EXIT{ sd_bus_unref(bus); }; // sdbusMsg will hold reference to the bus
+    r = sd_bus_default_system(&bus);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to get default system bus", -r);
+
+    sd_bus_message* sdbusMsg{};
+    SCOPE_EXIT{ sd_bus_message_unref(sdbusMsg); }; // Returned message will become an owner of sdbusMsg
+    r = sd_bus_message_new(bus, &sdbusMsg, _SD_BUS_MESSAGE_TYPE_INVALID);
+    if (r < 0)
+        SDBUS_THROW_ERROR("Failed to create a new message", -r);
+
+    return Message(sdbusMsg, Message::Type::ePlainMessage);
+}
+
+/*}*/}

src/MessageUtils.h

@@ -0,0 +1,36 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file MessageUtils.h
+ *
+ * Created on: Dec 5, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CXX_INTERNAL_MESSAGEUTILS_H_
+#define SDBUS_CXX_INTERNAL_MESSAGEUTILS_H_
+
+#include <sdbus-c++/Message.h>
+
+namespace sdbus
+{
+    Message createPlainMessage();
+}
+
+#endif /* SDBUS_CXX_INTERNAL_MESSAGEUTILS_H_ */

src/Object.cpp

@@ -0,0 +1,261 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Object.cpp
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Object.h"
+#include <sdbus-c++/IConnection.h>
+#include <sdbus-c++/Message.h>
+#include <sdbus-c++/Error.h>
+#include "IConnection.h"
+#include "VTableUtils.h"
+#include <systemd/sd-bus.h>
+#include <utility>
+#include <cassert>
+
+namespace sdbus { namespace internal {
+
+Object::Object(sdbus::internal::IConnection& connection, std::string objectPath)
+    : connection_(connection), objectPath_(std::move(objectPath))
+{
+}
+
+void Object::registerMethod( const std::string& interfaceName
+                           , const std::string& methodName
+                           , const std::string& inputSignature
+                           , const std::string& outputSignature
+                           , method_callback methodCallback )
+{
+    SDBUS_THROW_ERROR_IF(!methodCallback, "Invalid method callback provided", EINVAL);
+
+    auto& interface = interfaces_[interfaceName];
+
+    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(methodCallback)};
+    auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;
+
+    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
+}
+
+void Object::registerSignal( const std::string& interfaceName
+                           , const std::string& signalName
+                           , const std::string& signature )
+{
+    auto& interface = interfaces_[interfaceName];
+
+    InterfaceData::SignalData signalData{signature};
+    auto inserted = interface.signals_.emplace(signalName, std::move(signalData)).second;
+
+    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register signal: signal already exists", EINVAL);
+}
+
+void Object::registerProperty( const std::string& interfaceName
+                             , const std::string& propertyName
+                             , const std::string& signature
+                             , property_get_callback getCallback )
+{
+    registerProperty( interfaceName
+                    , propertyName
+                    , signature
+                    , getCallback
+                    , property_set_callback{} );
+}
+
+void Object::registerProperty( const std::string& interfaceName
+                             , const std::string& propertyName
+                             , const std::string& signature
+                             , property_get_callback getCallback
+                             , property_set_callback setCallback )
+{
+    SDBUS_THROW_ERROR_IF(!getCallback && !setCallback, "Invalid property callbacks provided", EINVAL);
+
+    auto& interface = interfaces_[interfaceName];
+
+    InterfaceData::PropertyData propertyData{signature, std::move(getCallback), std::move(setCallback)};
+    auto inserted = interface.properties_.emplace(propertyName, std::move(propertyData)).second;
+
+    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register property: property already exists", EINVAL);
+}
+
+void Object::finishRegistration()
+{
+    for (auto& item : interfaces_)
+    {
+        const auto& interfaceName = item.first;
+        auto& interfaceData = item.second;
+
+        auto& vtable = interfaceData.vtable_;
+        assert(vtable.empty());
+
+        vtable.push_back(createVTableStartItem());
+        for (const auto& item : interfaceData.methods_)
+        {
+            const auto& methodName = item.first;
+            const auto& methodData = item.second;
+
+            vtable.push_back(createVTableMethodItem( methodName.c_str()
+                                                   , methodData.inputArgs_.c_str()
+                                                   , methodData.outputArgs_.c_str()
+                                                   , &Object::sdbus_method_callback ));
+        }
+        for (const auto& item : interfaceData.signals_)
+        {
+            const auto& signalName = item.first;
+            const auto& signalData = item.second;
+
+            vtable.push_back(createVTableSignalItem( signalName.c_str()
+                                                   , signalData.signature_.c_str() ));
+        }
+        for (const auto& item : interfaceData.properties_)
+        {
+            const auto& propertyName = item.first;
+            const auto& propertyData = item.second;
+
+            if (!propertyData.setCallback_)
+                vtable.push_back(createVTablePropertyItem( propertyName.c_str()
+                                                         , propertyData.signature_.c_str()
+                                                         , &Object::sdbus_property_get_callback ));
+            else
+                vtable.push_back(createVTableWritablePropertyItem( propertyName.c_str()
+                                                                 , propertyData.signature_.c_str()
+                                                                 , &Object::sdbus_property_get_callback
+                                                                 , &Object::sdbus_property_set_callback ));
+        }
+        vtable.push_back(createVTableEndItem());
+
+        // Tell, don't ask
+        auto slot = (sd_bus_slot*) connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], this);
+        interfaceData.slot_.reset(slot);
+        interfaceData.slot_.get_deleter() = [this](void *slot){ connection_.removeObjectVTable(slot); };
+    }
+}
+
+sdbus::Message Object::createSignal(const std::string& interfaceName, const std::string& signalName)
+{
+    // Tell, don't ask
+    return connection_.createSignal(objectPath_, interfaceName, signalName);
+}
+
+void Object::emitSignal(const sdbus::Message& message)
+{
+    message.send();
+}
+
+int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)
+{
+    Message message(sdbusMessage, Message::Type::eMethodCall);
+
+    auto* object = static_cast<Object*>(userData);
+    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
+    auto& callback = object->interfaces_[message.getInterfaceName()].methods_[message.getMemberName()].callback_;
+    assert(callback);
+
+    auto reply = message.createReply();
+
+    try
+    {
+        callback(message, reply);
+    }
+    catch (const sdbus::Error& e)
+    {
+        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
+        return 1;
+    }
+
+    reply.send();
+
+    return 1;
+}
+
+int Object::sdbus_property_get_callback( sd_bus */*bus*/
+                                       , const char */*objectPath*/
+                                       , const char *interface
+                                       , const char *property
+                                       , sd_bus_message *sdbusReply
+                                       , void *userData
+                                       , sd_bus_error *retError )
+{
+    Message reply(sdbusReply, Message::Type::ePlainMessage);
+
+    auto* object = static_cast<Object*>(userData);
+    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
+    auto& callback = object->interfaces_[interface].properties_[property].getCallback_;
+    // Getter can be empty - the case of "write-only" property
+    if (!callback)
+    {
+        sd_bus_error_set(retError, "org.freedesktop.DBus.Error.Failed", "Cannot read property as it is write-only");
+        return 1;
+    }
+
+    try
+    {
+        callback(reply);
+    }
+    catch (const sdbus::Error& e)
+    {
+        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
+    }
+
+    return 1;
+}
+
+int Object::sdbus_property_set_callback( sd_bus */*bus*/
+                                       , const char */*objectPath*/
+                                       , const char *interface
+                                       , const char *property
+                                       , sd_bus_message *sdbusValue
+                                       , void *userData
+                                       , sd_bus_error *retError )
+{
+    Message value(sdbusValue, Message::Type::ePlainMessage);
+
+    auto* object = static_cast<Object*>(userData);
+    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
+    auto& callback = object->interfaces_[interface].properties_[property].setCallback_;
+    assert(callback);
+
+    try
+    {
+        callback(value);
+    }
+    catch (const sdbus::Error& e)
+    {
+        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
+        return 1;
+    }
+
+    return 1;
+}
+
+}}
+
+namespace sdbus {
+
+std::unique_ptr<sdbus::IObject> createObject(sdbus::IConnection& connection, std::string objectPath)
+{
+    auto* sdbusConnection = dynamic_cast<sdbus::internal::IConnection*>(&connection);
+    SDBUS_THROW_ERROR_IF(!sdbusConnection, "Connection is not a real sdbus-c++ connection", EINVAL);
+
+    return std::make_unique<sdbus::internal::Object>(*sdbusConnection, std::move(objectPath));
+}
+
+}

src/Object.h

@@ -0,0 +1,129 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Object.h
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CXX_INTERNAL_OBJECT_H_
+#define SDBUS_CXX_INTERNAL_OBJECT_H_
+
+#include <sdbus-c++/IObject.h>
+#include "IConnection.h"
+#include <systemd/sd-bus.h>
+#include <string>
+#include <map>
+#include <vector>
+#include <memory>
+#include <cassert>
+
+namespace sdbus {
+namespace internal {
+
+    class Object
+        : public IObject
+    {
+    public:
+        Object(sdbus::internal::IConnection& connection, std::string objectPath);
+
+        void registerMethod( const std::string& interfaceName
+                           , const std::string& methodName
+                           , const std::string& inputSignature
+                           , const std::string& outputSignature
+                           , method_callback methodCallback ) override;
+
+        void registerSignal( const std::string& interfaceName
+                           , const std::string& signalName
+                           , const std::string& signature ) override;
+
+        void registerProperty( const std::string& interfaceName
+                             , const std::string& propertyName
+                             , const std::string& signature
+                             , property_get_callback getCallback ) override;
+
+        void registerProperty( const std::string& interfaceName
+                             , const std::string& propertyName
+                             , const std::string& signature
+                             , property_get_callback getCallback
+                             , property_set_callback setCallback ) override;
+
+        void finishRegistration() override;
+
+        sdbus::Message createSignal(const std::string& interfaceName, const std::string& signalName) override;
+        void emitSignal(const sdbus::Message& message) override;
+
+    private:
+        static int sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
+        static int sdbus_property_get_callback( sd_bus *bus
+                                              , const char *objectPath
+                                              , const char *interface
+                                              , const char *property
+                                              , sd_bus_message *sdbusReply
+                                              , void *userData
+                                              , sd_bus_error *retError );
+        static int sdbus_property_set_callback( sd_bus *bus
+                                              , const char *objectPath
+                                              , const char *interface
+                                              , const char *property
+                                              , sd_bus_message *sdbusValue
+                                              , void *userData
+                                              , sd_bus_error *retError );
+
+    private:
+        sdbus::internal::IConnection& connection_;
+        std::string objectPath_;
+
+        using InterfaceName = std::string;
+        struct InterfaceData
+        {
+            using MethodName = std::string;
+            struct MethodData
+            {
+                std::string inputArgs_;
+                std::string outputArgs_;
+                method_callback callback_;
+            };
+            std::map<MethodName, MethodData> methods_;
+            using SignalName = std::string;
+            struct SignalData
+            {
+                std::string signature_;
+            };
+            std::map<SignalName, SignalData> signals_;
+            using PropertyName = std::string;
+            struct PropertyData
+            {
+                std::string signature_;
+                property_get_callback getCallback_;
+                property_set_callback setCallback_;
+            };
+            std::map<PropertyName, PropertyData> properties_;
+            std::vector<sd_bus_vtable> vtable_;
+
+            std::unique_ptr<void, std::function<void(void*)>> slot_;
+        };
+        std::map<InterfaceName, InterfaceData> interfaces_;
+    };
+
+}
+}
+
+#endif /* SDBUS_CXX_INTERNAL_OBJECT_H_ */

src/ObjectProxy.cpp

@@ -0,0 +1,182 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file ObjectProxy.cpp
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ObjectProxy.h"
+#include <sdbus-c++/Message.h>
+#include <sdbus-c++/IConnection.h>
+#include <sdbus-c++/Error.h>
+#include "IConnection.h"
+#include <systemd/sd-bus.h>
+#include <cassert>
+
+namespace sdbus { namespace internal {
+
+ObjectProxy::ObjectProxy(sdbus::internal::IConnection& connection, std::string destination, std::string objectPath)
+    : connection_(&connection, [](sdbus::internal::IConnection *){ /* Intentionally left empty */ })
+    , ownConnection_(false)
+    , destination_(std::move(destination))
+    , objectPath_(std::move(objectPath))
+{
+}
+
+ObjectProxy::ObjectProxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
+                        , std::string destination
+                        , std::string objectPath )
+    : connection_(std::move(connection))
+    , ownConnection_(true)
+    , destination_(std::move(destination))
+    , objectPath_(std::move(objectPath))
+{
+}
+
+ObjectProxy::~ObjectProxy()
+{
+    // If the dedicated connection for signals is used, we have to stop the processing loop
+    // upon this connection prior to unregistering signal slots in the interfaces_ container,
+    // otherwise we might have a race condition of two threads working upon one connection.
+    if (signalConnection_ != nullptr)
+        signalConnection_->leaveProcessingLoop();
+}
+
+Message ObjectProxy::createMethodCall(const std::string& interfaceName, const std::string& methodName)
+{
+    // Tell, don't ask
+    return connection_->createMethodCall(destination_, objectPath_, interfaceName, methodName);
+}
+
+Message ObjectProxy::callMethod(const Message& message)
+{
+    return message.send();
+}
+
+void ObjectProxy::registerSignalHandler( const std::string& interfaceName
+                                       , const std::string& signalName
+                                       , signal_handler signalHandler )
+{
+    SDBUS_THROW_ERROR_IF(!signalHandler, "Invalid signal handler provided", EINVAL);
+
+    auto& interface = interfaces_[interfaceName];
+
+    InterfaceData::SignalData signalData{std::move(signalHandler), nullptr};
+    auto insertionResult = interface.signals_.emplace(signalName, std::move(signalData));
+
+    auto inserted = insertionResult.second;
+    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register signal handler: handler already exists", EINVAL);
+}
+
+void ObjectProxy::finishRegistration()
+{
+    bool hasSignals = listensToSignals();
+
+    if (hasSignals && ownConnection_)
+    {
+        // Let's use dedicated signalConnection_ for signals,
+        // which will then be used by the processing loop thread.
+        signalConnection_ = connection_->clone();
+        registerSignalHandlers(*signalConnection_);
+        signalConnection_->enterProcessingLoopAsync();
+    }
+    else if (hasSignals)
+    {
+        // Let's used connection provided from the outside.
+        registerSignalHandlers(*connection_);
+    }
+}
+
+bool ObjectProxy::listensToSignals() const
+{
+    for (auto& interfaceItem : interfaces_)
+        if (!interfaceItem.second.signals_.empty())
+            return true;
+
+    return false;
+}
+
+void ObjectProxy::registerSignalHandlers(sdbus::internal::IConnection& connection)
+{
+    for (auto& interfaceItem : interfaces_)
+    {
+        const auto& interfaceName = interfaceItem.first;
+        auto& signalsOnInterface = interfaceItem.second.signals_;
+
+        for (auto& signalItem : signalsOnInterface)
+        {
+            const auto& signalName = signalItem.first;
+            auto& slot = signalItem.second.slot_;
+            auto* rawSlotPtr = connection.registerSignalHandler( objectPath_
+                                                               , interfaceName
+                                                               , signalName
+                                                               , &ObjectProxy::sdbus_signal_callback
+                                                               , this );
+            slot.reset(rawSlotPtr);
+            slot.get_deleter() = [&connection](void *slot){ connection.unregisterSignalHandler(slot); };
+        }
+    }
+}
+
+int ObjectProxy::sdbus_signal_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/)
+{
+    Message message(sdbusMessage, Message::Type::eSignal);
+
+    auto* object = static_cast<ObjectProxy*>(userData);
+    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
+    auto& callback = object->interfaces_[message.getInterfaceName()].signals_[message.getMemberName()].callback_;
+    assert(callback);
+
+    callback(message);
+
+    return 1;
+}
+
+}}
+
+namespace sdbus {
+
+std::unique_ptr<sdbus::IObjectProxy> createObjectProxy( IConnection& connection
+                                                      , std::string destination
+                                                      , std::string objectPath )
+{
+    auto* sdbusConnection = dynamic_cast<sdbus::internal::IConnection*>(&connection);
+    SDBUS_THROW_ERROR_IF(!sdbusConnection, "Connection is not a real sdbus-c++ connection", EINVAL);
+
+    return std::make_unique<sdbus::internal::ObjectProxy>( *sdbusConnection
+                                                         , std::move(destination)
+                                                         , std::move(objectPath) );
+}
+
+std::unique_ptr<sdbus::IObjectProxy> createObjectProxy( std::string destination
+                                                      , std::string objectPath )
+{
+    auto connection = sdbus::createConnection();
+
+    auto sdbusConnection = std::unique_ptr<sdbus::internal::IConnection>(dynamic_cast<sdbus::internal::IConnection*>(connection.release()));
+    assert(sdbusConnection != nullptr);
+
+    return std::make_unique<sdbus::internal::ObjectProxy>( std::move(sdbusConnection)
+                                                         , std::move(destination)
+                                                         , std::move(objectPath) );
+}
+
+}

src/ObjectProxy.h

@@ -0,0 +1,93 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file ObjectProxy.h
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CXX_INTERNAL_OBJECTPROXY_H_
+#define SDBUS_CXX_INTERNAL_OBJECTPROXY_H_
+
+#include <sdbus-c++/IObjectProxy.h>
+#include <systemd/sd-bus.h>
+#include <string>
+#include <memory>
+#include <map>
+
+// Forward declarations
+namespace sdbus { namespace internal {
+    class IConnection;
+}}
+
+namespace sdbus {
+namespace internal {
+
+    class ObjectProxy
+        : public IObjectProxy
+    {
+    public:
+        ObjectProxy( sdbus::internal::IConnection& connection
+                   , std::string destination
+                   , std::string objectPath );
+        ObjectProxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
+                   , std::string destination
+                   , std::string objectPath );
+        ~ObjectProxy();
+
+        Message createMethodCall(const std::string& interfaceName, const std::string& methodName) override;
+        Message callMethod(const Message& message) override;
+
+        void registerSignalHandler( const std::string& interfaceName
+                                  , const std::string& signalName
+                                  , signal_handler signalHandler ) override;
+        void finishRegistration() override;
+
+    private:
+        bool listensToSignals() const;
+        void registerSignalHandlers(sdbus::internal::IConnection& connection);
+        static int sdbus_signal_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
+
+    private:
+        std::unique_ptr< sdbus::internal::IConnection
+                       , std::function<void(sdbus::internal::IConnection*)>
+                       > connection_;
+        bool ownConnection_{};
+        std::unique_ptr<sdbus::internal::IConnection> signalConnection_;
+        std::string destination_;
+        std::string objectPath_;
+
+        using InterfaceName = std::string;
+        struct InterfaceData
+        {
+            using SignalName = std::string;
+            struct SignalData
+            {
+                signal_handler callback_;
+                std::unique_ptr<void, std::function<void(void*)>> slot_;
+            };
+            std::map<SignalName, SignalData> signals_;
+        };
+        std::map<InterfaceName, InterfaceData> interfaces_;
+    };
+
+}}
+
+#endif /* SDBUS_CXX_INTERNAL_OBJECTPROXY_H_ */

src/ScopeGuard.h

@@ -0,0 +1,131 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file ScopeGuard.h
+ *
+ * Created on: Apr 29, 2015
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CPP_INTERNAL_SCOPEGUARD_H_
+#define SDBUS_CPP_INTERNAL_SCOPEGUARD_H_
+
+#include <utility>
+
+// Straightforward, modern, easy-to-use RAII utility to perform work on scope exit in an exception-safe manner.
+//
+// The utility helps providing basic exception safety guarantee by ensuring that the resources are always
+// released in face of an exception and released or kept when exiting the scope normally.
+//
+// Use SCOPE_EXIT if you'd like to perform an (mostly clean-up) operation when the scope ends, either due
+// to an exception or because it just ends normally.
+// Use SCOPE_EXIT_NAMED if you'd like to conditionally deactivate given scope-exit operation. This is useful
+// if, for example, we want the operation to be executed only in face of an exception.
+//
+// Example usage (maybe a bit contrived):
+// SqlDb* g_pDb = nullptr;
+// void fnc() {
+//     auto* pDb = open_database(...); // Resource to be released when scope exits due to whatever reason
+//     SCOPE_EXIT{ close_database(pDb); }; // Executes body when exiting the scope due to whatever reason
+//     g_pDb = open_database(...); // Resource to be released only in face of an exception
+//     SCOPE_EXIT_NAMED(releaseGlobalDbOnException) // Executes body when exiting the scope in face of an exception
+//     {
+//         close_database(g_pDb);
+//         g_pDb = nullptr;
+//     };
+//     //... do operations (that may or may not possibly throw) on the database here
+//     releaseGlobalDbOnException.dismiss(); // Don't release global DB on normal scope exit
+//     return; // exiting scope normally
+// }
+
+#define SCOPE_EXIT                                          \
+    auto ANONYMOUS_VARIABLE(SCOPE_EXIT_STATE)               \
+    = ::skybase::utils::detail::ScopeGuardOnExit() + [&]()  \
+    /**/
+
+#define SCOPE_EXIT_NAMED(NAME)                              \
+    auto NAME                                               \
+    = ::skybase::utils::detail::ScopeGuardOnExit() + [&]()  \
+    /**/
+
+namespace skybase {
+namespace utils {
+
+    template <class _Fun>
+    class ScopeGuard
+    {
+        _Fun fnc_;
+        bool active_;
+
+    public:
+        ScopeGuard(_Fun f)
+            : fnc_(std::move(f))
+            , active_(true)
+        {
+        }
+        ~ScopeGuard()
+        {
+            if (active_)
+                fnc_();
+        }
+        void dismiss()
+        {
+            active_ = false;
+        }
+        ScopeGuard() = delete;
+        ScopeGuard(const ScopeGuard&) = delete;
+        ScopeGuard& operator=(const ScopeGuard&) = delete;
+        ScopeGuard(ScopeGuard&& rhs)
+            : fnc_(std::move(rhs.fnc_))
+            , active_(rhs.active_)
+        {
+            rhs.dismiss();
+        }
+    };
+
+    namespace detail
+    {
+        enum class ScopeGuardOnExit
+        {
+        };
+
+        // Helper function to auto-deduce type of the callable entity
+        template <typename _Fun>
+        ScopeGuard<_Fun> operator+(ScopeGuardOnExit, _Fun&& fnc)
+        {
+            return ScopeGuard<_Fun>(std::forward<_Fun>(fnc));
+        }
+    }
+
+}}
+
+#define CONCATENATE_IMPL(s1, s2) s1##s2
+#define CONCATENATE(s1, s2) CONCATENATE_IMPL(s1, s2)
+
+#ifdef __COUNTER__
+#define ANONYMOUS_VARIABLE(str)                 \
+    CONCATENATE(str, __COUNTER__)               \
+    /**/
+#else
+#define ANONYMOUS_VARIABLE(str)                 \
+    CONCATENATE(str, __LINE__)                  \
+    /**/
+#endif
+
+#endif /* SDBUS_CPP_INTERNAL_SCOPEGUARD_H_ */

src/Types.cpp

@@ -0,0 +1,65 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Types.cpp
+ *
+ * Created on: Nov 30, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sdbus-c++/Types.h>
+#include <sdbus-c++/Error.h>
+#include "MessageUtils.h"
+#include <systemd/sd-bus.h>
+#include <cassert>
+
+namespace sdbus { /*namespace internal {*/
+
+Variant::Variant()
+    : msg_(createPlainMessage())
+{
+}
+
+void Variant::serializeTo(Message& msg) const
+{
+    SDBUS_THROW_ERROR_IF(isEmpty(), "Empty variant is not allowed", EINVAL);
+    msg_.rewind(true);
+    msg_.copyTo(msg, true);
+}
+
+void Variant::deserializeFrom(Message& msg)
+{
+    msg.copyTo(msg_, false);
+    msg_.seal();
+}
+
+std::string Variant::peekValueType() const
+{
+    std::string type;
+    std::string contents;
+    msg_.peekType(type, contents);
+    return contents;
+}
+
+bool Variant::isEmpty() const
+{
+    return msg_.isEmpty();
+}
+
+}

src/VTableUtils.c

@@ -0,0 +1,72 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file VTableUtils.c
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "VTableUtils.h"
+#include <systemd/sd-bus.h>
+
+sd_bus_vtable createVTableStartItem()
+{
+    struct sd_bus_vtable vtableStart = SD_BUS_VTABLE_START(0);
+    return vtableStart;
+}
+
+sd_bus_vtable createVTableMethodItem( const char *member
+                                    , const char *signature
+                                    , const char *result
+                                    , sd_bus_message_handler_t handler )
+{
+    struct sd_bus_vtable vtableItem = SD_BUS_METHOD(member, signature, result, handler, SD_BUS_VTABLE_UNPRIVILEGED);
+    return vtableItem;
+}
+
+sd_bus_vtable createVTableSignalItem( const char *member
+                                    , const char *signature )
+{
+    struct sd_bus_vtable vtableItem = SD_BUS_SIGNAL(member, signature, 0);
+    return vtableItem;
+}
+
+sd_bus_vtable createVTablePropertyItem( const char *member
+                                      , const char *signature
+                                      , sd_bus_property_get_t getter )
+{
+    struct sd_bus_vtable vtableItem = SD_BUS_PROPERTY(member, signature, getter, 0, 0);
+    return vtableItem;
+}
+
+sd_bus_vtable createVTableWritablePropertyItem( const char *member
+                                              , const char *signature
+                                              , sd_bus_property_get_t getter
+                                              , sd_bus_property_set_t setter )
+{
+    struct sd_bus_vtable vtableItem = SD_BUS_WRITABLE_PROPERTY(member, signature, getter, setter, 0, 0);
+    return vtableItem;
+}
+
+sd_bus_vtable createVTableEndItem()
+{
+    struct sd_bus_vtable vtableEnd = SD_BUS_VTABLE_END;
+    return vtableEnd;
+}

src/VTableUtils.h

@@ -0,0 +1,55 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file VTableUtils.h
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CXX_INTERNAL_VTABLEUTILS_H_
+#define SDBUS_CXX_INTERNAL_VTABLEUTILS_H_
+
+#include <systemd/sd-bus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+sd_bus_vtable createVTableStartItem();
+sd_bus_vtable createVTableMethodItem( const char *member
+                                    , const char *signature
+                                    , const char *result
+                                    , sd_bus_message_handler_t handler );
+sd_bus_vtable createVTableSignalItem( const char *member
+                                    , const char *signature );
+sd_bus_vtable createVTablePropertyItem( const char *member
+                                      , const char *signature
+                                      , sd_bus_property_get_t getter );
+sd_bus_vtable createVTableWritablePropertyItem( const char *member
+                                              , const char *signature
+                                              , sd_bus_property_get_t getter
+                                              , sd_bus_property_set_t setter );
+sd_bus_vtable createVTableEndItem();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SDBUS_CXX_INTERNAL_VTABLEUTILS_H_ */