Trait ParallelizationContract

pub trait ParallelizationContract<T, C> {
    type Pusher: Push<Message<T, C>> + 'static;
    type Puller: Pull<Message<T, C>> + 'static;

    // Required method
    fn connect<A: AsWorker>(
        self,
        allocator: &mut A,
        identifier: usize,
        address: Rc<[usize]>,
        logging: Option<Logger>,
    ) -> (Self::Pusher, Self::Puller);
}

A ParallelizationContract allocates paired Push and Pull implementors.

Required Associated Types

type Pusher: Push<Message<T, C>> + 'static

Type implementing Push produced by this pact.

type Puller: Pull<Message<T, C>> + 'static

Type implementing Pull produced by this pact.

Required Methods

fn connect<A: AsWorker>( self, allocator: &mut A, identifier: usize, address: Rc<[usize]>, logging: Option<Logger>, ) -> (Self::Pusher, Self::Puller)

Allocates a matched pair of push and pull endpoints implementing the pact.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T: 'static, C: Container + 'static> ParallelizationContract<T, C> for Pipeline

type Pusher = LogPusher<T, C, Pusher<Message<T, C>, Pusher<Message<T, C>>>>

type Puller = LogPuller<T, C, Puller<Message<T, C>, Puller<Message<T, C>>>>

impl<T: Timestamp, CB, H> ParallelizationContract<T, <CB as ContainerBuilder>::Container> for ExchangeCore<CB, H>

where CB: ContainerBuilder + for<'a> PushInto<<CB::Container as Container>::Item<'a>>, CB::Container: Data + Send + ContainerBytes, for<'a> H: FnMut(&<CB::Container as Container>::Item<'a>) -> u64 + 'static,

type Pusher = Exchange<T, CB, LogPusher<T, <CB as ContainerBuilder>::Container, Box<dyn Push<Message<T, <CB as ContainerBuilder>::Container>>>>, H>

type Puller = LogPuller<T, <CB as ContainerBuilder>::Container, Box<dyn Pull<Message<T, <CB as ContainerBuilder>::Container>>>>