Trait Plugin 

pub trait Plugin<Ser, Op, T> {
    type Output;

    // Required method
    fn apply(&self, input: T) -> Self::Output;
}

A mapping from one Service to another. This should be viewed as a Layer parameterized by the protocol and operation.

The generics Ser and Op allow the behavior to be parameterized by the Smithy service and operation it’s applied to.

See module documentation for more information.

Required Associated Types

type Output

The type of the new Service.

Required Methods

fn apply(&self, input: T) -> Self::Output

Maps a Service to another.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<Ser, Op, T, Pl> Plugin<Ser, Op, T> for &Pl

where Pl: Plugin<Ser, Op, T>,

type Output = <Pl as Plugin<Ser, Op, T>>::Output

fn apply(&self, inner: T) -> Self::Output

Implementors

impl<Ser, Op, S, L> Plugin<Ser, Op, S> for LayerPlugin<L>

where L: Layer<S>,

type Output = <L as Layer<S>>::Service

impl<Ser, Op, S> Plugin<Ser, Op, S> for IdentityPlugin

type Output = S

impl<Ser, Op, T, Extractors> Plugin<Ser, Op, T> for UpgradePlugin<Extractors>

where Ser: ServiceShape, Op: OperationShape,

type Output = Upgrade<<Ser as ServiceShape>::Protocol, (<Op as OperationShape>::Input, Extractors), T>

impl<Ser, Op, T, Inner, F> Plugin<Ser, Op, T> for FilterByOperation<Inner, F>

where Ser: ContainsOperation<Op>, F: Fn(Ser::Operations) -> bool, Inner: Plugin<Ser, Op, T>, Op: OperationShape,

type Output = Either<<Inner as Plugin<Ser, Op, T>>::Output, T>

impl<Ser, Op, T, Inner, Outer> Plugin<Ser, Op, T> for PluginStack<Inner, Outer>

where Inner: Plugin<Ser, Op, T>, Outer: Plugin<Ser, Op, Inner::Output>,

type Output = <Outer as Plugin<Ser, Op, <Inner as Plugin<Ser, Op, T>>::Output>>::Output

impl<Ser, Op, T, InnerPlugin> Plugin<Ser, Op, T> for HttpPlugins<InnerPlugin>

where InnerPlugin: Plugin<Ser, Op, T>,

type Output = <InnerPlugin as Plugin<Ser, Op, T>>::Output

impl<Ser, Op, T, InnerPlugin> Plugin<Ser, Op, T> for ModelPlugins<InnerPlugin>

where InnerPlugin: Plugin<Ser, Op, T>,

type Output = <InnerPlugin as Plugin<Ser, Op, T>>::Output

impl<Ser, Op, T, Le, Ri> Plugin<Ser, Op, T> for Either<Le, Ri>

where Le: Plugin<Ser, Op, T>, Ri: Plugin<Ser, Op, T>,

type Output = Either<<Le as Plugin<Ser, Op, T>>::Output, <Ri as Plugin<Ser, Op, T>>::Output>

impl<Ser, Op, T, NewService, F> Plugin<Ser, Op, T> for OperationFn<F>

where Ser: ContainsOperation<Op>, F: Fn(Ser::Operations, T) -> NewService,

type Output = NewService

impl<Ser, Op, T, Scope, Pl> Plugin<Ser, Op, T> for Scoped<Scope, Pl>

where Scope: Membership<Op>, Scope::Contains: ConditionalApply<Ser, Op, Pl, T>,

type Output = <<Scope as Membership<Op>>::Contains as ConditionalApply<Ser, Op, Pl, T>>::Service

impl<Ser, Op, T> Plugin<Ser, Op, T> for InstrumentPlugin

where Op: OperationShape + Sensitivity,

type Output = InstrumentOperation<T, <Op as Sensitivity>::RequestFmt, <Op as Sensitivity>::ResponseFmt>

impl<Ser, Op, T> Plugin<Ser, Op, T> for OperationExtensionPlugin

where Op: OperationShape,

type Output = OperationExtensionService<T>