Struct specs_task::TaskManager

pub struct TaskManager<'a> { /* fields omitted */ }

The main object for users of this module. Used for creating and connecting tasks.

Methods

impl<'_> TaskManager<'_>

pub fn make_task_with_entity<'a, T: TaskComponent<'a>>(
    &mut self,
    entity: Entity,
    task: T,
    tasks: &mut WriteStorage<T>
)

Like make_task, but use entity for tracking the task components. This can make it easier to manage tasks coupled with a specific entity (rather than storing a separate task entity in a component).

pub fn make_task<'a, T: TaskComponent<'a>>(
    &mut self,
    task: T,
    tasks: &mut WriteStorage<T>
) -> Entity

Create a new task entity with the given TaskComponent. The task will not make progress until it is either finalized or the descendent of a finalized entity.

pub fn make_final_task_with_entity<'a, T: TaskComponent<'a>>(
    &mut self,
    entity: Entity,
    task: T,
    tasks: &mut WriteStorage<T>,
    on_completion: OnCompletion
) -> Entity

Same as make_task_with_entity, but also finalizes the task.

pub fn make_final_task<'a, T: TaskComponent<'a>>(
    &mut self,
    task: T,
    tasks: &mut WriteStorage<T>,
    on_completion: OnCompletion
) -> Entity

Same as make_task, but also finalizes the task.

pub fn make_fork(&mut self) -> Entity

Create a new fork entity with no children.

pub fn add_prong(
    &mut self,
    fork_entity: Entity,
    prong: Entity
) -> Result<(), UnexpectedEntity>

Add prong as a child on the MultiEdge of fork_entity.

pub fn join(
    &mut self,
    parent: Entity,
    child: Entity
) -> Result<(), AlreadyJoined>

Creates a SingleEdge from parent to child. Creates a fork-join if parent is a fork.

pub fn finalize(&mut self, entity: Entity, on_completion: OnCompletion)

Mark entity as final. This will make all of entity's descendents visible to the TaskManagerSystem, allowing them to make progress. If OnCompletion::Delete, then entity and all of its descendents will be deleted when entity is complete (and hence the entire graph is complete). Otherwise, you need to clean up the entities your self by calling delete_entity_and_descendents. God help you if you leak an orphaned entity.

pub fn task_is_complete(&self, entity: Entity) -> bool

Returns true iff the task was seen as complete on the last run of the TaskManagerSystem.

WARNING: assumes that this entity was at one point a task, and it can't tell otherwise.

pub fn entity_is_complete(&self, entity: Entity) -> bool

Tells you whether a fork or a task entity is complete.

WARNING: assumes that this entity was at one point a task or a fork, and it can't tell otherwise.

pub fn count_tasks_in_progress(&self) -> usize

Returns the number of tasks that haven't yet completed.

pub fn delete_descendents(&self, entity: Entity)

Deletes only the descendent entities of entity, but leaves entity alive.

pub fn delete_entity_and_descendents(&self, entity: Entity)

Deletes entity and all of its descendents.

Trait Implementations

impl<'a> SystemData<'a> for TaskManager<'a> where
    Entities<'a>: SystemData<'a>,
    WriteStorage<'a, TaskProgress>: SystemData<'a>,
    WriteStorage<'a, SingleEdge>: SystemData<'a>,
    WriteStorage<'a, MultiEdge>: SystemData<'a>,
    WriteStorage<'a, FinalTag>: SystemData<'a>, 

fn setup(world: &mut World)

Sets up the system data for fetching it from the World.

fn fetch(world: &'a World) -> Self

Fetches the system data from World. Note that this is only specified for one concrete lifetime 'a, you need to implement the SystemData trait for every possible lifetime.

fn reads() -> Vec<ResourceId>

Returns all read dependencies as fetched from Self::fetch.

fn writes() -> Vec<ResourceId>

Returns all write dependencies as fetched from Self::fetch.