slot.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2016 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_SLOT_H
#define SWIFT_MISC_SLOT_H
 
#include <atomic>
#include <functional>
#include <future>
#include <memory>
 
#include <QObject>
#include <QPointer>
#include <QTimer>
#include <QtGlobal>
 
#include "misc/invoke.h"
 
namespace swift::misc
{
    template <typename T, typename U, typename F, typename G>
    QMetaObject::Connection connectOnce(T *sender, F signal, U *receiver, G &&slot,
                                        Qt::ConnectionType type = Qt::AutoConnection)
    {
        std::promise<QMetaObject::Connection> promise;
        auto called = std::make_shared<std::atomic_flag>();
        called->clear();
        auto wrapper = [receiver, called, connection = promise.get_future().share(),
                        slot = std::forward<G>(slot)](auto &&...args) {
            if (called->test_and_set()) { return; }
            QObject::disconnect(connection.get());
            private_ns::invokeSlot(slot, receiver, std::forward<decltype(args)>(args)...);
        };
        auto connection = QObject::connect(sender, signal, receiver, std::move(wrapper), type);
        promise.set_value(connection);
        return connection;
    }
 
    template <typename T, typename F, typename G>
    QMetaObject::Connection connectOnce(T *sender, F signal, G &&slot)
    {
        static_assert(!std::is_member_pointer_v<std::decay_t<G>>,
                      "If slot is a pointer to member, a receiver must be supplied");
        return connectOnce(sender, signal, sender, std::forward<G>(slot));
    }
 
    template <typename F>
    class CSlot;
 
    template <typename R, typename... Args>
    class CSlot<R(Args...)>
    {
    public:
        CSlot() {}
 
        template <typename T, typename U>
        CSlot(T *object, R (U::*function)(Args...))
            : m_object(object), m_function([=](Args... args) { return (object->*function)(args...); })
        {
            Q_ASSERT_X(object, Q_FUNC_INFO, "Need object");
        }
 
        template <typename T>
        CSlot(T *object, std::function<R(Args...)> function) : m_object(object), m_function(function)
        {}
 
        R operator()(Args... args) const
        {
            Q_ASSERT_X(m_function, Q_FUNC_INFO, "Empty CSlot was called");
            return m_function(args...);
        }
 
        bool singleShot(Args... args) const
        {
            // does NOT return the values of m_function!
            if (!m_object || !m_function) { return false; }
            QTimer::singleShot(0, m_object.data(), std::bind(*this, std::forward<Args>(args)...));
            return true;
        }
 
        QObject *object() const { return m_object.data(); }
 
        void setObject(QObject *object)
        {
            Q_ASSERT_X(hasNullObject(), Q_FUNC_INFO, "Can only set, not change the object");
            m_object = object;
        }
 
        operator bool() const { return !this->isEmpty() && !this->hasNullObject(); }
 
        bool operator!() const { return this->isEmpty() || this->hasNullObject(); }
 
        bool isEmpty() const { return !m_function; }
 
        bool hasNullObject() const { return m_object.isNull(); }
 
    private:
        QPointer<QObject> m_object;
        std::function<R(Args...)> m_function;
    };
} // namespace swift::misc
 
#endif // SWIFT_MISC_SLOT_H