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>,
}

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.

{
   "fieldPath": "bar",
   "ruleId": "foo.bar",
   "message": "bar must be greater than 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 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 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.

const 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 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 StructuralPartialEq for Violation