Struct Violation 

pub struct Violation {
    pub field: Option<FieldPath>,
    pub rule: Option<FieldPath>,
    pub rule_id: Option<String>,
    pub message: Option<String>,
    pub for_key: Option<bool>,
}

Available on crate feature protovalidate only.

Violation represents a single instance where a validation rule, expressed as a Rule, was not met. It provides information about the field that caused the violation, the specific rule that wasn’t fulfilled, and a human-readable error message.

For example, consider the following message:

message User {
     int32 age = 1 [(buf.validate.field).cel = {
         id: "user.age",
         expression: "this < 18 ? 'User must be at least 18 years old' : ''",
     }];
}

It could produce the following violation:

{
   "ruleId": "user.age",
   "message": "User must be at least 18 years old",
   "field": {
     "elements": [
       {
         "fieldNumber": 1,
         "fieldName": "age",
         "fieldType": "TYPE_INT32"
       }
     ]
   },
   "rule": {
     "elements": [
       {
         "fieldNumber": 23,
         "fieldName": "cel",
         "fieldType": "TYPE_MESSAGE",
         "index": "0"
       }
     ]
   }
}

Fields

field: Option<FieldPath>

field is a machine-readable path to the field that failed validation. This could be a nested field, in which case the path will include all the parent fields leading to the actual field that caused the violation.

For example, consider the following message:

message Message {
   bool a = 1 \[(buf.validate.field).required = true\];
}

It could produce the following violation:

violation {
   field { element { field_number: 1, field_name: "a", field_type: 8 } }
   ...
}

rule: Option<FieldPath>

rule is a machine-readable path that points to the specific rule that failed validation. This will be a nested field starting from the FieldRules of the field that failed validation. For custom rules, this will provide the path of the rule, e.g. cel\[0\].

For example, consider the following message:

message Message {
   bool a = 1 \[(buf.validate.field).required = true\];
   bool b = 2 [(buf.validate.field).cel = {
     id: "custom_rule",
     expression: "!this ? 'b must be true': ''"
   }]
}

It could produce the following violations:

violation {
   rule { element { field_number: 25, field_name: "required", field_type: 8 } }
   ...
}
violation {
   rule { element { field_number: 23, field_name: "cel", field_type: 11, index: 0 } }
   ...
}

rule_id: Option<String>

rule_id is the unique identifier of the Rule that was not fulfilled. This is the same id that was specified in the Rule message, allowing easy tracing of which rule was violated.

message: Option<String>

message is a human-readable error message that describes the nature of the violation. This can be the default error message from the violated Rule, or it can be a custom message that gives more context about the violation.

for_key: Option<bool>

for_key indicates whether the violation was caused by a map key, rather than a value.

Implementations

impl Violation

pub fn last_field(&self) -> Option<&FieldPathElement>

Returns the last member in the elements list, if there is one.

pub fn parent_field(&self) -> Option<&FieldPathElement>

Returns the second last member in the elements list, if there is one.

pub fn get_field(&self, name: &str) -> Option<&FieldPathElement>

Searches for a field in the FieldPath list with a specific name.

pub fn field_path(&self) -> Option<Vec<String>>

If the FieldPath is present, it will return the list of the names for each path element.

pub fn rule_path(&self) -> Option<Vec<String>>

Returns the element names composing the violation’s rule, like [“string”, “max_len”].

pub fn field_path_str(&self) -> Option<String>

If there is a FieldPath, it returns the path elements’ names, joined by a dot (e.g. person.friends.0.address.street_name).

pub fn rule_path_str(&self) -> Option<String>

If a rule path is defined, it returns the rule path segments for this violation, joined by a dot (e.g. map.keys.string.min_len)

pub const fn has_fields(&self) -> bool

Checks whether this violation has a FieldPath or not. This may not be the case when a violation is triggered by a rule defined with (buf.validate.message).cel in a message

pub fn has_field_by_name(&self, name: &str) -> bool

Checks if the list of FieldPathElements contains a field with a particular name.

pub fn field_name(&self) -> Option<&str>

If a list of path elements is defined, it returns the name of the invalid field (the last field in the list of path elements)

impl Violation

pub fn rule_id(&self) -> &str

Returns the value of rule_id, or the default value if rule_id is unset.

pub fn message(&self) -> &str

Returns the value of message, or the default value if message is unset.

pub fn for_key(&self) -> bool

Returns the value of for_key, or the default value if for_key is unset.

Trait Implementations

impl Clone for Violation

fn clone(&self) -> Violation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Violation

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

Formats the value using the given formatter.

impl Default for Violation

fn default() -> Self

Returns the “default value” for a type.

impl Extend<Violation> for Violations

fn extend<T: IntoIterator<Item = Violation>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<Violation> for Status

fn from(value: Violation) -> Self

Converts to this type from the input type.

impl FromIterator<Violation> for Violations

fn from_iter<T: IntoIterator<Item = Violation>>(iter: T) -> Self

Creates a value from an iterator.

impl Hash for Violation

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 Message for Violation

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for Violation

fn eq(&self, other: &Violation) -> 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 Eq for Violation

impl StructuralPartialEq for Violation