qbarriertask.h - mozsearch

Enable keyboard shortcuts

// Copyright (C) 2025 Jarek Kobus

// Copyright (C) 2025 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:significant reason:default

#ifndef QTASKTREE_QBARRIERTASK_H

#define QTASKTREE_QBARRIERTASK_H

#include <QtTaskTree/qttasktreeglobal.h>

#include <QtTaskTree/qtasktree.h>

#include <QtCore/QSharedData>

QT_BEGIN_NAMESPACE

namespace QtTaskTree { class WhenPrivate; }

QT_DECLARE_QESDP_SPECIALIZATION_DTOR(QtTaskTree::WhenPrivate)

namespace QtTaskTree {

class QBarrierPrivate;

class Q_TASKTREE_EXPORT QBarrier : public QObject

    Q_OBJECT

    Q_DECLARE_PRIVATE(QBarrier)

public:

    QBarrier() : QBarrier(nullptr) {}

    explicit QBarrier(QObject *parent);

    ~QBarrier() override;

    void setLimit(qsizetype value);

    qsizetype limit() const;

    void start();

    void advance();

    void stopWithResult(DoneResult result);

    bool isRunning() const;

    qsizetype current() const;

    std::optional<DoneResult> result() const;

Q_SIGNALS:

    void done(QtTaskTree::DoneResult success, QPrivateSignal);

protected:

    bool event(QEvent *event) override;

};

using QBarrierTask = QCustomTask<QBarrier>;

class Q_TASKTREE_EXPORT QStartedBarrier : public QBarrier

    Q_OBJECT

public:

    QStartedBarrier() : QStartedBarrier(nullptr) {}

    explicit QStartedBarrier(QObject *parent);

    explicit QStartedBarrier(qsizetype limit, QObject *parent = nullptr);

    ~QStartedBarrier() override;

protected:

    bool event(QEvent *event) override;

};

using QStoredBarrier = Storage<QStartedBarrier>;

Q_TASKTREE_EXPORT ExecutableItem barrierAwaiterTask(const QStoredBarrier &storedBarrier);

template <typename Signal>

ExecutableItem signalAwaiterTask(const typename QtPrivate::FunctionPointer<Signal>::Object *sender,

                                 Signal signal)

    return QBarrierTask([sender, signal](QBarrier &barrier) {

        QObject::connect(sender, signal, &barrier, &QBarrier::advance, Qt::SingleShotConnection);

});

using BarrierKickerGetter = std::function<ExecutableItem(const QStoredBarrier &)>;

class When final

public:

    Q_TASKTREE_EXPORT explicit When(const BarrierKickerGetter &kicker,

                                    WorkflowPolicy policy = WorkflowPolicy::StopOnError);

    template <typename Task, typename Adapter, typename Deleter, typename Signal>

    explicit When(const QCustomTask<Task, Adapter, Deleter> &customTask, Signal signal,

                  WorkflowPolicy policy = WorkflowPolicy::StopOnError)

        : When(kickerForSignal(customTask, signal), policy)

{}

    QT_TASKTREE_DECLARE_SMFS(When, Q_TASKTREE_EXPORT)

private:

    Q_TASKTREE_EXPORT friend Group operator>>(const When &whenItem, const Do &doItem);

    template <typename Task, typename Adapter, typename Deleter, typename Signal>

    static BarrierKickerGetter kickerForSignal(const QCustomTask<Task, Adapter, Deleter> &task,

                                               Signal signal)

        return [taskHandler = task.taskHandler(), signal](const QStoredBarrier &barrier) {

            auto handler = std::move(taskHandler);

            const auto wrappedSetupHandler

                = [originalSetupHandler = std::move(handler.m_taskAdapterSetupHandler),

                   barrier, signal](void *taskAdapter) {

                const SetupResult setupResult = std::invoke(originalSetupHandler, taskAdapter);

                using TaskAdapter = typename QCustomTask<Task, Adapter, Deleter>::TaskAdapter;

                TaskAdapter *adapter = static_cast<TaskAdapter *>(taskAdapter);

                QObject::connect(adapter->task.get(), signal,

                                 barrier.activeStorage(), &QBarrier::advance);

                return setupResult;

};

            handler.m_taskAdapterSetupHandler = std::move(wrappedSetupHandler);

            return ExecutableItem(std::move(handler));

};

    QExplicitlySharedDataPointer<WhenPrivate> d;

};

} // namespace QtTaskTree

QT_END_NAMESPACE

#endif // QTASKTREE_QBARRIERTASK_H