Revision control
Copy as Markdown
// 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
#include <QtTaskTree/qconditional.h>
QT_BEGIN_NAMESPACE
namespace QtTaskTree {
/*!
\class QtTaskTree::If
\inheaderfile qconditional.h
\inmodule QtTaskTree
\brief An "if" element used in conditional expressions.
\reentrant
An initial condition element of the conditional expressions.
Must always be followed by \l Then element.
The conditional expressions in the TaskTree module enable processing of
branch conditions and their bodies in an asynchronous way. For example:
\code
const Group recipe {
If (conditionTask1) >> Then {
bodyTask1
} >> ElseIf (conditionTask2) >> Then {
bodyTask2
} >> Else {
bodyTask3
}
};
\endcode
When the above recipe is run with QTaskTree, the task tree starts the
asynchronous \c conditionTask1 first. After it's finished,
depending on the result, the task tree may either execute the
\c bodyTask1 when the \c conditionTask1 finished with success,
or dispatch another condition by executing \c conditionTask2 otherwise.
In case the \c bodyTask1 is executed, no other tasks are executed,
and the result of \c bodyTask1 is the final result of the whole
conditional expression.
\sa Then, Else, ElseIf
*/
class IfPrivate : public QSharedData
{
public:
IfPrivate(const ExecutableItem &condition) : m_condition(condition) {}
ExecutableItem m_condition;
};
/*!
\fn template <typename Handler, std::enable_if_t<!std::is_base_of_v<ExecutableItem, std::decay_t<Handler>>, bool> = true> If::If(Handler &&handler)
\overload
A helper constructor accepting the synchronous \a handler to be executed
when evaluating the initial condition by the running QTaskTree.
It's a shortcut for:
\code
If (QSyncTask(handler))
\endcode
See \l QSyncTask for more information on what handler types are acceptable.
\sa QSyncTask, ElseIf
*/
/*!
Creates an initial condition element with \a condition task to be used in
conditional expression. The running QTaskTree executes the passed
\a condition first, and after it's finished, either the \l Then branch
is executed (on success), or optionally provided \l Else branch
or \l ElseIf condition otherwise.
The passed \a condition may consist of multiple tasks enclosed
in \l Group element, or be a conjunction or disjunction of them, like:
\code
const Group subRecipe {
parallel,
parallelConditionTask1,
parallelConditionTask2
};
const Group recipe {
If (conditionTask1 && !conditionTask2) >> Then {
bodyTask1
} >> ElseIf (subRecipe) >> Then {
bodyTask2
} >> Else {
bodyTask3
}
};
\endcode
*/
If::If(const ExecutableItem &condition) : d(new IfPrivate{condition}) {}
ExecutableItem If::condition() const { return d->m_condition; }
/*!
\class QtTaskTree::ElseIf
\inheaderfile qconditional.h
\inmodule QtTaskTree
\brief An "else if" element used in conditional expressions.
\reentrant
An alternative condition element of the conditional expressions.
Must always be preceeded and followed by \l Then element.
\sa If, Then, Else
*/
class ElseIfPrivate : public QSharedData
{
public:
ElseIfPrivate(const ExecutableItem &condition) : m_condition(condition) {}
ExecutableItem m_condition;
};
/*!
\fn template <typename Handler, std::enable_if_t<!std::is_base_of_v<ExecutableItem, std::decay_t<Handler>>, bool> = true> ElseIf::ElseIf(Handler &&handler)
\overload
A helper constructor accepting the synchronous \a handler to be executed
when evaluating the initial condition by the running QTaskTree.
It's a shortcut for:
\code
ElseIf (QSyncTask(handler))
\endcode
See \l QSyncTask for more information on what handler types are acceptable.
\sa QSyncTask, If
*/
/*!
Creates an alternative condition element with \a condition task
to be used in conditional expression.
\sa If
*/
ElseIf::ElseIf(const ExecutableItem &condition) : d(new ElseIfPrivate{condition}) {}
ExecutableItem ElseIf::condition() const { return d->m_condition; }
/*!
\class QtTaskTree::Else
\inheaderfile qconditional.h
\inmodule QtTaskTree
\brief An "else" element used in conditional expressions.
\reentrant
A body of an else branch of the conditional expressions.
Must always be preceeded by \l Then element.
\sa If, Then, ElseIf
*/
class ElsePrivate : public QSharedData
{
public:
ElsePrivate(const Group &body) : m_body(body) {}
Group m_body;
};
/*!
Creates an else branch body element of the conditional expressions
with \a children items. If the previous condition finishes with an error,
the preceeding \l Then body is skipped, and \c this branch is selected.
In this case the running QTaskTree executes the \a children,
and the result of this execution is the final result of the whole
conditional expression.
*/
Else::Else(const GroupItems &children) : d(new ElsePrivate{{children}}) {}
/*!
\overload
Constructs an else branch body element from \c std::initializer_list
given by \a children.
*/
Else::Else(std::initializer_list<GroupItem> children) : d(new ElsePrivate{{children}}) {}
Group Else::body() const { return d->m_body; }
/*!
\class QtTaskTree::Then
\inheaderfile qconditional.h
\inmodule QtTaskTree
\brief A "then" element used in conditional expressions.
\reentrant
A branch body element of the conditional expressions.
Must always be preceeded by \l If or \l ElseIf element.
May be followed by \l Else or \l ElseIf element.
\sa If, Else, ElseIf
*/
class ThenPrivate : public QSharedData
{
public:
ThenPrivate(const Group &body) : m_body(body) {}
Group m_body;
};
/*!
Creates a branch body element with \a children items, to be used in
conditional expression. If the preceeding \l If or \l ElseIf element
finishes with success, the running QTaskTree executes the \a children,
and the result of this execution is the final result of the whole
conditional expression.
*/
Then::Then(const GroupItems &children) : d(new ThenPrivate{{children}}) {}
/*!
\overload
Constructs a branch body element from \c std::initializer_list
given by \a children.
*/
Then::Then(std::initializer_list<GroupItem> children) : d(new ThenPrivate{{children}}) {}
Group Then::body() const { return d->m_body; }
class ConditionData final
{
public:
std::optional<ExecutableItem> m_condition = std::nullopt;
Group m_body;
};
static Group conditionRecipe(const Storage<bool> &bodyExecutedStorage, const ConditionData &condition)
{
const auto onSetup = [bodyExecutedStorage] {
return *bodyExecutedStorage ? SetupResult::StopWithSuccess : SetupResult::Continue;
};
const auto onBodyDone = [bodyExecutedStorage] { *bodyExecutedStorage = true; };
const Group bodyTask { condition.m_body, onGroupDone(onBodyDone) };
return {
onGroupSetup(onSetup),
condition.m_condition ? Group { !*condition.m_condition || bodyTask } : bodyTask
};
}
static ExecutableItem conditionsRecipe(const QList<ConditionData> &conditions)
{
Storage<bool> bodyExecutedStorage;
GroupItems recipes;
for (const ConditionData &condition : conditions)
recipes << conditionRecipe(bodyExecutedStorage, condition);
return Group { bodyExecutedStorage, recipes };
}
class ThenItemPrivate : public QSharedData
{
public:
ThenItemPrivate(const QList<ConditionData> &conditions) : m_conditions(conditions) {}
QList<ConditionData> m_conditions;
};
ThenItem::operator ExecutableItem() const
{
return conditionsRecipe(d->m_conditions);
}
ThenItem::ThenItem(const If &ifItem, const Then &thenItem)
: d(new ThenItemPrivate{{{ifItem.condition(), thenItem.body()}}}) {}
ThenItem::ThenItem(const ElseIfItem &elseIfItem, const Then &thenItem)
: d(new ThenItemPrivate{elseIfItem.conditions()})
{
d->m_conditions.append({elseIfItem.nextCondition(), thenItem.body()});
}
QList<ConditionData> ThenItem::conditions() const { return d->m_conditions; }
class ElseItemPrivate : public QSharedData
{
public:
ElseItemPrivate(const QList<ConditionData> &conditions) : m_conditions(conditions) {}
QList<ConditionData> m_conditions;
};
ElseItem::operator ExecutableItem() const
{
return conditionsRecipe(d->m_conditions);
}
ElseItem::ElseItem(const ThenItem &thenItem, const Else &elseItem)
: d(new ElseItemPrivate{thenItem.conditions()})
{
d->m_conditions.append({{}, elseItem.body()});
}
class ElseIfItemPrivate : public QSharedData
{
public:
ElseIfItemPrivate(const QList<ConditionData> &conditions, const ExecutableItem &nextCondition)
: m_conditions(conditions)
, m_nextCondition(nextCondition)
{}
QList<ConditionData> m_conditions;
ExecutableItem m_nextCondition;
};
ElseIfItem::ElseIfItem(const ThenItem &thenItem, const ElseIf &elseIfItem)
: d(new ElseIfItemPrivate{thenItem.conditions(), elseIfItem.condition()}) { }
QList<ConditionData> ElseIfItem::conditions() const { return d->m_conditions; }
ExecutableItem ElseIfItem::nextCondition() const { return d->m_nextCondition; }
ThenItem operator>>(const If &ifItem, const Then &thenItem)
{
return {ifItem, thenItem};
}
ThenItem operator>>(const ElseIfItem &elseIfItem, const Then &thenItem)
{
return {elseIfItem, thenItem};
}
ElseIfItem operator>>(const ThenItem &thenItem, const ElseIf &elseIfItem)
{
return {thenItem, elseIfItem};
}
ElseItem operator>>(const ThenItem &thenItem, const Else &elseItem)
{
return {thenItem, elseItem};
}
QT_TASKTREE_DEFINE_SMF(Else)
QT_TASKTREE_DEFINE_SMF(ElseIf)
QT_TASKTREE_DEFINE_SMF(ElseIfItem)
QT_TASKTREE_DEFINE_SMF(ElseItem)
QT_TASKTREE_DEFINE_SMF(If)
QT_TASKTREE_DEFINE_SMF(Then)
QT_TASKTREE_DEFINE_SMF(ThenItem)
} // namespace QtTaskTree
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QtTaskTree::ElsePrivate)
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QtTaskTree::ElseIfPrivate)
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QtTaskTree::ElseIfItemPrivate)
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QtTaskTree::ElseItemPrivate)
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QtTaskTree::IfPrivate)
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QtTaskTree::ThenPrivate)
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QtTaskTree::ThenItemPrivate)
QT_END_NAMESPACE