mixindbus.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2014 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_MIXIN_MIXINDBUS_H
#define SWIFT_MISC_MIXIN_MIXINDBUS_H
 
#include <type_traits>
 
#include <QDBusArgument>
 
#include "misc/dbus.h"
#include "misc/inheritancetraits.h"
#include "misc/metaclass.h"
#include "misc/typetraits.h"
 
namespace swift::misc
{
    class CEmpty;
 
    class LosslessTag
    {};
 
    namespace mixin
    {
        template <class Derived, class...>
        class DBusOperators
        {
        public:
            friend const QDBusArgument &operator>>(const QDBusArgument &arg, Derived &obj)
            {
                arg.beginStructure();
                obj.unmarshallFromDbus(arg);
                arg.endStructure();
                return arg;
            }
 
            friend QDBusArgument &operator<<(QDBusArgument &arg, const Derived &obj)
            {
                arg.beginStructure();
                obj.marshallToDbus(arg);
                arg.endStructure();
                return arg;
            }
        };
        template <class Derived>
        class DBusOperators<Derived, LosslessTag>
        {};
 
        template <class Derived, class... Tags>
        class DBusByMetaClass : public DBusOperators<Derived, Tags...>
        {
        public:
            void marshallToDbus(QDBusArgument &arg, Tags...) const;
 
            void unmarshallFromDbus(const QDBusArgument &arg, Tags...);
 
        private:
            const Derived *derived() const;
            Derived *derived();
 
            template <typename T>
            static void baseMarshall(const T *base, QDBusArgument &arg);
            template <typename T>
            static void baseUnmarshall(T *base, const QDBusArgument &arg);
            static void baseMarshall(const void *, QDBusArgument &);
            static void baseUnmarshall(void *, const QDBusArgument &);
            static void baseMarshall(const CEmpty *, QDBusArgument &);
            static void baseUnmarshall(CEmpty *, const QDBusArgument &);
        };
 
        template <class Derived, class... Tags>
        void DBusByMetaClass<Derived, Tags...>::marshallToDbus(QDBusArgument &arg, Tags...) const
        {
            baseMarshall(static_cast<const TBaseOfT<Derived> *>(derived()), arg);
            introspect<Derived>().forEachMember([&, this](auto member) {
                if constexpr (!decltype(member)::has(MetaFlags<DisabledForMarshalling>()))
                {
                    const auto &value = member.in(*this->derived());
                    if constexpr (THasMarshallMethods<std::decay_t<decltype(value)>>::value)
                    {
                        if constexpr (member.has(MetaFlags<LosslessMarshalling>()))
                        {
                            value.marshallToDbus(arg, LosslessTag());
                        }
                        else { value.marshallToDbus(arg); }
                    }
                    else { arg << value; }
                }
            });
        }
 
        template <class Derived, class... Tags>
        void DBusByMetaClass<Derived, Tags...>::unmarshallFromDbus(const QDBusArgument &arg, Tags...)
        {
            baseUnmarshall(static_cast<TBaseOfT<Derived> *>(derived()), arg);
            introspect<Derived>().forEachMember([&, this](auto member) {
                if constexpr (!decltype(member)::has(MetaFlags<DisabledForMarshalling>()))
                {
                    auto &value = member.in(*this->derived());
                    if constexpr (THasMarshallMethods<std::decay_t<decltype(value)>>::value)
                    {
                        if constexpr (member.has(MetaFlags<LosslessMarshalling>()))
                        {
                            value.unmarshallFromDbus(arg, LosslessTag());
                        }
                        else { value.unmarshallFromDbus(arg); }
                    }
                    else { arg >> value; }
                }
            });
        }
 
        template <class Derived, class... Tags>
        const Derived *DBusByMetaClass<Derived, Tags...>::derived() const
        {
            return static_cast<const Derived *>(this);
        }
 
        template <class Derived, class... Tags>
        Derived *DBusByMetaClass<Derived, Tags...>::derived()
        {
            return static_cast<Derived *>(this);
        }
 
        template <class Derived, class... Tags>
        template <typename T>
        void DBusByMetaClass<Derived, Tags...>::baseMarshall(const T *base, QDBusArgument &arg)
        {
            base->marshallToDbus(arg, Tags()...);
        }
 
        template <class Derived, class... Tags>
        template <typename T>
        void DBusByMetaClass<Derived, Tags...>::baseUnmarshall(T *base, const QDBusArgument &arg)
        {
            base->unmarshallFromDbus(arg, Tags()...);
        }
 
        template <class Derived, class... Tags>
        void DBusByMetaClass<Derived, Tags...>::baseMarshall(const void *, QDBusArgument &)
        {}
 
        template <class Derived, class... Tags>
        void DBusByMetaClass<Derived, Tags...>::baseUnmarshall(void *, const QDBusArgument &)
        {}
 
        template <class Derived, class... Tags>
        void DBusByMetaClass<Derived, Tags...>::baseMarshall(const CEmpty *, QDBusArgument &)
        {}
 
        template <class Derived, class... Tags>
        void DBusByMetaClass<Derived, Tags...>::baseUnmarshall(CEmpty *, const QDBusArgument &)
        {}
 
        // *INDENT-OFF*
#define SWIFT_MISC_DECLARE_USING_MIXIN_DBUS(DERIVED, ...)                                                              \
    using ::swift::misc::mixin::DBusByMetaClass<DERIVED SWIFT_TRAILING_VA_ARGS(__VA_ARGS__)>::marshallToDbus;          \
    using ::swift::misc::mixin::DBusByMetaClass<DERIVED SWIFT_TRAILING_VA_ARGS(__VA_ARGS__)>::unmarshallFromDbus;
        // *INDENT-ON*
 
    } // namespace mixin
} // namespace swift::misc
 
#endif // SWIFT_MISC_MIXIN_MIXINDBUS_H