Expand description
Shared resource dispatcher
This library allows to dispatch systems, which can have interdependencies, shared and exclusive resource access, in parallel.
Examples
extern crate shred;
use shred::{DispatcherBuilder, Read, Resource, ResourceId, System, SystemData, World, Write};
#[derive(Debug, Default)]
struct ResA;
#[derive(Debug, Default)]
struct ResB;
#[derive(SystemData)] // Provided with `shred-derive` feature
struct Data<'a> {
a: Read<'a, ResA>,
b: Write<'a, ResB>,
}
struct EmptySystem;
impl<'a> System<'a> for EmptySystem {
type SystemData = Data<'a>;
fn run(&mut self, bundle: Data<'a>) {
println!("{:?}", &*bundle.a);
println!("{:?}", &*bundle.b);
}
}
let mut world = World::empty();
let mut dispatcher = DispatcherBuilder::new()
.with(EmptySystem, "empty", &[])
.build();
world.insert(ResA);
world.insert(ResB);
dispatcher.dispatch(&mut world);Once you are more familiar with how system data and parallelization works,
you can take look at a more flexible and performant way to dispatch:
ParSeq. Using it is bit trickier, but it allows dispatching without any
virtual function calls.
Modules
Helper module for some internals, most users don’t need to interact with it.
Macros
The par! macro may be used to easily create a structure
which runs things in parallel.
The seq! macro may be used to easily create a structure
which runs things sequentially.
Structs
Like, Dispatcher but works asynchronously.
The BatchAccessor is used to notify the main dispatcher of the read and
write resources of the Systems contained in the batch (“sub systems”).
The BatchUncheckedWorld wraps an instance of the world.
You have to specify this as SystemData for a System implementing
BatchController.
A SetupHandler that simply uses the default implementation.
The dispatcher struct, allowing systems to be executed in parallel.
Builder for the Dispatcher.
An entry to a resource of the World struct.
This is similar to the Entry API found in the standard library.
Allows to fetch a resource in a system immutably.
Allows to fetch a resource in a system mutably.
An iterator for the MetaTable.
A mutable iterator for the MetaTable.
The MetaTable which allows to store object-safe trait implementations for
resources.
A bridge from MultiDispatchController to BatchController.
A setup handler that simply does nothing and thus will cause a panic on fetching.
Runs two tasks in parallel.
These two tasks are called head and tail
in the following documentation.
A dispatcher intended to be used with
Par and Seq structures.
Allows to fetch a resource in a system immutably.
The id of a Resource, which simply wraps a type id and a “dynamic ID”.
The “dynamic ID” is usually just left 0, and, unless such documentation
says otherwise, other libraries will assume that it is always 0; non-zero
IDs are only used for special resource types that are specifically defined
in a more dynamic way, such that resource types can essentially be created
at run time, without having different static types.
Runs two tasks sequentially.
These two tasks are called head and tail
in the following documentation.
The static accessor that is used for SystemData.
A Resource container, which provides methods to insert, access and manage the contained resources.
Allows to fetch a resource in a system mutably.
Enums
Either an Accessor of the system T or a reference to it.
Traits
A trait for accessing read/write multiple resources from a system. This can be used to create dynamic systems that don’t specify what they fetch at compile-time.
The BatchController describes things that allow one to control how batches
of systems are executed.
Helper trait for the MetaTable.
This trait is required to be implemented for a trait to be compatible with
the meta table.
A struct implementing system data indicates that it bundles some resources which are required for the execution.
The controlling parts of simplified BatchControllers for running a batch
fixed number of times.
A resource is a data slot which lives in the World can only be accessed
according to Rust’s typical borrowing model (one writer xor multiple
readers).
Trait for fetching data and running systems. Automatically implemented for systems.
Similar to RunNow except additionally taking in a rayon::ThreadPool
for parallelism.
A setup handler performing the fetching of T.
A static system data that can specify its dependencies at statically (at
compile-time). Most system data is a SystemData, the DynamicSystemData
type is only needed for very special setups.
Type Definitions
Allows to fetch a resource in a system immutably.
This will panic if the resource does not exist.
Usage of Read or Option<Read> is therefore recommended.
Alias for World for easier migration to the new version. Will be removed
in the future.
Allows to fetch a resource in a system mutably.
This will panic if the resource does not exist.
Usage of Write or Option<Write> is therefore recommended.
Derive Macros
A reexport of the #[derive(SystemData] macro provided by shred-derive.
This requires that the shred-derive feature is enabled.
Used to #[derive] the trait SystemData.