Revision control
++ // 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