Trait ParallelizationContractCore

pub trait ParallelizationContractCore<T, D> {
    type Pusher: Push<BundleCore<T, D>> + 'static;
    type Puller: Pull<BundleCore<T, D>> + 'static;

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

A ParallelizationContractCore allocates paired Push and Pull implementors.

Required Associated Types

type Pusher: Push<BundleCore<T, D>> + 'static

Type implementing Push produced by this pact.

type Puller: Pull<BundleCore<T, D>> + 'static

Type implementing Pull produced by this pact.

Required Methods

fn connect<A: AsWorker>( self, allocator: &mut A, identifier: usize, address: &[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, D: Container> ParallelizationContractCore<T, D> for Pipeline

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

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

impl<T: Timestamp, C, D: Data + Clone, F: FnMut(&D) -> u64 + 'static> ParallelizationContractCore<T, C> for ExchangeCore<C, D, F>

where C: Data + Container + PushPartitioned<Item = D>,

type Pusher = Exchange<T, C, D, LogPusher<T, C, Box<dyn Push<Message<Message<T, C>>>>>, F>

type Puller = LogPuller<T, C, Box<dyn Pull<Message<Message<T, C>>>>>