1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
//! **Sh**ared **re**source **d**ispatcher //! //! This library allows to dispatch //! systems, which can have interdependencies, //! shared and exclusive resource access, in parallel. //! //! # Examples //! //! ```rust //! extern crate shred; //! #[macro_use] //! extern crate shred_derive; //! //! use shred::{DispatcherBuilder, Fetch, FetchMut, Resource, Resources, System}; //! //! #[derive(Debug)] //! struct ResA; //! //! impl Resource for ResA {} //! //! #[derive(Debug)] //! struct ResB; //! //! impl Resource for ResB {} //! //! #[derive(SystemData)] //! struct Data<'a> { //! a: Fetch<'a, ResA>, //! b: FetchMut<'a, ResB>, //! } //! //! struct EmptySystem; //! //! impl<'a, C> System<'a, C> for EmptySystem { //! type SystemData = Data<'a>; //! //! fn work(&mut self, bundle: Data<'a>, _: C) { //! println!("{:?}", &*bundle.a); //! println!("{:?}", &*bundle.b); //! } //! } //! //! //! fn main() { //! let mut resources = Resources::new(); //! let mut dispatcher = DispatcherBuilder::new() //! .add(EmptySystem, "empty", &[]) //! .build(); //! resources.add(ResA, ()); //! resources.add(ResB, ()); //! //! dispatcher.dispatch(&mut resources, ()); //! } //! ``` //! #![deny(unused_must_use)] #![warn(missing_docs)] extern crate fnv; #[macro_use] extern crate mopa; #[cfg(feature = "parallel")] extern crate pulse; extern crate rayon; mod bitset; mod cell; mod dispatch; mod res; mod system; #[cfg(feature = "parallel")] pub use dispatch::AsyncDispatcher; pub use dispatch::{Dispatcher, DispatcherBuilder, run_now}; pub use res::{Fetch, FetchId, FetchIdMut, FetchMut, Resource, ResourceId, Resources}; pub use system::{System, SystemData};