Struct MapValidatorBuilder 

pub struct MapValidatorBuilder<K, V, S: State = Empty>
where
    K: ProtoValidation,
    V: ProtoValidation,
{ /* private fields */ }

Builder for MapValidator.

Implementations

impl<S: State, K, V> MapValidatorBuilder<K, V, S>

where K: ProtoValidation, V: ProtoValidation,

pub fn build(self) -> MapValidator<K, V>

Builds the validator.

If the values validator is unset, but the target has HAS_DEFAULT_VALIDATOR from ProtoValidation set to true, its default validator will be assigned.

pub fn with_error_messages( self, error_messages: impl IntoIterator<Item = (MapViolation, impl Into<FixedStr>)>, ) -> MapValidatorBuilder<K, V, SetErrorMessages<S>>

where S::ErrorMessages: IsUnset,

Adds a map with custom error messages to the underlying validator.

If a violation has no custom error message attached to it, it uses the default error message.

NOTE: The custom errors for items and keys must be handled in their respective validators.

pub fn cel(self, program: CelProgram) -> Self

Adds a CelProgram to this validator.

The program will be applied to the map as a whole.

To apply a program to the individual keys/values, use their respective validators.

pub fn min_pairs(self, num: usize) -> MapValidatorBuilder<K, V, SetMinPairs<S>>

where S::MinPairs: IsUnset,

Specifies the minimum amount of key-value pairs that this field should have in order to be valid.

pub fn max_pairs(self, num: usize) -> MapValidatorBuilder<K, V, SetMaxPairs<S>>

where S::MaxPairs: IsUnset,

Specifies the maximum amount of key-value pairs that this field should have in order to be valid.

pub fn ignore_if_zero_value(self) -> MapValidatorBuilder<K, V, SetIgnore<S>>

where S::Ignore: IsUnset,

Specifies that this validator’s rules will be ignored if the map is empty.

pub fn ignore_always(self) -> MapValidatorBuilder<K, V, SetIgnore<S>>

where S::Ignore: IsUnset,

Specifies that this validator should always be ignored.

pub fn keys<F, FinalBuilder>( self, config_fn: F, ) -> MapValidatorBuilder<K, V, SetKeys<S>>

where S::Keys: IsUnset, FinalBuilder: ValidatorBuilderFor<K, Validator = K::Validator>, F: FnOnce(K::ValidatorBuilder) -> FinalBuilder,

Sets the rules to apply to each key of this map.

It receives a closure that that receives the key type’s default validator builder as an argument.

Example

use protify::*;

let validator = MapValidator::<String, String>::builder().keys(|k| k.min_len(5)).build();

assert_eq!(validator.keys.unwrap(), StringValidator::builder().min_len(5).build());

pub fn values<F, FinalBuilder>( self, config_fn: F, ) -> MapValidatorBuilder<K, V, SetValues<S>>

where V: ProtoValidation, FinalBuilder: ValidatorBuilderFor<V, Validator = V::Validator>, F: FnOnce(V::ValidatorBuilder) -> FinalBuilder,

Sets the rules to apply to each value of this map.

It receives a closure that that receives the value type’s default validator builder as an argument.

Example

use protify::*;

let validator = MapValidator::<String, String>::builder().values(|v| v.min_len(5)).build();

assert_eq!(validator.values.unwrap(), StringValidator::builder().min_len(5).build());

Trait Implementations

impl<K, V, S: Clone + State> Clone for MapValidatorBuilder<K, V, S>

where K: ProtoValidation + Clone, V: ProtoValidation + Clone, K::Validator: Clone, V::Validator: Clone,

fn clone(&self) -> MapValidatorBuilder<K, V, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, S: Debug + State> Debug for MapValidatorBuilder<K, V, S>

where K: ProtoValidation + Debug, V: ProtoValidation + Debug, K::Validator: Debug, V::Validator: Debug,

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

Formats the value using the given formatter.

impl<K, V, S: State> Default for MapValidatorBuilder<K, V, S>

where K: ProtoValidation, V: ProtoValidation,

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, S: State> From<MapValidatorBuilder<K, V, S>> for ProtoOption

where K: ProtoValidation, V: ProtoValidation,

fn from(value: MapValidatorBuilder<K, V, S>) -> Self

Converts to this type from the input type.

impl<K, V, S: Hash + State> Hash for MapValidatorBuilder<K, V, S>

where K: ProtoValidation + Hash, V: ProtoValidation + Hash, K::Validator: Hash, V::Validator: Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<K, V, S: PartialEq + State> PartialEq for MapValidatorBuilder<K, V, S>

where K: ProtoValidation + PartialEq, V: ProtoValidation + PartialEq, K::Validator: PartialEq, V::Validator: PartialEq,

fn eq(&self, other: &MapValidatorBuilder<K, V, S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K, V, M, S> ValidatorBuilderFor<M> for MapValidatorBuilder<K, V, S>

where S: State, K: ProtoValidation + Send + Sync + AsProtoType, V: ProtoValidation + Send + Sync + AsProtoType, M: ProtoMap<K, V> + ToOwned, M::Target: Clone + Default, K::Stored: Sized + Clone + IntoCelKey + Into<Subscript>, V::Stored: Sized + Clone + TryIntoCel,

type Validator = MapValidator<K, V>

fn build_validator(self) -> Self::Validator

Builds the associated Validator.

impl<K, V, S: Eq + State> Eq for MapValidatorBuilder<K, V, S>

where K: ProtoValidation + Eq, V: ProtoValidation + Eq, K::Validator: Eq, V::Validator: Eq,

impl<K, V, S: State> StructuralPartialEq for MapValidatorBuilder<K, V, S>

where K: ProtoValidation, V: ProtoValidation,