Struct BytesRules 

pub struct BytesRules {
    pub const: Option<Bytes>,
    pub len: Option<u64>,
    pub min_len: Option<u64>,
    pub max_len: Option<u64>,
    pub pattern: Option<String>,
    pub prefix: Option<Bytes>,
    pub suffix: Option<Bytes>,
    pub contains: Option<Bytes>,
    pub in: Vec<Bytes>,
    pub not_in: Vec<Bytes>,
    pub example: Vec<Bytes>,
    pub well_known: Option<WellKnown>,
}

Available on crate feature protovalidate only.

BytesRules describe the rules applied to bytes values. These rules may also be applied to the google.protobuf.BytesValue Well-Known-Type.

Fields

const: Option<Bytes>

const requires the field value to exactly match the specified bytes value. If the field value doesn’t match, an error message is generated.

message MyBytes {
   // value must be "\x01\x02\x03\x04"
   bytes value = 1 \[(buf.validate.field).bytes.const = "\x01\x02\x03\x04"\];
}

len: Option<u64>

len requires the field value to have the specified length in bytes. If the field value doesn’t match, an error message is generated.

message MyBytes {
   // value length must be 4 bytes.
   optional bytes value = 1 \[(buf.validate.field).bytes.len = 4\];
}

min_len: Option<u64>

min_len requires the field value to have at least the specified minimum length in bytes. If the field value doesn’t meet the requirement, an error message is generated.

message MyBytes {
   // value length must be at least 2 bytes.
   optional bytes value = 1 \[(buf.validate.field).bytes.min_len = 2\];
}

max_len: Option<u64>

max_len requires the field value to have at most the specified maximum length in bytes. If the field value exceeds the requirement, an error message is generated.

message MyBytes {
   // value must be at most 6 bytes.
   optional bytes value = 1 \[(buf.validate.field).bytes.max_len = 6\];
}

pattern: Option<String>

pattern requires the field value to match the specified regular expression (RE2 syntax). The value of the field must be valid UTF-8 or validation will fail with a runtime error. If the field value doesn’t match the pattern, an error message is generated.

message MyBytes {
   // value must match regex pattern "^\[a-zA-Z0-9\]+$".
   optional bytes value = 1 \[(buf.validate.field).bytes.pattern = "^[a-zA-Z0-9\]+$"];
}

prefix: Option<Bytes>

prefix requires the field value to have the specified bytes at the beginning of the string. If the field value doesn’t meet the requirement, an error message is generated.

message MyBytes {
   // value does not have prefix \x01\x02
   optional bytes value = 1 \[(buf.validate.field).bytes.prefix = "\x01\x02"\];
}

suffix: Option<Bytes>

suffix requires the field value to have the specified bytes at the end of the string. If the field value doesn’t meet the requirement, an error message is generated.

message MyBytes {
   // value does not have suffix \x03\x04
   optional bytes value = 1 \[(buf.validate.field).bytes.suffix = "\x03\x04"\];
}

contains: Option<Bytes>

contains requires the field value to have the specified bytes anywhere in the string. If the field value doesn’t meet the requirement, an error message is generated.

message MyBytes {
   // value does not contain \x02\x03
   optional bytes value = 1 \[(buf.validate.field).bytes.contains = "\x02\x03"\];
}

in: Vec<Bytes>

in requires the field value to be equal to one of the specified values. If the field value doesn’t match any of the specified values, an error message is generated.

message MyBytes {
   // value must in \["\x01\x02", "\x02\x03", "\x03\x04"\]
   optional bytes value = 1 \[(buf.validate.field).bytes.in = {"\x01\x02", "\x02\x03", "\x03\x04"}\];
}

not_in: Vec<Bytes>

not_in requires the field value to be not equal to any of the specified values. If the field value matches any of the specified values, an error message is generated.

message MyBytes {
   // value must not in \["\x01\x02", "\x02\x03", "\x03\x04"\]
   optional bytes value = 1 \[(buf.validate.field).bytes.not_in = {"\x01\x02", "\x02\x03", "\x03\x04"}\];
}

example: Vec<Bytes>

example specifies values that the field may have. These values SHOULD conform to other rules. example values will not impact validation but may be used as helpful guidance on how to populate the given field.

message MyBytes {
   bytes value = 1 [
     (buf.validate.field).bytes.example = "\x01\x02",
     (buf.validate.field).bytes.example = "\x02\x03"
   ];
}

well_known: Option<WellKnown>

WellKnown rules provide advanced rules against common byte patterns

Implementations

impl BytesRules

pub fn const(&self) -> &[u8]

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

pub fn min_len(&self) -> u64

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

pub fn max_len(&self) -> u64

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

pub fn pattern(&self) -> &str

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

pub fn prefix(&self) -> &[u8]

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

pub fn suffix(&self) -> &[u8]

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

pub fn contains(&self) -> &[u8]

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

pub fn len(&self) -> u64

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

Trait Implementations

impl Clone for BytesRules

fn clone(&self) -> BytesRules

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BytesRules

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

Formats the value using the given formatter.

impl Default for BytesRules

fn default() -> Self

Returns the “default value” for a type.

impl Hash for BytesRules

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 BytesRules

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 BytesRules

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

impl StructuralPartialEq for BytesRules