Struct FieldRules

pub struct FieldRules {
    pub cel: Vec<Rule>,
    pub required: Option<bool>,
    pub ignore: Option<i32>,
    pub type: Option<Type>,
}

FieldRules encapsulates the rules for each type of field. Depending on the field, the correct set should be used to ensure proper validations.

Fields

cel: Vec<Rule>

cel is a repeated field used to represent a textual expression in the Common Expression Language (CEL) syntax. For more information, see our documentation.

message MyMessage {
   // The field `value` must be greater than 42.
   optional int32 value = 1 [(buf.validate.field).cel = {
     id: "my_message.value",
     message: "value must be greater than 42",
     expression: "this > 42",
   }];
}

required: Option<bool>

If required is true, the field must be set. A validation error is returned if the field is not set.

syntax="proto3";

message FieldsWithPresence {
   // Requires any string to be set, including the empty string.
   optional string link = 1 [
     (buf.validate.field).required = true
   ];
   // Requires true or false to be set.
   optional bool disabled = 2 [
     (buf.validate.field).required = true
   ];
   // Requires a message to be set, including the empty message.
   SomeMessage msg = 4 [
     (buf.validate.field).required = true
   ];
}

All fields in the example above track presence. By default, Protovalidate ignores rules on those fields if no value is set. required ensures that the fields are set and valid.

Fields that don’t track presence are always validated by Protovalidate, whether they are set or not. It is not necessary to add required:

syntax="proto3";

message FieldsWithoutPresence {
   // `string.email` always applies, even to an empty string.
   string link = 1 [
     (buf.validate.field).string.email = true
   ];
   // `repeated.min_items` always applies, even to an empty list.
   repeated string labels = 4 [
     (buf.validate.field).repeated.min_items = 1
   ];
}

To learn which fields track presence, see the Field Presence cheat sheet.

Note: While field rules can be applied to repeated items, map keys, and map values, the elements are always considered to be set. Consequently, specifying repeated.items.required is redundant.

ignore: Option<i32>

Ignore validation rules on the field if its value matches the specified criteria. See the Ignore enum for details.

message UpdateRequest {
   // The uri rule only applies if the field is not an empty string.
   string url = 1 [
     (buf.validate.field).ignore = IGNORE_IF_ZERO_VALUE,
     (buf.validate.field).string.uri = true
   ];
}

type: Option<Type>

Implementations

impl FieldRules

pub fn required(&self) -> bool

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

pub fn ignore(&self) -> Ignore

Returns the enum value of ignore, or the default if the field is unset or set to an invalid enum value.

pub fn set_ignore(&mut self, value: Ignore)

Sets ignore to the provided enum value.

Trait Implementations

impl Clone for FieldRules

fn clone(&self) -> FieldRules

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FieldRules

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

Formats the value using the given formatter.

impl Default for FieldRules

fn default() -> Self

Returns the “default value” for a type.

impl Message for FieldRules

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 FieldRules

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