helios::async::Task Class Reference

Represents a single task within a task graph. More...

#include <task.hpp>

Public Member Functions
	Task ()=default
	Task (const Task &)=default
	Task (Task &&)=default
	~Task ()=default
Task &	operator= (const Task &)=default
Task &	operator= (Task &&)=default
void	Reset ()
	Resets the task handle to an empty state.
void	ResetWork ()
	Removes the work callable from this task.
template<AnyTask C>
Task &	Work (C &&callable)
	Assigns work to this task.
template<typename... Tasks> requires (std::same_as<std::remove_cvref_t<Tasks>, Task> && ...)
Task &	Precede (Tasks &&... tasks)
	Makes this task run before the specified tasks.
template<std::ranges::range R> requires std::same_as<std::ranges::range_value_t<R>, Task>
Task &	Precede (const R &tasks)
	Makes this task run before all tasks in the specified range.
template<typename... Tasks> requires (std::same_as<std::remove_cvref_t<Tasks>, Task> && ...)
Task &	Succeed (Tasks &&... tasks)
	Makes this task run after the specified tasks.
template<std::ranges::range R> requires std::same_as<std::ranges::range_value_t<R>, Task>
Task &	Succeed (const R &tasks)
	Makes this task run after all tasks in the specified range.
Task &	Name (const std::string &name)
	Assigns a name to this task.
bool	operator== (const Task &other) const
bool	operator!= (const Task &other) const
bool	HasWork () const
	Checks if this task has assigned work.
bool	Empty () const
	Checks if this task handle is empty (not associated with any task).
size_t	Hash () const
	Returns a hash value for this task.
size_t	SuccessorsCount () const
	Gets the number of tasks that depend on this task.
size_t	PredecessorsCount () const
	Gets the number of tasks this task depends on.
size_t	StrongDependenciesCount () const
	Gets the number of strong dependencies this task has.
size_t	WeakDependenciesCount () const
	Gets the number of weak dependencies this task has.
std::string_view	Name () const
	Gets the name of this task.
TaskType	Type () const
	Gets the type of this task.

Friends
class	TaskGraph
class	SubTaskGraph
class	TaskGraphBuilder
class	Executor

Detailed Description

Represents a single task within a task graph.

Task objects are lightweight handles - copying them is safe and efficient. Wraps tf::Task and provides methods to manage task dependencies, work assignment, and metadata. Tasks can be static (simple callable) or dynamic (subtasks). The underlying task data is managed by the TaskGraph.

Note

Not thread-safe.

Definition at line 28 of file task.hpp.

Constructor & Destructor Documentation

Task() [1/3]

helios::async::Task::Task ( )

default

Task() [2/3]

helios::async::Task::Task ( const Task &  )

default

Task() [3/3]

helios::async::Task::Task ( Task &&  )

default

~Task()

helios::async::Task::~Task ( )

default

Member Function Documentation

Empty()

bool helios::async::Task::Empty ( ) const

inline

Checks if this task handle is empty (not associated with any task).

Returns

True if task id empty, false otherwise.

Definition at line 134 of file task.hpp.

{ return task_.empty(); }

Hash()

size_t helios::async::Task::Hash ( ) const

inline

Returns a hash value for this task.

Returns

Hash of task or 0 if current task is empty.

Definition at line 242 of file task.hpp.

                               {
  if (Empty()) [[unlikely]] {
    return 0;
  }
 
  return task_.hash_value();
}

HasWork()

bool helios::async::Task::HasWork ( ) const

inline

Checks if this task has assigned work.

Returns

True if task has work, false otherwise.

Definition at line 128 of file task.hpp.

{ return task_.has_work(); }

Name() [1/2]

std::string_view helios::async::Task::Name ( ) const

inline

Gets the name of this task.

Returns

Returns empty std::string_view if current task is empty.

Definition at line 282 of file task.hpp.

                                       {
  if (Empty()) [[unlikely]] {
    return {};
  }
 
  return task_.name();
}

Name() [2/2]

Task & helios::async::Task::Name ( const std::string &  name )

inline

Assigns a name to this task.

Warning

Triggers assertion if current task is empty.

Parameters

name	Name for the task (must not be empty)

Returns

Reference to this task for method chaining

Definition at line 235 of file task.hpp.

                                             {
  HELIOS_ASSERT(!Empty(), "Failed to set task name: Cannot assign name to empty task!");
  HELIOS_ASSERT(!name.empty(), "Failed to set task name: 'name' cannot be empty!");
  task_.name(name);
  return *this;
}

operator!=()

bool helios::async::Task::operator!= ( const Task &  other ) const

inline

Definition at line 122 of file task.hpp.

{ return !(*this == other); }

operator=() [1/2]

Task & helios::async::Task::operator= ( const Task &  )

default

operator=() [2/2]

Task & helios::async::Task::operator= ( Task &&  )

default

operator==()

bool helios::async::Task::operator== ( const Task &  other ) const

inline

Definition at line 121 of file task.hpp.

{ return task_ == other.task_; }

Precede() [1/2]

template<std::ranges::range R>
requires std::same_as<std::ranges::range_value_t<R>, Task>

Task & helios::async::Task::Precede ( const R &  tasks )

inline

Makes this task run before all tasks in the specified range.

Warning

Triggers assertion in next cases:

• Current task is empty.
• Any task in the range is empty.

Template Parameters

R	Range type containing Task objects

Parameters

tasks

Range of tasks that should run after this task

Returns

Reference to this task for method chaining

Definition at line 208 of file task.hpp.

                                         {
  HELIOS_ASSERT(!Empty(), "Failed to precede task: Task cannot be empty!");
  auto view = tasks | std::ranges::views::filter([](const auto& task) { return !task.Empty(); });
  for (const auto& task : view) {
    task_.precede(task.task_);
  }
  return *this;
}

Precede() [2/2]

template<typename... Tasks>
requires (std::same_as<std::remove_cvref_t<Tasks>, Task> && ...)

Task & helios::async::Task::Precede ( Tasks &&...  tasks )

inline

Makes this task run before the specified tasks.

Warning

Triggers assertion if current task is empty.

Template Parameters

Tasks

Task parameter pack

Parameters

tasks

Tasks that should run after this task

Returns

Reference to this task for method chaining

Definition at line 201 of file task.hpp.

                                           {
  HELIOS_ASSERT(!Empty(), "Failed to precede task: Task cannot be empty!");
  return Precede(std::to_array({std::forward<Tasks>(tasks)...}));
}

PredecessorsCount()

size_t helios::async::Task::PredecessorsCount ( ) const

inline

Gets the number of tasks this task depends on.

Returns

Count of predecessors or 0 if current task is empty.

Definition at line 258 of file task.hpp.

                                            {
  if (Empty()) [[unlikely]] {
    return 0;
  }
 
  return task_.num_predecessors();
}

Reset()

void helios::async::Task::Reset ( )

inline

Resets the task handle to an empty state.

Note

Not thread-safe.

Definition at line 42 of file task.hpp.

{ task_.reset(); }

ResetWork()

void helios::async::Task::ResetWork ( )

inline

Removes the work callable from this task.

Note

Not thread-safe.

Definition at line 48 of file task.hpp.

{ task_.reset_work(); }

StrongDependenciesCount()

size_t helios::async::Task::StrongDependenciesCount ( ) const

inline

Gets the number of strong dependencies this task has.

Returns

Count of strong dependencies or 0 if current task is empty.

Definition at line 266 of file task.hpp.

                                                  {
  if (Empty()) [[unlikely]] {
    return 0;
  }
 
  return task_.num_strong_dependencies();
}

Succeed() [1/2]

template<std::ranges::range R>
requires std::same_as<std::ranges::range_value_t<R>, Task>

Task & helios::async::Task::Succeed ( const R &  tasks )

inline

Makes this task run after all tasks in the specified range.

Warning

Triggers assertion in next cases:

• Current task is empty.
• Any task in the range is empty.

Template Parameters

R	Range type containing Task objects

Parameters

tasks

Range of tasks that should run before this task

Returns

Reference to this task for method chaining

Definition at line 226 of file task.hpp.

                                         {
  HELIOS_ASSERT(!Empty(), "Failed to succeed task: Task cannot be empty!");
  auto view = tasks | std::ranges::views::filter([](const auto& task) { return !task.Empty(); });
  for (const auto& task : view) {
    task_.succeed(task.task_);
  }
  return *this;
}

Succeed() [2/2]

template<typename... Tasks>
requires (std::same_as<std::remove_cvref_t<Tasks>, Task> && ...)

Task & helios::async::Task::Succeed ( Tasks &&...  tasks )

inline

Makes this task run after the specified tasks.

Warning

Triggers assertion in next cases:

• Current task is empty.
• Any task in the parameter pack is empty.

Template Parameters

Tasks

Task parameter pack

Parameters

tasks

Tasks that should run before this task

Returns

Reference to this task for method chaining

Definition at line 219 of file task.hpp.

                                           {
  HELIOS_ASSERT(!Empty(), "Failed to succeed task: Task cannot be empty!");
  return Succeed(std::to_array({std::forward<Tasks>(tasks)...}));
}

SuccessorsCount()

size_t helios::async::Task::SuccessorsCount ( ) const

inline

Gets the number of tasks that depend on this task.

Returns

Count of successors or '0' if current task is empty.

Definition at line 250 of file task.hpp.

                                          {
  if (Empty()) [[unlikely]] {
    return 0;
  }
 
  return task_.num_successors();
}

Type()

TaskType helios::async::Task::Type ( ) const

inline

Gets the type of this task.

Returns TaskType::Undefined if current task is empty.

Definition at line 290 of file task.hpp.

                                 {
  if (Empty()) [[unlikely]] {
    return TaskType::Undefined;
  }
 
  return details::ConvertTaskType(task_.type());
}

WeakDependenciesCount()

size_t helios::async::Task::WeakDependenciesCount ( ) const

inline

Gets the number of weak dependencies this task has.

Returns

Count of weak dependencies or 0 if current task is empty.

Definition at line 274 of file task.hpp.

                                                {
  if (Empty()) [[unlikely]] {
    return 0;
  }
 
  return task_.num_weak_dependencies();
}

Work()

template<AnyTask C>

Task & helios::async::Task::Work ( C &&  callable )

inline

Assigns work to this task.

Warning

Triggers assertion if current task is empty.

Template Parameters

C	Callable type

Parameters

callable

Function to execute when this task runs

Returns

Reference to this task for method chaining

Definition at line 193 of file task.hpp.

                                    {
  HELIOS_ASSERT(!Empty(), "Failed to set task work: Cannot assign work to empty task!");
  task_.work(std::forward<C>(callable));
  return *this;
}

Friends And Related Symbol Documentation

Executor

friend class Executor

friend

Definition at line 189 of file task.hpp.

SubTaskGraph

friend class SubTaskGraph

friend

Definition at line 187 of file task.hpp.

TaskGraph

friend class TaskGraph

friend

Definition at line 186 of file task.hpp.

TaskGraphBuilder

friend class TaskGraphBuilder

friend

Definition at line 188 of file task.hpp.