Struct bazel_bep::types::blaze::SetValue

pub struct SetValue {
    pub flag_value: Vec<String>,
    pub behavior: Option<i32>,
}

Fields

flag_value: Vec<String>

Use this value for the specified flag, overriding any default or user-set value (unless behavior = APPEND for repeatable flags).

This field is repeated for repeatable flags. It is an error to set multiple values for a flag that is not actually a repeatable flag. This requires at least 1 value, if even the empty string.

If the flag allows multiple values, all of its values are replaced with the value or values from the policy (i.e., no diffing or merging is performed), unless behavior = APPEND (see below).

Note that some flags are tricky. For example, some flags look like boolean flags, but are actually Void expansion flags that expand into other flags. The Bazel flag parser will accept “–void_flag=false”, but because the flag is Void, the “=false” is ignored. It can get even trickier, like “–novoid_flag” which is also an expansion flag with the type Void whose name is explicitly “novoid_flag” and which expands into other flags that are the opposite of “–void_flag”. For expansion flags, it’s best to explicitly override the flags they expand into.

Other flags may be differently tricky: A flag could have a converter that converts some string to a list of values, but that flag may not itself have allowMultiple set to true.

An example is “–test_tag_filters”: this flag sets its converter to CommaSeparatedOptionListConverter, but does not set allowMultiple to true. So “–test_tag_filters=foo,bar” results in [“foo”, “bar”], however “–test_tag_filters=foo –test_tag_filters=bar” results in just [“bar”] since the 2nd value overrides the 1st.

Similarly, “–test_tag_filters=foo,bar –test_tag_filters=baz,qux” results in [“baz”, “qux”]. For flags like these, the policy should specify “foo,bar” instead of separately specifying “foo” and “bar” so that the converter is appropriately invoked.

Note that the opposite is not necessarily true: for a flag that specifies allowMultiple=true, “–flag=foo,bar” may fail to parse or result in an unexpected value.

behavior: Option<i32>

Defines how invocation policy should interact with user settings for the same flag.

Implementations

impl SetValue

pub fn behavior(&self) -> Behavior

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

pub fn set_behavior(&mut self, value: Behavior)

Sets behavior to the provided enum value.

Trait Implementations

impl Clone for SetValue

fn clone(&self) -> SetValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SetValue

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

Formats the value using the given formatter.

impl Default for SetValue

fn default() -> Self

Returns the “default value” for a type.

impl Message for SetValue

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<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, 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<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, 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<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes an instance of the message from a buffer.

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

where B: Buf, Self: Default,

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

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

where B: Buf, Self: Sized,

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

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

where B: Buf, Self: Sized,

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

impl PartialEq for SetValue

fn eq(&self, other: &SetValue) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for SetValue