Struct Delay 

pub struct Delay<Inner = PipeHandle, Clk = TimeClock> {
    pub inner: Inner,
    /* private fields */
}

Fields

inner: Inner

Implementations

impl<Inner> Delay<Inner, TimeClock>

pub fn new(inner: Inner, dist: Dist) -> Self

impl<Inner, Clk> Delay<Inner, Clk>

pub fn with_clock(inner: Inner, dist: Dist, clock: Clk) -> Self

Materialise with an explicit Clock — the seam a deterministic test or example injects a fake clock through; production code goes via Delay::new, which defaults Clk to TimeClock.

pub fn with_when(self, when: When) -> Self

pub fn dist(&self) -> Dist

pub fn when(&self) -> Option<When>

impl Delay<PipeHandle, TimeClock>

pub fn to_config(&self) -> DelayConfig

pub fn from_spec(inner: PipeHandle, value: &Value) -> Result<Self, ProximaError>

Trait Implementations

impl<Clk> Pipe for Delay<ThreadLocalPipeHandle, Clk>

where ThreadLocalPipeHandle: Pipe<In = Request<Bytes>, Out = Response<Bytes>, Err = ProximaError>, Clk: Clock + Clone + 'static,

type In = Request<Bytes>

Input the pipe consumes.

type Out = Response<Bytes>

Output the pipe produces.

type Err = ProximaError

Error the pipe can fail with. Debug + 'static; Send is added only on the cross-core SendPipe form.

fn call( &self, input: Request<Bytes>, ) -> impl Future<Output = Result<Response<Bytes>, ProximaError>>

Apply the pipe. The returned future is NOT required to be Send.

impl<Inner, Clk> SendPipe for Delay<Inner, Clk>

where Inner: SendPipe + Clone + Send + Sync + 'static, Inner::In: Send, Clk: Clock + Clone + Send + Sync + 'static, Clk::Delay: Send,

type In = <Inner as SendPipe>::In

Input the pipe consumes.

type Out = <Inner as SendPipe>::Out

Output the pipe produces.

type Err = <Inner as SendPipe>::Err

Error the pipe can fail with — Send here so it can cross cores.

fn call( &self, input: Inner::In, ) -> impl Future<Output = Result<Inner::Out, Inner::Err>> + Send

Apply the pipe. The returned future IS Send.