Struct Validate 

pub struct Validate<Inner = PipeHandle, Op = ValidateOp> {
    pub inner: Inner,
    /* private fields */
}

Predicate/schema-gated admission middleware. Generic over the inner pipe AND the check op. The std default op is the HTTP ValidateOp (proxima-config’s schema module); under no_std+alloc that type is absent, so the default falls back to () and callers name their own Checkable op explicitly.

Fields

inner: Inner

Implementations

impl<Inner, Op> Validate<Inner, Op>

pub fn new(inner: Inner, op: Op) -> Self

impl Validate<PipeHandle, ValidateOp>

pub fn from_schema( inner: PipeHandle, schema: Schema, schemas: Arc<SchemaRegistry>, ) -> Self

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

Trait Implementations

impl<Op> Pipe for Validate<ThreadLocalPipeHandle, Op>

where Request<Bytes>: Checkable<Op, Out = Response<Bytes>>, Op: Clone + Send + Sync + '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, Op> SendPipe for Validate<Inner, Op>

where Inner: SendPipe + Clone, Inner::In: Checkable<Op, Out = Inner::Out> + Send, Inner::Out: Send, Inner::Err: From<ProximaError> + Send, Op: Clone + Send + Sync + 'static,

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.