Struct InterceptLayer 

pub struct InterceptLayer<In, Out> { /* private fields */ }

Available on crate features intercept only.

Builder for creating Intercept middleware.

Provides a fluent API for configuring input and output observers and modifiers. Create with Intercept::layer().

Examples

let stack = (
    Intercept::layer(), // Create a new interception layer
    Execute::new(|input: String| async move { input }),
);

let service = stack.into_service();
let response = service.execute("input".to_string()).await;

Implementations

impl<In, Out> InterceptLayer<In, Out>

pub fn on_input<F>(self, f: F) -> Self

where F: Fn(&In) + Send + Sync + 'static,

Adds an observer for incoming inputs.

Called before input modifications. Multiple observers execute in registration order.

Examples

let stack = (
    Intercept::layer()
        .on_input(|input| println!("processing: {input}"))
        .on_input(|input| println!("another: {input}")),
    Execute::new(|input: String| async move { input }),
);

let service = stack.into_service();
let response = service.execute("input".to_string()).await;

pub fn on_output<F>(self, f: F) -> Self

where F: Fn(&Out) + Send + Sync + 'static,

Adds an observer for outgoing outputs.

Called before output modifications. Multiple observers execute in registration order.

Examples

let stack = (
    Intercept::layer()
        .on_output(|output| println!("response: {output}"))
        .on_output(|output| println!("another response: {output}")),
    Execute::new(|input: String| async move { input }),
);

let service = stack.into_service();
let response = service.execute("input".to_string()).await;

pub fn modify_input<F>(self, f: F) -> Self

where F: Fn(In) -> In + Send + Sync + 'static,

Adds a transformation for incoming inputs.

Transforms inputs before service execution. Multiple modifications apply in registration order, each receiving the previous output.

Examples

let stack = (
    Intercept::layer()
        .modify_input(|input: String| input.trim().to_string())
        .modify_input(|input| input.to_lowercase()),
    Execute::new(|input: String| async move { input }),
);

let service = stack.into_service();
let response = service.execute("input".to_string()).await;

pub fn modify_output<F>(self, f: F) -> Self

where F: Fn(Out) -> Out + Send + Sync + 'static,

Adds a transformation for outgoing outputs.

Transforms outputs after service execution. Multiple modifications apply in registration order, each receiving the previous output.

Examples

let stack = (
    Intercept::layer()
        .modify_output(|output: String| output.trim().to_string())
        .modify_output(|output| format!("Result: {}", output)),
    Execute::new(|input: String| async move { input }),
);

let service = stack.into_service();
let response = service.execute("input".to_string()).await;

Trait Implementations

impl<In: Clone, Out: Clone> Clone for InterceptLayer<In, Out>

fn clone(&self) -> InterceptLayer<In, Out>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<In, Out> Debug for InterceptLayer<In, Out>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<In, Out, S> Layer<S> for InterceptLayer<In, Out>

type Service = Intercept<In, Out, S>

The wrapped service

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.