Struct Whole 

pub struct Whole<Op: Operation> { /* private fields */ }

The fold of an operation whose reply is one whole answer: it has no events, and the provider’s end is the response. The stamp writes what the driver learned about the reply onto it.

use std::convert::Infallible;
use rig_core::operation::Whole;
use rig_core::wire::{Call, Free, Operation};

struct Echo;

impl Operation for Echo {
    type Request = String;
    type Event = Infallible;
    type End = String;
    type Response = String;
    type Fold = Whole<Self>;
    type Emit = Free;

    fn fold(_request: &String, _call: &mut Call<'_>) -> Whole<Self> {
        Whole::<Self>::stamping(|response, reply| response.push_str(&reply.provider))
    }
}

Implementations

impl<Op: Operation> Whole<Op>

pub fn new() -> Self

A fold that stamps nothing.

pub fn stamping(stamp: fn(&mut Op::Response, &Reply)) -> Self

A fold that writes what the driver learned about the reply onto the response with stamp.

Trait Implementations

impl<Op: Operation> Default for Whole<Op>

fn default() -> Self

Returns the “default value” for a type.

impl<Op> Fold<Op> for Whole<Op>

where Op: Operation<Event = Infallible>, Op::End: Into<Op::Response>,

fn absorb(&mut self, event: &Infallible) -> Result<(), ProviderError>

Absorb one event the consumer is about to see. An error fails the reply.

fn finish( self, end: Op::End, reply: Reply, ) -> Result<Op::Response, ProviderError>

The response, from the events absorbed, the provider’s end and what the driver learned about the reply.