[][src]Struct shred::ParSeq

pub struct ParSeq<P, T> { /* fields omitted */ }

A dispatcher intended to be used with Par and Seq structures.

This is more flexible and performant than Dispatcher, however, you have to check conflicts yourself. That means you cannot run two systems in parallel which write to the same resource; if you'd do that, one of the systems will panic while trying to fetch the SystemData.

Thread-local systems

This dispatcher also allows more freedom for thread-local systems; you can execute wherever you want, just not in parallel with other systems (putting one inside par! will give you a compile-time error saying the Send requirement is unmet).


#[macro_use(par, seq)]
extern crate shred;

let x = 5u8;

let mut dispatcher = ParSeq::new(
        par![SysA, SysWithLifetime(&x), seq![SysC, SysD,],],
        SysLocal(&x as *const u8),

dispatcher.dispatch(&mut world);


impl<P, T> ParSeq<P, T> where
    P: Borrow<ThreadPool>,
    T: for<'a> RunWithPool<'a>, 

pub fn new(run: T, pool: P) -> Self[src]

Creates a new ParSeq dispatcher. run is usually created by using the par! / seq! macros.

pub fn setup(&mut self, world: &mut World)[src]

Sets up world for dispatching. This will add default values for required resources by calling System::setup.

pub fn dispatch(&mut self, world: &World)[src]

Dispatches the systems using world. This doesn't call any virtual functions.

Please note that this method assumes that no resource is currently borrowed. If that's the case, it panics.

Trait Implementations

impl<'a, P, T> RunNow<'a> for ParSeq<P, T> where
    P: Borrow<ThreadPool>,
    T: for<'b> RunWithPool<'b>, 

Auto Trait Implementations

impl<P, T> RefUnwindSafe for ParSeq<P, T> where
    P: RefUnwindSafe,
    T: RefUnwindSafe

impl<P, T> Send for ParSeq<P, T> where
    P: Send,
    T: Send

impl<P, T> Sync for ParSeq<P, T> where
    P: Sync,
    T: Sync

impl<P, T> Unpin for ParSeq<P, T> where
    P: Unpin,
    T: Unpin

impl<P, T> UnwindSafe for ParSeq<P, T> where
    P: UnwindSafe,
    T: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Any for T where
    T: Any

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.