Struct interledger_service::WrappedService

pub struct WrappedService<F, I, A> { /* fields omitted */ }

A service that wraps another one with a function that will be called on every request.

This enables wrapping services without the boilerplate of defining a new struct and implementing IncomingService and/or OutgoingService every time.

Methods

impl<F, IO, A, R> WrappedService<F, IO, A> where
    F: Fn(IncomingRequest<A>, IO) -> R,
    IO: IncomingService<A> + Clone,
    A: Account,
    R: Future<Item = Fulfill, Error = Reject> + Send + 'static, 

pub fn wrap_incoming(inner: IO, f: F) -> Self

Wrap the given service such that the provided function will be called to handle each request. That function can return immediately, modify the request before passing it on, and/or handle the result of calling the inner service.

impl<F, IO, A, R> WrappedService<F, IO, A> where
    F: Fn(OutgoingRequest<A>, IO) -> R,
    IO: OutgoingService<A> + Clone,
    A: Account,
    R: Future<Item = Fulfill, Error = Reject> + Send + 'static, 

pub fn wrap_outgoing(inner: IO, f: F) -> Self

Wrap the given service such that the provided function will be called to handle each request. That function can return immediately, modify the request before passing it on, and/or handle the result of calling the inner service.

Trait Implementations

impl<F, IO, A, R> IncomingService<A> for WrappedService<F, IO, A> where
    F: Fn(IncomingRequest<A>, IO) -> R,
    IO: IncomingService<A> + Clone,
    A: Account,
    R: Future<Item = Fulfill, Error = Reject> + Send + 'static, 

type Future = R

fn handle_request(&mut self, request: IncomingRequest<A>) -> R

fn wrap<F, R>(self, f: F) -> WrappedService<F, Self, A> where
    F: Fn(IncomingRequest<A>, Self) -> R,
    R: Future<Item = Fulfill, Error = Reject> + Send + 'static,
    Self: Clone + Sized, 

Wrap the given service such that the provided function will be called to handle each request. That function can return immediately, modify the request before passing it on, and/or handle the result of calling the inner service.

impl<F, IO, A, R> OutgoingService<A> for WrappedService<F, IO, A> where
    F: Fn(OutgoingRequest<A>, IO) -> R,
    IO: OutgoingService<A> + Clone,
    A: Account,
    R: Future<Item = Fulfill, Error = Reject> + Send + 'static, 

type Future = R

fn send_request(&mut self, request: OutgoingRequest<A>) -> R

fn wrap<F, R>(self, f: F) -> WrappedService<F, Self, A> where
    F: Fn(OutgoingRequest<A>, Self) -> R,
    R: Future<Item = Fulfill, Error = Reject> + Send + 'static,
    Self: Clone + Sized, 

Wrap the given service such that the provided function will be called to handle each request. That function can return immediately, modify the request before passing it on, and/or handle the result of calling the inner service.

impl<F: Clone, I: Clone, A: Clone> Clone for WrappedService<F, I, A>

fn clone(&self) -> WrappedService<F, I, A>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.