Struct Builder

pub struct Builder<'a> { /* private fields */ }

Builder for the Dispatcher.

Barriers

Barriers are a way of sequentializing parts of the system execution. See add_barrier()/with_barrier().

Examples

This is how you create a dispatcher with a shared thread pool:

let dispatcher = Dispatcher::builder()
    .with(system_a, "a", &[])
    .unwrap()
    .with(system_b, "b", &["a"])
    .unwrap() // b depends on a
    .with(system_c, "c", &["a"])
    .unwrap() // c also depends on a
    .with(system_d, "d", &[])
    .unwrap()
    .with(system_e, "e", &["c", "d"])
    .unwrap() // e executes after c and d are finished
    .build();

Systems can be conditionally added by using the add_ functions:

let mut builder = Dispatcher::builder().with(system_a, "a", &[]).unwrap();

if b_enabled {
    builder.add(system_b, "b", &[]).unwrap();
}

let dispatcher = builder.build();

Implementations

impl<'a> Builder<'a>

pub fn new(world: Option<&'a mut World>) -> Self

pub fn build(self) -> Dispatcher

Builds the Dispatcher.

This method will precompute useful information in order to speed up dispatching.

pub fn with<S>( self, system: S, name: &str, dependencies: &[&str], ) -> Result<Self, Error>

where S: for<'s> System<'s> + Send + 'static,

Adds a new system with a given name and a list of dependencies. Please note that the dependency should be added before you add the depending system.

If you want to register systems which can not be specified as dependencies, you can use "" as their name, which will not panic (using another name twice will).

Same as add(), but returns self to enable method chaining.

pub fn add<S>( &mut self, system: S, name: &str, dependencies: &[&str], ) -> Result<&mut Self, Error>

where S: for<'s> System<'s> + Send + 'static,

Adds a new system with a given name and a list of dependencies. Please note that the dependency should be added before you add the depending system.

If you want to register systems which can not be specified as dependencies, you can use "" as their name, which will not panic (using another name twice will).

pub fn with_async<S>( self, system: S, name: &str, dependencies: &[&str], ) -> Result<Self, Error>

where S: for<'s> AsyncSystem<'s> + Send + 'static,

Adds a new asynchronous system with a given name and a list of dependencies. Please note that the dependency should be added before you add the depending system.

If you want to register systems which can not be specified as dependencies, you can use "" as their name, which will not panic (using another name twice will).

Same as add(), but returns self to enable method chaining.

pub fn add_async<S>( &mut self, system: S, name: &str, dependencies: &[&str], ) -> Result<&mut Self, Error>

where S: for<'s> AsyncSystem<'s> + Send + 'static,

Adds a new asynchronous system with a given name and a list of dependencies. Please note that the dependency should be added before you add the depending system.

If you want to register systems which can not be specified as dependencies, you can use "" as their name, which will not panic (using another name twice will).

pub fn with_local<S>( self, system: S, name: &str, dependencies: &[&str], ) -> Result<Self, Error>

where S: for<'s> System<'s> + 'static,

Adds a new thread local system.

Please only use this if your struct is not Send and Sync.

Thread-local systems are dispatched in-order.

Same as [Dispatcher::builder()::add_local], but returns self to enable method chaining.

pub fn add_local<S>( &mut self, system: S, name: &str, dependencies: &[&str], ) -> Result<&mut Self, Error>

where S: for<'s> System<'s> + 'static,

Adds a new thread local system.

Please only use this if your struct is not Send and Sync.

Thread-local systems are dispatched in-order.

pub fn with_local_async<S>( self, system: S, name: &str, dependencies: &[&str], ) -> Result<Self, Error>

where S: for<'s> AsyncSystem<'s> + 'static,

Adds a new thread local asynchronous system.

Please only use this if your struct is not Send and Sync.

Thread-local systems are dispatched in-order.

Same as [Dispatcher::builder()::add_local], but returns self to enable method chaining.

pub fn add_local_async<S>( &mut self, system: S, name: &str, dependencies: &[&str], ) -> Result<&mut Self, Error>

where S: for<'s> AsyncSystem<'s> + 'static,

Adds a new thread local asynchronous system.

Please only use this if your struct is not Send and Sync.

Thread-local systems are dispatched in-order.