Crate shred

Shared resource dispatcher

This library allows to dispatch systems, which can have interdependencies, shared and exclusive resource access, in parallel.

Examples

extern crate shred;
#[macro_use]
extern crate shred_derive;

use shred::{DispatcherBuilder, Read, Resource, Resources, System, Write};

#[derive(Debug, Default)]
struct ResA;

#[derive(Debug, Default)]
struct ResB;

#[derive(SystemData)]
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);
    }
}


fn main() {
    let mut resources = Resources::new();
    let mut dispatcher = DispatcherBuilder::new()
        .with(EmptySystem, "empty", &[])
        .build();
    resources.insert(ResA);
    resources.insert(ResB);

    dispatcher.dispatch(&mut resources);
}

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

cell	Helper module for some internals, most users don't need to interact with it.

Macros

par	The par! macro may be used to easily create a structure which runs things in parallel.
seq	The seq! macro may be used to easily create a structure which runs things sequentially.

Structs

AsyncDispatcher	Like, Dispatcher but works asynchronously.
DefaultProvider	A SetupHandler that simply uses the default implementation.
Dispatcher	The dispatcher struct, allowing systems to be executed in parallel.
DispatcherBuilder	Builder for the Dispatcher.
Entry	An entry to a resource of the Resources struct. This is similar to the Entry API found in the standard library.
Fetch	Allows to fetch a resource in a system immutably.
FetchMut	Allows to fetch a resource in a system mutably.
MetaIter	An iterator for the MetaTable.
MetaIterMut	A mutable iterator for the MetaTable.
MetaTable	The MetaTable which allows to store object-safe trait implementations for resources.
PanicHandler	A setup handler that simply does nothing and thus will cause a panic on fetching. The panic will provide the type name if the nightly feature of shred is enabled.
Par	Runs two tasks in parallel. These two tasks are called head and tail in the following documentation.
ParSeq	A dispatcher intended to be used with Par and Seq structures.
Read	Allows to fetch a resource in a system immutably.
ResourceId	The id of a Resource, which is a tuple struct with a type id and an additional resource id (represented with a usize).
Resources	A resource container, which provides methods to access to the contained resources.
Seq	Runs two tasks sequentially. These two tasks are called head and tail in the following documentation.
StaticAccessor	The static accessor that is used for SystemData.
Write	Allows to fetch a resource in a system mutably.

Enums

AccessorCow	Either an Accessor of the system T or a reference to it.
RunningTime

Traits

Accessor	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.
CastFrom	Helper trait for the MetaTable. This trait is required to be implemented for a trait to be compatible with the meta table.
DynamicSystemData	A struct implementing system data indicates that it bundles some resources which are required for the execution.
Resource	A resource defines a set of data which can only be accessed according to Rust's typical borrowing model (one writer xor multiple readers).
RunNow	Trait for fetching data and running systems. Automatically implemented for systems.
RunWithPool	Similar to RunNow except additionally taking in a rayon::ThreadPool for parallelism.
SetupHandler	A setup handler performing the fetching of T.
System	A System, executed with a set of required Resources.
SystemData	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

ReadExpect	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.
WriteExpect	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.