Struct specs_task::TaskData

pub struct TaskData<'a, P, S, M, F> { /* fields omitted */ }

Implementations

impl<'a, P, S, M, F> TaskData<'a, P, S, M, F> where
    P: GenericReadStorage<Component = TaskProgress>,
    S: GenericReadStorage<Component = SingleEdge>,
    M: GenericReadStorage<Component = MultiEdge>,
    &'a P: 'a + Join, 

pub fn make_task_with_entity_lazy<'b, T: TaskComponent<'b> + Send + Sync>(
    &self,
    entity: Entity,
    task: 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_lazy<'b, T: TaskComponent<'b> + Send + Sync>(
    &self,
    task: 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_lazy<'b, T: TaskComponent<'b> + Send + Sync>(
    &self,
    task: T,
    on_completion: OnCompletion
) -> Entity

pub fn make_fork_lazy(&self) -> Entity

Create a new fork entity with no children.

pub fn add_prong_lazy(&self, fork_entity: Entity, prong: Entity)

Add prong as a child on the MultiEdge of fork_entity.

pub fn join_lazy(&self, parent: Entity, child: Entity)

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

pub fn finalize_lazy(&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, task: Entity) -> bool

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

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

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

pub fn count_tasks_in_progress(&'a self) -> usize

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

pub fn delete_entity_and_descendents(&self, entity: Entity)

Deletes entity and all of its descendents.

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

Deletes the entity and descendents if they are all complete. Returns true iff the entity and all descendents are complete.

impl<'a> TaskData<'a, Storage<'a, TaskProgress, FetchMut<'a, MaskedStorage<TaskProgress>>>, Storage<'a, SingleEdge, FetchMut<'a, MaskedStorage<SingleEdge>>>, Storage<'a, MultiEdge, FetchMut<'a, MaskedStorage<MultiEdge>>>, Storage<'a, FinalTag, FetchMut<'a, MaskedStorage<FinalTag>>>>

pub fn make_task_with_entity<'b, T: TaskComponent<'b> + Send + Sync>(
    &mut self,
    entity: Entity,
    task: T,
    task_storage: &mut WriteStorage<T>
)

Like make_task, but use entity for tracking the task components.

pub fn make_task<'b, T: TaskComponent<'b> + Send + Sync>(
    &mut self,
    task: T,
    task_storage: &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<'b, T: TaskComponent<'b> + Send + Sync>(
    &mut self,
    entity: Entity,
    task: T,
    on_completion: OnCompletion,
    task_storage: &mut WriteStorage<T>
) -> Entity

Same as make_task_with_entity, but also finalizes the task.

pub fn make_final_task<'b, T: TaskComponent<'b> + Send + Sync>(
    &mut self,
    task: T,
    on_completion: OnCompletion,
    task_storage: &mut WriteStorage<T>
) -> 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)

Add prong as a child on the MultiEdge of fork_entity.

pub fn join(&mut self, parent: Entity, child: Entity)

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.

Trait Implementations

impl<'a, P, S, M, F> SystemData<'a> for TaskData<'a, P, S, M, F> where
    Entities<'a>: SystemData<'a>,
    Read<'a, LazyUpdate>: SystemData<'a>,
    P: SystemData<'a>,
    S: SystemData<'a>,
    M: SystemData<'a>,
    F: 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.