Struct axum_valid::validator::ValidEx

pub struct ValidEx<E, A>(pub E, pub A);

ValidEx data extractor

ValidEx can be incorporated with extractors from various modules, similar to Valid. Two differences exist between ValidEx and Valid:

• The inner data type in ValidEx implements ValidateArgs instead of Validate.
• ValidEx includes a second field that represents arguments used during validation of the first field.

The implementation of ValidateArgs is often automatically handled by validator’s derive macros (for more details, please refer to the validator’s documentation).

Although current module documentation predominantly showcases Valid examples, the usage of ValidEx is analogous.

Tuple Fields

0: E

1: A

Implementations

impl<E, A> ValidEx<E, A>

pub fn into_inner(self) -> E

Consumes the ValidEx and returns the validated data within.

This returns the E type which represents the data that has been successfully validated.

pub fn arguments<'a>( &'a self ) -> <<A as Arguments<'a>>::T as ValidateArgs<'a>>::Args

where A: Arguments<'a>,

Returns a reference to the validation arguments.

This provides access to the A type which contains the arguments used to validate the data. These arguments were passed to the validation function.

Trait Implementations

impl<E: Clone, A: Clone> Clone for ValidEx<E, A>

fn clone(&self) -> ValidEx<E, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug, A: Debug> Debug for ValidEx<E, A>

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

Formats the value using the given formatter.

impl<E: Default, A: Default> Default for ValidEx<E, A>

fn default() -> ValidEx<E, A>

Returns the “default value” for a type.

impl<E, A> Deref for ValidEx<E, A>

type Target = E

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<E, A> DerefMut for ValidEx<E, A>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Display, A> Display for ValidEx<T, A>

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

Formats the value using the given formatter.

impl<State, Extractor, Args> FromRequest<State> for ValidEx<Extractor, Args>

where State: Send + Sync, Args: Send + Sync + FromRef<State> + for<'a> Arguments<'a, T = <Extractor as HasValidateArgs<'a>>::ValidateArgs>, Extractor: for<'v> HasValidateArgs<'v> + FromRequest<State>,

type Rejection = ValidationRejection<ValidationErrors, <Extractor as FromRequest<State>>::Rejection>

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request<'life0, 'async_trait>( req: Request, state: &'life0 State ) -> Pin<Box<dyn Future<Output = Result<Self, Self::Rejection>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Perform the extraction.

impl<State, Extractor, Args> FromRequestParts<State> for ValidEx<Extractor, Args>

where State: Send + Sync, Args: Send + Sync + FromRef<State> + for<'a> Arguments<'a, T = <Extractor as HasValidateArgs<'a>>::ValidateArgs>, Extractor: for<'v> HasValidateArgs<'v> + FromRequestParts<State>,

type Rejection = ValidationRejection<ValidationErrors, <Extractor as FromRequestParts<State>>::Rejection>

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request_parts<'life0, 'life1, 'async_trait>( parts: &'life0 mut Parts, state: &'life1 State ) -> Pin<Box<dyn Future<Output = Result<Self, Self::Rejection>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Perform the extraction.

impl<T, A> OperationInput for ValidEx<T, A>

where T: OperationInput,

fn operation_input(ctx: &mut GenContext, operation: &mut Operation)

Modify the operation.

fn inferred_early_responses( ctx: &mut GenContext, operation: &mut Operation ) -> Vec<(Option<u16>, Response)>

Inferred early responses are used to document early returns for extractors, guards inside handlers. For example these could represent JSON parsing errors, authentication failures.

impl<T: TypedPath + Display, A> TypedPath for ValidEx<T, A>

const PATH: &'static str = T::PATH

The path with optional captures such as /users/:id.

fn to_uri(&self) -> Uri

Convert the path into a Uri.

fn with_query_params<T>(self, params: T) -> WithQueryParams<Self, T>

where T: Serialize, Self: Sized,

Add query parameters to a path.

impl<E: Copy, A: Copy> Copy for ValidEx<E, A>