Package com.google.devtools.build.lib.runtime.proto

Class InvocationPolicyOuterClass.SetValue.Builder

java.lang.Object
com.google.protobuf.AbstractMessageLite.Builder
com.google.protobuf.AbstractMessage.Builder<BuilderT>
com.google.protobuf.GeneratedMessage.Builder<InvocationPolicyOuterClass.SetValue.Builder>
com.google.devtools.build.lib.runtime.proto.InvocationPolicyOuterClass.SetValue.Builder
All Implemented Interfaces:
InvocationPolicyOuterClass.SetValueOrBuilder, com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, Cloneable
Enclosing class:
InvocationPolicyOuterClass.SetValue
public static final class InvocationPolicyOuterClass.SetValue.Builder extends com.google.protobuf.GeneratedMessage.Builder<InvocationPolicyOuterClass.SetValue.Builder> implements InvocationPolicyOuterClass.SetValueOrBuilder
Protobuf type blaze.invocation_policy.SetValue

  • Method Details

    • getDescriptor

      public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

    • internalGetFieldAccessorTable

      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
      Specified by:
      internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessage.Builder<InvocationPolicyOuterClass.SetValue.Builder>

    • clear

      public InvocationPolicyOuterClass.SetValue.Builder clear()
      Specified by:
      clear in interface com.google.protobuf.Message.Builder
      Specified by:
      clear in interface com.google.protobuf.MessageLite.Builder
      Overrides:
      clear in class com.google.protobuf.GeneratedMessage.Builder<InvocationPolicyOuterClass.SetValue.Builder>

    • getDescriptorForType

      public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()
      Specified by:
      getDescriptorForType in interface com.google.protobuf.Message.Builder
      Specified by:
      getDescriptorForType in interface com.google.protobuf.MessageOrBuilder
      Overrides:
      getDescriptorForType in class com.google.protobuf.GeneratedMessage.Builder<InvocationPolicyOuterClass.SetValue.Builder>

    • getDefaultInstanceForType

      public InvocationPolicyOuterClass.SetValue getDefaultInstanceForType()
      Specified by:
      getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder
      Specified by:
      getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder

    • build

      public InvocationPolicyOuterClass.SetValue build()
      Specified by:
      build in interface com.google.protobuf.Message.Builder
      Specified by:
      build in interface com.google.protobuf.MessageLite.Builder

    • buildPartial

      public InvocationPolicyOuterClass.SetValue buildPartial()
      Specified by:
      buildPartial in interface com.google.protobuf.Message.Builder
      Specified by:
      buildPartial in interface com.google.protobuf.MessageLite.Builder

    • mergeFrom

      public InvocationPolicyOuterClass.SetValue.Builder mergeFrom(com.google.protobuf.Message other)
      Specified by:
      mergeFrom in interface com.google.protobuf.Message.Builder
      Overrides:
      mergeFrom in class com.google.protobuf.AbstractMessage.Builder<InvocationPolicyOuterClass.SetValue.Builder>

    • mergeFrom

      public InvocationPolicyOuterClass.SetValue.Builder mergeFrom(InvocationPolicyOuterClass.SetValue other)

    • isInitialized

      public final boolean isInitialized()
      Specified by:
      isInitialized in interface com.google.protobuf.MessageLiteOrBuilder
      Overrides:
      isInitialized in class com.google.protobuf.GeneratedMessage.Builder<InvocationPolicyOuterClass.SetValue.Builder>

    • mergeFrom

      public InvocationPolicyOuterClass.SetValue.Builder mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws IOException
      Specified by:
      mergeFrom in interface com.google.protobuf.Message.Builder
      Specified by:
      mergeFrom in interface com.google.protobuf.MessageLite.Builder
      Overrides:
      mergeFrom in class com.google.protobuf.AbstractMessage.Builder<InvocationPolicyOuterClass.SetValue.Builder>
      Throws:
      IOException

    • getFlagValueList

      public com.google.protobuf.ProtocolStringList getFlagValueList()
       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.
      repeated string flag_value = 1;
      Specified by:
      getFlagValueList in interface InvocationPolicyOuterClass.SetValueOrBuilder
      Returns:
      A list containing the flagValue.

    • getFlagValueCount

      public int getFlagValueCount()
       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.
      repeated string flag_value = 1;
      Specified by:
      getFlagValueCount in interface InvocationPolicyOuterClass.SetValueOrBuilder
      Returns:
      The count of flagValue.

    • getFlagValue

      public String getFlagValue(int index)
       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.
      repeated string flag_value = 1;
      Specified by:
      getFlagValue in interface InvocationPolicyOuterClass.SetValueOrBuilder
      Parameters:
      index - The index of the element to return.
      Returns:
      The flagValue at the given index.

    • getFlagValueBytes

      public com.google.protobuf.ByteString getFlagValueBytes(int index)
       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.
      repeated string flag_value = 1;
      Specified by:
      getFlagValueBytes in interface InvocationPolicyOuterClass.SetValueOrBuilder
      Parameters:
      index - The index of the value to return.
      Returns:
      The bytes of the flagValue at the given index.

    • setFlagValue

      public InvocationPolicyOuterClass.SetValue.Builder setFlagValue(int index, String value)
       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.
      repeated string flag_value = 1;
      Parameters:
      index - The index to set the value at.
      value - The flagValue to set.
      Returns:
      This builder for chaining.

    • addFlagValue

      public InvocationPolicyOuterClass.SetValue.Builder addFlagValue(String value)
       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.
      repeated string flag_value = 1;
      Parameters:
      value - The flagValue to add.
      Returns:
      This builder for chaining.

    • addAllFlagValue

      public InvocationPolicyOuterClass.SetValue.Builder addAllFlagValue(Iterable<String> values)
       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.
      repeated string flag_value = 1;
      Parameters:
      values - The flagValue to add.
      Returns:
      This builder for chaining.

    • clearFlagValue

      public InvocationPolicyOuterClass.SetValue.Builder clearFlagValue()
       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.
      repeated string flag_value = 1;
      Returns:
      This builder for chaining.

    • addFlagValueBytes

      public InvocationPolicyOuterClass.SetValue.Builder addFlagValueBytes(com.google.protobuf.ByteString value)
       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.
      repeated string flag_value = 1;
      Parameters:
      value - The bytes of the flagValue to add.
      Returns:
      This builder for chaining.

    • hasBehavior

      public boolean hasBehavior()
       Defines how invocation policy should interact with user settings for the
 same flag.
      optional .blaze.invocation_policy.SetValue.Behavior behavior = 4;
      Specified by:
      hasBehavior in interface InvocationPolicyOuterClass.SetValueOrBuilder
      Returns:
      Whether the behavior field is set.

    • getBehavior

      public InvocationPolicyOuterClass.SetValue.Behavior getBehavior()
       Defines how invocation policy should interact with user settings for the
 same flag.
      optional .blaze.invocation_policy.SetValue.Behavior behavior = 4;
      Specified by:
      getBehavior in interface InvocationPolicyOuterClass.SetValueOrBuilder
      Returns:
      The behavior.

    • setBehavior

      public InvocationPolicyOuterClass.SetValue.Builder setBehavior(InvocationPolicyOuterClass.SetValue.Behavior value)
       Defines how invocation policy should interact with user settings for the
 same flag.
      optional .blaze.invocation_policy.SetValue.Behavior behavior = 4;
      Parameters:
      value - The behavior to set.
      Returns:
      This builder for chaining.

    • clearBehavior

      public InvocationPolicyOuterClass.SetValue.Builder clearBehavior()
       Defines how invocation policy should interact with user settings for the
 same flag.
      optional .blaze.invocation_policy.SetValue.Behavior behavior = 4;
      Returns:
      This builder for chaining.