RouteMatch.Builder (api 0.1.28 API)

java.lang.Object
- com.google.protobuf.AbstractMessageLite.Builder
- - com.google.protobuf.AbstractMessage.Builder<BuilderType>
  - - com.google.protobuf.GeneratedMessageV3.Builder<RouteMatch.Builder>
    - - io.envoyproxy.envoy.config.route.v3.RouteMatch.Builder

All Implemented Interfaces:

com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, RouteMatchOrBuilder, Cloneable

Enclosing class:

RouteMatch
```
public static final class RouteMatch.Builder
extends com.google.protobuf.GeneratedMessageV3.Builder<RouteMatch.Builder>
implements RouteMatchOrBuilder
```
```
 [#next-free-field: 13]
 
```
Protobuf type envoy.config.route.v3.RouteMatch

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`RouteMatch.Builder`	`addAllHeaders(Iterable<? extends HeaderMatcher> values)` Specifies a set of headers that the route should match on.
`RouteMatch.Builder`	`addAllQueryParameters(Iterable<? extends QueryParameterMatcher> values)` Specifies a set of URL query parameters on which the route should match.
`RouteMatch.Builder`	`addHeaders(HeaderMatcher.Builder builderForValue)` Specifies a set of headers that the route should match on.
`RouteMatch.Builder`	`addHeaders(HeaderMatcher value)` Specifies a set of headers that the route should match on.
`RouteMatch.Builder`	`addHeaders(int index, HeaderMatcher.Builder builderForValue)` Specifies a set of headers that the route should match on.
`RouteMatch.Builder`	`addHeaders(int index, HeaderMatcher value)` Specifies a set of headers that the route should match on.
`HeaderMatcher.Builder`	`addHeadersBuilder()` Specifies a set of headers that the route should match on.
`HeaderMatcher.Builder`	`addHeadersBuilder(int index)` Specifies a set of headers that the route should match on.
`RouteMatch.Builder`	`addQueryParameters(int index, QueryParameterMatcher.Builder builderForValue)` Specifies a set of URL query parameters on which the route should match.
`RouteMatch.Builder`	`addQueryParameters(int index, QueryParameterMatcher value)` Specifies a set of URL query parameters on which the route should match.
`RouteMatch.Builder`	`addQueryParameters(QueryParameterMatcher.Builder builderForValue)` Specifies a set of URL query parameters on which the route should match.
`RouteMatch.Builder`	`addQueryParameters(QueryParameterMatcher value)` Specifies a set of URL query parameters on which the route should match.
`QueryParameterMatcher.Builder`	`addQueryParametersBuilder()` Specifies a set of URL query parameters on which the route should match.
`QueryParameterMatcher.Builder`	`addQueryParametersBuilder(int index)` Specifies a set of URL query parameters on which the route should match.
`RouteMatch.Builder`	`addRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field, Object value)`
`RouteMatch`	`build()`
`RouteMatch`	`buildPartial()`
`RouteMatch.Builder`	`clear()`
`RouteMatch.Builder`	`clearCaseSensitive()` Indicates that prefix/path matching should be case sensitive.
`RouteMatch.Builder`	`clearConnectMatcher()` If this is used as the matcher, the matcher will only match CONNECT requests.
`RouteMatch.Builder`	`clearField(com.google.protobuf.Descriptors.FieldDescriptor field)`
`RouteMatch.Builder`	`clearGrpc()` If specified, only gRPC requests will be matched.
`RouteMatch.Builder`	`clearHeaders()` Specifies a set of headers that the route should match on.
`RouteMatch.Builder`	`clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof)`
`RouteMatch.Builder`	`clearPath()` If specified, the route is an exact path rule meaning that the path must exactly match the :path header once the query string is removed.
`RouteMatch.Builder`	`clearPathSpecifier()`
`RouteMatch.Builder`	`clearPrefix()` If specified, the route is a prefix rule meaning that the prefix must match the beginning of the :path header.
`RouteMatch.Builder`	`clearQueryParameters()` Specifies a set of URL query parameters on which the route should match.
`RouteMatch.Builder`	`clearRuntimeFraction()` Indicates that the route should additionally match on a runtime key.
`RouteMatch.Builder`	`clearSafeRegex()` If specified, the route is a regular expression rule meaning that the regex must match the :path header once the query string is removed.
`RouteMatch.Builder`	`clearTlsContext()` If specified, the client tls context will be matched against the defined match options.
`RouteMatch.Builder`	`clone()`
`com.google.protobuf.BoolValue`	`getCaseSensitive()` Indicates that prefix/path matching should be case sensitive.
`com.google.protobuf.BoolValue.Builder`	`getCaseSensitiveBuilder()` Indicates that prefix/path matching should be case sensitive.
`com.google.protobuf.BoolValueOrBuilder`	`getCaseSensitiveOrBuilder()` Indicates that prefix/path matching should be case sensitive.
`RouteMatch.ConnectMatcher`	`getConnectMatcher()` If this is used as the matcher, the matcher will only match CONNECT requests.
`RouteMatch.ConnectMatcher.Builder`	`getConnectMatcherBuilder()` If this is used as the matcher, the matcher will only match CONNECT requests.
`RouteMatch.ConnectMatcherOrBuilder`	`getConnectMatcherOrBuilder()` If this is used as the matcher, the matcher will only match CONNECT requests.
`RouteMatch`	`getDefaultInstanceForType()`
`static com.google.protobuf.Descriptors.Descriptor`	`getDescriptor()`
`com.google.protobuf.Descriptors.Descriptor`	`getDescriptorForType()`
`RouteMatch.GrpcRouteMatchOptions`	`getGrpc()` If specified, only gRPC requests will be matched.
`RouteMatch.GrpcRouteMatchOptions.Builder`	`getGrpcBuilder()` If specified, only gRPC requests will be matched.
`RouteMatch.GrpcRouteMatchOptionsOrBuilder`	`getGrpcOrBuilder()` If specified, only gRPC requests will be matched.
`HeaderMatcher`	`getHeaders(int index)` Specifies a set of headers that the route should match on.
`HeaderMatcher.Builder`	`getHeadersBuilder(int index)` Specifies a set of headers that the route should match on.
`List<HeaderMatcher.Builder>`	`getHeadersBuilderList()` Specifies a set of headers that the route should match on.
`int`	`getHeadersCount()` Specifies a set of headers that the route should match on.
`List<HeaderMatcher>`	`getHeadersList()` Specifies a set of headers that the route should match on.
`HeaderMatcherOrBuilder`	`getHeadersOrBuilder(int index)` Specifies a set of headers that the route should match on.
`List<? extends HeaderMatcherOrBuilder>`	`getHeadersOrBuilderList()` Specifies a set of headers that the route should match on.
`String`	`getPath()` If specified, the route is an exact path rule meaning that the path must exactly match the :path header once the query string is removed.
`com.google.protobuf.ByteString`	`getPathBytes()` If specified, the route is an exact path rule meaning that the path must exactly match the :path header once the query string is removed.
`RouteMatch.PathSpecifierCase`	`getPathSpecifierCase()`
`String`	`getPrefix()` If specified, the route is a prefix rule meaning that the prefix must match the beginning of the :path header.
`com.google.protobuf.ByteString`	`getPrefixBytes()` If specified, the route is a prefix rule meaning that the prefix must match the beginning of the :path header.
`QueryParameterMatcher`	`getQueryParameters(int index)` Specifies a set of URL query parameters on which the route should match.
`QueryParameterMatcher.Builder`	`getQueryParametersBuilder(int index)` Specifies a set of URL query parameters on which the route should match.
`List<QueryParameterMatcher.Builder>`	`getQueryParametersBuilderList()` Specifies a set of URL query parameters on which the route should match.
`int`	`getQueryParametersCount()` Specifies a set of URL query parameters on which the route should match.
`List<QueryParameterMatcher>`	`getQueryParametersList()` Specifies a set of URL query parameters on which the route should match.
`QueryParameterMatcherOrBuilder`	`getQueryParametersOrBuilder(int index)` Specifies a set of URL query parameters on which the route should match.
`List<? extends QueryParameterMatcherOrBuilder>`	`getQueryParametersOrBuilderList()` Specifies a set of URL query parameters on which the route should match.
`RuntimeFractionalPercent`	`getRuntimeFraction()` Indicates that the route should additionally match on a runtime key.
`RuntimeFractionalPercent.Builder`	`getRuntimeFractionBuilder()` Indicates that the route should additionally match on a runtime key.
`RuntimeFractionalPercentOrBuilder`	`getRuntimeFractionOrBuilder()` Indicates that the route should additionally match on a runtime key.
`RegexMatcher`	`getSafeRegex()` If specified, the route is a regular expression rule meaning that the regex must match the :path header once the query string is removed.
`RegexMatcher.Builder`	`getSafeRegexBuilder()` If specified, the route is a regular expression rule meaning that the regex must match the :path header once the query string is removed.
`RegexMatcherOrBuilder`	`getSafeRegexOrBuilder()` If specified, the route is a regular expression rule meaning that the regex must match the :path header once the query string is removed.
`RouteMatch.TlsContextMatchOptions`	`getTlsContext()` If specified, the client tls context will be matched against the defined match options.
`RouteMatch.TlsContextMatchOptions.Builder`	`getTlsContextBuilder()` If specified, the client tls context will be matched against the defined match options.
`RouteMatch.TlsContextMatchOptionsOrBuilder`	`getTlsContextOrBuilder()` If specified, the client tls context will be matched against the defined match options.
`boolean`	`hasCaseSensitive()` Indicates that prefix/path matching should be case sensitive.
`boolean`	`hasConnectMatcher()` If this is used as the matcher, the matcher will only match CONNECT requests.
`boolean`	`hasGrpc()` If specified, only gRPC requests will be matched.
`boolean`	`hasRuntimeFraction()` Indicates that the route should additionally match on a runtime key.
`boolean`	`hasSafeRegex()` If specified, the route is a regular expression rule meaning that the regex must match the :path header once the query string is removed.
`boolean`	`hasTlsContext()` If specified, the client tls context will be matched against the defined match options.
`protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable`	`internalGetFieldAccessorTable()`
`boolean`	`isInitialized()`
`RouteMatch.Builder`	`mergeCaseSensitive(com.google.protobuf.BoolValue value)` Indicates that prefix/path matching should be case sensitive.
`RouteMatch.Builder`	`mergeConnectMatcher(RouteMatch.ConnectMatcher value)` If this is used as the matcher, the matcher will only match CONNECT requests.
`RouteMatch.Builder`	`mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`RouteMatch.Builder`	`mergeFrom(com.google.protobuf.Message other)`
`RouteMatch.Builder`	`mergeFrom(RouteMatch other)`
`RouteMatch.Builder`	`mergeGrpc(RouteMatch.GrpcRouteMatchOptions value)` If specified, only gRPC requests will be matched.
`RouteMatch.Builder`	`mergeRuntimeFraction(RuntimeFractionalPercent value)` Indicates that the route should additionally match on a runtime key.
`RouteMatch.Builder`	`mergeSafeRegex(RegexMatcher value)` If specified, the route is a regular expression rule meaning that the regex must match the :path header once the query string is removed.
`RouteMatch.Builder`	`mergeTlsContext(RouteMatch.TlsContextMatchOptions value)` If specified, the client tls context will be matched against the defined match options.
`RouteMatch.Builder`	`mergeUnknownFields(com.google.protobuf.UnknownFieldSet unknownFields)`
`RouteMatch.Builder`	`removeHeaders(int index)` Specifies a set of headers that the route should match on.
`RouteMatch.Builder`	`removeQueryParameters(int index)` Specifies a set of URL query parameters on which the route should match.
`RouteMatch.Builder`	`setCaseSensitive(com.google.protobuf.BoolValue.Builder builderForValue)` Indicates that prefix/path matching should be case sensitive.
`RouteMatch.Builder`	`setCaseSensitive(com.google.protobuf.BoolValue value)` Indicates that prefix/path matching should be case sensitive.
`RouteMatch.Builder`	`setConnectMatcher(RouteMatch.ConnectMatcher.Builder builderForValue)` If this is used as the matcher, the matcher will only match CONNECT requests.
`RouteMatch.Builder`	`setConnectMatcher(RouteMatch.ConnectMatcher value)` If this is used as the matcher, the matcher will only match CONNECT requests.
`RouteMatch.Builder`	`setField(com.google.protobuf.Descriptors.FieldDescriptor field, Object value)`
`RouteMatch.Builder`	`setGrpc(RouteMatch.GrpcRouteMatchOptions.Builder builderForValue)` If specified, only gRPC requests will be matched.
`RouteMatch.Builder`	`setGrpc(RouteMatch.GrpcRouteMatchOptions value)` If specified, only gRPC requests will be matched.
`RouteMatch.Builder`	`setHeaders(int index, HeaderMatcher.Builder builderForValue)` Specifies a set of headers that the route should match on.
`RouteMatch.Builder`	`setHeaders(int index, HeaderMatcher value)` Specifies a set of headers that the route should match on.
`RouteMatch.Builder`	`setPath(String value)` If specified, the route is an exact path rule meaning that the path must exactly match the :path header once the query string is removed.
`RouteMatch.Builder`	`setPathBytes(com.google.protobuf.ByteString value)` If specified, the route is an exact path rule meaning that the path must exactly match the :path header once the query string is removed.
`RouteMatch.Builder`	`setPrefix(String value)` If specified, the route is a prefix rule meaning that the prefix must match the beginning of the :path header.
`RouteMatch.Builder`	`setPrefixBytes(com.google.protobuf.ByteString value)` If specified, the route is a prefix rule meaning that the prefix must match the beginning of the :path header.
`RouteMatch.Builder`	`setQueryParameters(int index, QueryParameterMatcher.Builder builderForValue)` Specifies a set of URL query parameters on which the route should match.
`RouteMatch.Builder`	`setQueryParameters(int index, QueryParameterMatcher value)` Specifies a set of URL query parameters on which the route should match.
`RouteMatch.Builder`	`setRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field, int index, Object value)`
`RouteMatch.Builder`	`setRuntimeFraction(RuntimeFractionalPercent.Builder builderForValue)` Indicates that the route should additionally match on a runtime key.
`RouteMatch.Builder`	`setRuntimeFraction(RuntimeFractionalPercent value)` Indicates that the route should additionally match on a runtime key.
`RouteMatch.Builder`	`setSafeRegex(RegexMatcher.Builder builderForValue)` If specified, the route is a regular expression rule meaning that the regex must match the :path header once the query string is removed.
`RouteMatch.Builder`	`setSafeRegex(RegexMatcher value)` If specified, the route is a regular expression rule meaning that the regex must match the :path header once the query string is removed.
`RouteMatch.Builder`	`setTlsContext(RouteMatch.TlsContextMatchOptions.Builder builderForValue)` If specified, the client tls context will be matched against the defined match options.
`RouteMatch.Builder`	`setTlsContext(RouteMatch.TlsContextMatchOptions value)` If specified, the client tls context will be matched against the defined match options.
`RouteMatch.Builder`	`setUnknownFields(com.google.protobuf.UnknownFieldSet unknownFields)`

Methods inherited from class com.google.protobuf.GeneratedMessageV3.Builder
getAllFields, getField, getFieldBuilder, getOneofFieldDescriptor, getParentForChildren, getRepeatedField, getRepeatedFieldBuilder, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof, internalGetMapField, internalGetMutableMapField, isClean, markClean, newBuilderForField, onBuilt, onChanged, setUnknownFieldsProto3

Methods inherited from class com.google.protobuf.AbstractMessage.Builder
findInitializationErrors, getInitializationErrorString, internalMergeFrom, mergeDelimitedFrom, mergeDelimitedFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, newUninitializedMessageException, toString

Methods inherited from class com.google.protobuf.AbstractMessageLite.Builder
addAll, addAll, mergeFrom, newUninitializedMessageException

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.google.protobuf.MessageOrBuilder
findInitializationErrors, getAllFields, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof

Methods inherited from interface com.google.protobuf.MessageLite.Builder
mergeFrom

Method Detail

getDescriptor

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

internalGetFieldAccessorTable
```
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
```
Specified by:

internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessageV3.Builder<RouteMatch.Builder>

clear
```
public RouteMatch.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.GeneratedMessageV3.Builder<RouteMatch.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.GeneratedMessageV3.Builder<RouteMatch.Builder>

getDefaultInstanceForType
```
public RouteMatch getDefaultInstanceForType()
```
Specified by:

getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder

Specified by:

getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder

build
```
public RouteMatch build()
```
Specified by:

build in interface com.google.protobuf.Message.Builder

Specified by:

build in interface com.google.protobuf.MessageLite.Builder

buildPartial
```
public RouteMatch buildPartial()
```
Specified by:

buildPartial in interface com.google.protobuf.Message.Builder

Specified by:

buildPartial in interface com.google.protobuf.MessageLite.Builder

clone
```
public RouteMatch.Builder clone()
```
Specified by:

clone in interface com.google.protobuf.Message.Builder

Specified by:

clone in interface com.google.protobuf.MessageLite.Builder

Overrides:

clone in class com.google.protobuf.GeneratedMessageV3.Builder<RouteMatch.Builder>

setField

public RouteMatch.Builder setField(com.google.protobuf.Descriptors.FieldDescriptor field,
                                   Object value)

Specified by:: setField in interface com.google.protobuf.Message.Builder
Overrides:: setField in class com.google.protobuf.GeneratedMessageV3.Builder<RouteMatch.Builder>

clearField
```
public RouteMatch.Builder clearField(com.google.protobuf.Descriptors.FieldDescriptor field)
```
Specified by:

clearField in interface com.google.protobuf.Message.Builder

Overrides:

clearField in class com.google.protobuf.GeneratedMessageV3.Builder<RouteMatch.Builder>

clearOneof
```
public RouteMatch.Builder clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof)
```
Specified by:

clearOneof in interface com.google.protobuf.Message.Builder

Overrides:

clearOneof in class com.google.protobuf.GeneratedMessageV3.Builder<RouteMatch.Builder>

setRepeatedField

public RouteMatch.Builder setRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field,
                                           int index,
                                           Object value)

Specified by:: setRepeatedField in interface com.google.protobuf.Message.Builder
Overrides:: setRepeatedField in class com.google.protobuf.GeneratedMessageV3.Builder<RouteMatch.Builder>

addRepeatedField

public RouteMatch.Builder addRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field,
                                           Object value)

Specified by:: addRepeatedField in interface com.google.protobuf.Message.Builder
Overrides:: addRepeatedField in class com.google.protobuf.GeneratedMessageV3.Builder<RouteMatch.Builder>

mergeFrom
```
public RouteMatch.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<RouteMatch.Builder>

mergeFrom

public RouteMatch.Builder mergeFrom(RouteMatch other)

isInitialized
```
public final boolean isInitialized()
```
Specified by:

isInitialized in interface com.google.protobuf.MessageLiteOrBuilder

Overrides:

isInitialized in class com.google.protobuf.GeneratedMessageV3.Builder<RouteMatch.Builder>

mergeFrom
```
public RouteMatch.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<RouteMatch.Builder>

Throws:

IOException

getPathSpecifierCase
```
public RouteMatch.PathSpecifierCase getPathSpecifierCase()
```
Specified by:

getPathSpecifierCase in interface RouteMatchOrBuilder

clearPathSpecifier

public RouteMatch.Builder clearPathSpecifier()

getPrefix

public String getPrefix()

 If specified, the route is a prefix rule meaning that the prefix must
 match the beginning of the *:path* header.

string prefix = 1;

Specified by:: getPrefix in interface RouteMatchOrBuilder

getPrefixBytes

public com.google.protobuf.ByteString getPrefixBytes()

 If specified, the route is a prefix rule meaning that the prefix must
 match the beginning of the *:path* header.

string prefix = 1;

Specified by:: getPrefixBytes in interface RouteMatchOrBuilder

setPrefix

public RouteMatch.Builder setPrefix(String value)

 If specified, the route is a prefix rule meaning that the prefix must
 match the beginning of the *:path* header.

string prefix = 1;

clearPrefix

public RouteMatch.Builder clearPrefix()

 If specified, the route is a prefix rule meaning that the prefix must
 match the beginning of the *:path* header.

string prefix = 1;

setPrefixBytes

public RouteMatch.Builder setPrefixBytes(com.google.protobuf.ByteString value)

 If specified, the route is a prefix rule meaning that the prefix must
 match the beginning of the *:path* header.

string prefix = 1;

getPath

public String getPath()

 If specified, the route is an exact path rule meaning that the path must
 exactly match the *:path* header once the query string is removed.

string path = 2;

Specified by:: getPath in interface RouteMatchOrBuilder

getPathBytes

public com.google.protobuf.ByteString getPathBytes()

 If specified, the route is an exact path rule meaning that the path must
 exactly match the *:path* header once the query string is removed.

string path = 2;

Specified by:: getPathBytes in interface RouteMatchOrBuilder

setPath

public RouteMatch.Builder setPath(String value)

 If specified, the route is an exact path rule meaning that the path must
 exactly match the *:path* header once the query string is removed.

string path = 2;

clearPath

public RouteMatch.Builder clearPath()

 If specified, the route is an exact path rule meaning that the path must
 exactly match the *:path* header once the query string is removed.

string path = 2;

setPathBytes

public RouteMatch.Builder setPathBytes(com.google.protobuf.ByteString value)

 If specified, the route is an exact path rule meaning that the path must
 exactly match the *:path* header once the query string is removed.

string path = 2;

hasSafeRegex

public boolean hasSafeRegex()

 If specified, the route is a regular expression rule meaning that the
 regex must match the *:path* header once the query string is removed. The entire path
 (without the query string) must match the regex. The rule will not match if only a
 subsequence of the *:path* header matches the regex.
 [#next-major-version: In the v3 API we should redo how path specification works such
 that we utilize StringMatcher, and additionally have consistent options around whether we
 strip query strings, do a case sensitive match, etc. In the interim it will be too disruptive
 to deprecate the existing options. We should even consider whether we want to do away with
 path_specifier entirely and just rely on a set of header matchers which can already match
 on :path, etc. The issue with that is it is unclear how to generically deal with query string
 stripping. This needs more thought.]

.envoy.type.matcher.v3.RegexMatcher safe_regex = 10 [(.validate.rules) = { ... }

Specified by:: hasSafeRegex in interface RouteMatchOrBuilder

getSafeRegex

public RegexMatcher getSafeRegex()

 If specified, the route is a regular expression rule meaning that the
 regex must match the *:path* header once the query string is removed. The entire path
 (without the query string) must match the regex. The rule will not match if only a
 subsequence of the *:path* header matches the regex.
 [#next-major-version: In the v3 API we should redo how path specification works such
 that we utilize StringMatcher, and additionally have consistent options around whether we
 strip query strings, do a case sensitive match, etc. In the interim it will be too disruptive
 to deprecate the existing options. We should even consider whether we want to do away with
 path_specifier entirely and just rely on a set of header matchers which can already match
 on :path, etc. The issue with that is it is unclear how to generically deal with query string
 stripping. This needs more thought.]

.envoy.type.matcher.v3.RegexMatcher safe_regex = 10 [(.validate.rules) = { ... }

Specified by:: getSafeRegex in interface RouteMatchOrBuilder

setSafeRegex

public RouteMatch.Builder setSafeRegex(RegexMatcher value)

 If specified, the route is a regular expression rule meaning that the
 regex must match the *:path* header once the query string is removed. The entire path
 (without the query string) must match the regex. The rule will not match if only a
 subsequence of the *:path* header matches the regex.
 [#next-major-version: In the v3 API we should redo how path specification works such
 that we utilize StringMatcher, and additionally have consistent options around whether we
 strip query strings, do a case sensitive match, etc. In the interim it will be too disruptive
 to deprecate the existing options. We should even consider whether we want to do away with
 path_specifier entirely and just rely on a set of header matchers which can already match
 on :path, etc. The issue with that is it is unclear how to generically deal with query string
 stripping. This needs more thought.]

.envoy.type.matcher.v3.RegexMatcher safe_regex = 10 [(.validate.rules) = { ... }

setSafeRegex

public RouteMatch.Builder setSafeRegex(RegexMatcher.Builder builderForValue)

 If specified, the route is a regular expression rule meaning that the
 regex must match the *:path* header once the query string is removed. The entire path
 (without the query string) must match the regex. The rule will not match if only a
 subsequence of the *:path* header matches the regex.
 [#next-major-version: In the v3 API we should redo how path specification works such
 that we utilize StringMatcher, and additionally have consistent options around whether we
 strip query strings, do a case sensitive match, etc. In the interim it will be too disruptive
 to deprecate the existing options. We should even consider whether we want to do away with
 path_specifier entirely and just rely on a set of header matchers which can already match
 on :path, etc. The issue with that is it is unclear how to generically deal with query string
 stripping. This needs more thought.]

.envoy.type.matcher.v3.RegexMatcher safe_regex = 10 [(.validate.rules) = { ... }

mergeSafeRegex

public RouteMatch.Builder mergeSafeRegex(RegexMatcher value)

 If specified, the route is a regular expression rule meaning that the
 regex must match the *:path* header once the query string is removed. The entire path
 (without the query string) must match the regex. The rule will not match if only a
 subsequence of the *:path* header matches the regex.
 [#next-major-version: In the v3 API we should redo how path specification works such
 that we utilize StringMatcher, and additionally have consistent options around whether we
 strip query strings, do a case sensitive match, etc. In the interim it will be too disruptive
 to deprecate the existing options. We should even consider whether we want to do away with
 path_specifier entirely and just rely on a set of header matchers which can already match
 on :path, etc. The issue with that is it is unclear how to generically deal with query string
 stripping. This needs more thought.]

.envoy.type.matcher.v3.RegexMatcher safe_regex = 10 [(.validate.rules) = { ... }

clearSafeRegex

public RouteMatch.Builder clearSafeRegex()

 If specified, the route is a regular expression rule meaning that the
 regex must match the *:path* header once the query string is removed. The entire path
 (without the query string) must match the regex. The rule will not match if only a
 subsequence of the *:path* header matches the regex.
 [#next-major-version: In the v3 API we should redo how path specification works such
 that we utilize StringMatcher, and additionally have consistent options around whether we
 strip query strings, do a case sensitive match, etc. In the interim it will be too disruptive
 to deprecate the existing options. We should even consider whether we want to do away with
 path_specifier entirely and just rely on a set of header matchers which can already match
 on :path, etc. The issue with that is it is unclear how to generically deal with query string
 stripping. This needs more thought.]

.envoy.type.matcher.v3.RegexMatcher safe_regex = 10 [(.validate.rules) = { ... }

getSafeRegexBuilder

public RegexMatcher.Builder getSafeRegexBuilder()

 If specified, the route is a regular expression rule meaning that the
 regex must match the *:path* header once the query string is removed. The entire path
 (without the query string) must match the regex. The rule will not match if only a
 subsequence of the *:path* header matches the regex.
 [#next-major-version: In the v3 API we should redo how path specification works such
 that we utilize StringMatcher, and additionally have consistent options around whether we
 strip query strings, do a case sensitive match, etc. In the interim it will be too disruptive
 to deprecate the existing options. We should even consider whether we want to do away with
 path_specifier entirely and just rely on a set of header matchers which can already match
 on :path, etc. The issue with that is it is unclear how to generically deal with query string
 stripping. This needs more thought.]

.envoy.type.matcher.v3.RegexMatcher safe_regex = 10 [(.validate.rules) = { ... }

getSafeRegexOrBuilder

public RegexMatcherOrBuilder getSafeRegexOrBuilder()

 If specified, the route is a regular expression rule meaning that the
 regex must match the *:path* header once the query string is removed. The entire path
 (without the query string) must match the regex. The rule will not match if only a
 subsequence of the *:path* header matches the regex.
 [#next-major-version: In the v3 API we should redo how path specification works such
 that we utilize StringMatcher, and additionally have consistent options around whether we
 strip query strings, do a case sensitive match, etc. In the interim it will be too disruptive
 to deprecate the existing options. We should even consider whether we want to do away with
 path_specifier entirely and just rely on a set of header matchers which can already match
 on :path, etc. The issue with that is it is unclear how to generically deal with query string
 stripping. This needs more thought.]

.envoy.type.matcher.v3.RegexMatcher safe_regex = 10 [(.validate.rules) = { ... }

Specified by:: getSafeRegexOrBuilder in interface RouteMatchOrBuilder

hasConnectMatcher

public boolean hasConnectMatcher()

 If this is used as the matcher, the matcher will only match CONNECT requests.
 Note that this will not match HTTP/2 upgrade-style CONNECT requests
 (WebSocket and the like) as they are normalized in Envoy as HTTP/1.1 style
 upgrades.
 This is the only way to match CONNECT requests for HTTP/1.1. For HTTP/2,
 where Extended CONNECT requests may have a path, the path matchers will work if
 there is a path present.
 Note that CONNECT support is currently considered alpha in Envoy.
 [#comment:TODO(htuch): Replace the above comment with an alpha tag.

.envoy.config.route.v3.RouteMatch.ConnectMatcher connect_matcher = 12;

Specified by:: hasConnectMatcher in interface RouteMatchOrBuilder

getConnectMatcher

public RouteMatch.ConnectMatcher getConnectMatcher()

 If this is used as the matcher, the matcher will only match CONNECT requests.
 Note that this will not match HTTP/2 upgrade-style CONNECT requests
 (WebSocket and the like) as they are normalized in Envoy as HTTP/1.1 style
 upgrades.
 This is the only way to match CONNECT requests for HTTP/1.1. For HTTP/2,
 where Extended CONNECT requests may have a path, the path matchers will work if
 there is a path present.
 Note that CONNECT support is currently considered alpha in Envoy.
 [#comment:TODO(htuch): Replace the above comment with an alpha tag.

.envoy.config.route.v3.RouteMatch.ConnectMatcher connect_matcher = 12;

Specified by:: getConnectMatcher in interface RouteMatchOrBuilder

setConnectMatcher

public RouteMatch.Builder setConnectMatcher(RouteMatch.ConnectMatcher value)

 If this is used as the matcher, the matcher will only match CONNECT requests.
 Note that this will not match HTTP/2 upgrade-style CONNECT requests
 (WebSocket and the like) as they are normalized in Envoy as HTTP/1.1 style
 upgrades.
 This is the only way to match CONNECT requests for HTTP/1.1. For HTTP/2,
 where Extended CONNECT requests may have a path, the path matchers will work if
 there is a path present.
 Note that CONNECT support is currently considered alpha in Envoy.
 [#comment:TODO(htuch): Replace the above comment with an alpha tag.

.envoy.config.route.v3.RouteMatch.ConnectMatcher connect_matcher = 12;

setConnectMatcher

public RouteMatch.Builder setConnectMatcher(RouteMatch.ConnectMatcher.Builder builderForValue)

 If this is used as the matcher, the matcher will only match CONNECT requests.
 Note that this will not match HTTP/2 upgrade-style CONNECT requests
 (WebSocket and the like) as they are normalized in Envoy as HTTP/1.1 style
 upgrades.
 This is the only way to match CONNECT requests for HTTP/1.1. For HTTP/2,
 where Extended CONNECT requests may have a path, the path matchers will work if
 there is a path present.
 Note that CONNECT support is currently considered alpha in Envoy.
 [#comment:TODO(htuch): Replace the above comment with an alpha tag.

.envoy.config.route.v3.RouteMatch.ConnectMatcher connect_matcher = 12;

mergeConnectMatcher

public RouteMatch.Builder mergeConnectMatcher(RouteMatch.ConnectMatcher value)

 If this is used as the matcher, the matcher will only match CONNECT requests.
 Note that this will not match HTTP/2 upgrade-style CONNECT requests
 (WebSocket and the like) as they are normalized in Envoy as HTTP/1.1 style
 upgrades.
 This is the only way to match CONNECT requests for HTTP/1.1. For HTTP/2,
 where Extended CONNECT requests may have a path, the path matchers will work if
 there is a path present.
 Note that CONNECT support is currently considered alpha in Envoy.
 [#comment:TODO(htuch): Replace the above comment with an alpha tag.

.envoy.config.route.v3.RouteMatch.ConnectMatcher connect_matcher = 12;

clearConnectMatcher

public RouteMatch.Builder clearConnectMatcher()

 If this is used as the matcher, the matcher will only match CONNECT requests.
 Note that this will not match HTTP/2 upgrade-style CONNECT requests
 (WebSocket and the like) as they are normalized in Envoy as HTTP/1.1 style
 upgrades.
 This is the only way to match CONNECT requests for HTTP/1.1. For HTTP/2,
 where Extended CONNECT requests may have a path, the path matchers will work if
 there is a path present.
 Note that CONNECT support is currently considered alpha in Envoy.
 [#comment:TODO(htuch): Replace the above comment with an alpha tag.

.envoy.config.route.v3.RouteMatch.ConnectMatcher connect_matcher = 12;

getConnectMatcherBuilder

public RouteMatch.ConnectMatcher.Builder getConnectMatcherBuilder()

 If this is used as the matcher, the matcher will only match CONNECT requests.
 Note that this will not match HTTP/2 upgrade-style CONNECT requests
 (WebSocket and the like) as they are normalized in Envoy as HTTP/1.1 style
 upgrades.
 This is the only way to match CONNECT requests for HTTP/1.1. For HTTP/2,
 where Extended CONNECT requests may have a path, the path matchers will work if
 there is a path present.
 Note that CONNECT support is currently considered alpha in Envoy.
 [#comment:TODO(htuch): Replace the above comment with an alpha tag.

.envoy.config.route.v3.RouteMatch.ConnectMatcher connect_matcher = 12;

getConnectMatcherOrBuilder

public RouteMatch.ConnectMatcherOrBuilder getConnectMatcherOrBuilder()

 If this is used as the matcher, the matcher will only match CONNECT requests.
 Note that this will not match HTTP/2 upgrade-style CONNECT requests
 (WebSocket and the like) as they are normalized in Envoy as HTTP/1.1 style
 upgrades.
 This is the only way to match CONNECT requests for HTTP/1.1. For HTTP/2,
 where Extended CONNECT requests may have a path, the path matchers will work if
 there is a path present.
 Note that CONNECT support is currently considered alpha in Envoy.
 [#comment:TODO(htuch): Replace the above comment with an alpha tag.

.envoy.config.route.v3.RouteMatch.ConnectMatcher connect_matcher = 12;

Specified by:: getConnectMatcherOrBuilder in interface RouteMatchOrBuilder

hasCaseSensitive

public boolean hasCaseSensitive()

 Indicates that prefix/path matching should be case sensitive. The default
 is true.

.google.protobuf.BoolValue case_sensitive = 4;

Specified by:: hasCaseSensitive in interface RouteMatchOrBuilder

getCaseSensitive

public com.google.protobuf.BoolValue getCaseSensitive()

 Indicates that prefix/path matching should be case sensitive. The default
 is true.

.google.protobuf.BoolValue case_sensitive = 4;

Specified by:: getCaseSensitive in interface RouteMatchOrBuilder

setCaseSensitive

public RouteMatch.Builder setCaseSensitive(com.google.protobuf.BoolValue value)

 Indicates that prefix/path matching should be case sensitive. The default
 is true.

.google.protobuf.BoolValue case_sensitive = 4;

setCaseSensitive

public RouteMatch.Builder setCaseSensitive(com.google.protobuf.BoolValue.Builder builderForValue)

 Indicates that prefix/path matching should be case sensitive. The default
 is true.

.google.protobuf.BoolValue case_sensitive = 4;

mergeCaseSensitive

public RouteMatch.Builder mergeCaseSensitive(com.google.protobuf.BoolValue value)

 Indicates that prefix/path matching should be case sensitive. The default
 is true.

.google.protobuf.BoolValue case_sensitive = 4;

clearCaseSensitive

public RouteMatch.Builder clearCaseSensitive()

 Indicates that prefix/path matching should be case sensitive. The default
 is true.

.google.protobuf.BoolValue case_sensitive = 4;

getCaseSensitiveBuilder

public com.google.protobuf.BoolValue.Builder getCaseSensitiveBuilder()

 Indicates that prefix/path matching should be case sensitive. The default
 is true.

.google.protobuf.BoolValue case_sensitive = 4;

getCaseSensitiveOrBuilder

public com.google.protobuf.BoolValueOrBuilder getCaseSensitiveOrBuilder()

 Indicates that prefix/path matching should be case sensitive. The default
 is true.

.google.protobuf.BoolValue case_sensitive = 4;

Specified by:: getCaseSensitiveOrBuilder in interface RouteMatchOrBuilder

hasRuntimeFraction

public boolean hasRuntimeFraction()

 Indicates that the route should additionally match on a runtime key. Every time the route
 is considered for a match, it must also fall under the percentage of matches indicated by
 this field. For some fraction N/D, a random number in the range [0,D) is selected. If the
 number is <= the value of the numerator N, or if the key is not present, the default
 value, the router continues to evaluate the remaining match criteria. A runtime_fraction
 route configuration can be used to roll out route changes in a gradual manner without full
 code/config deploys. Refer to the :ref:`traffic shifting
 <config_http_conn_man_route_table_traffic_splitting_shift>` docs for additional documentation.
 .. note::
    Parsing this field is implemented such that the runtime key's data may be represented
    as a FractionalPercent proto represented as JSON/YAML and may also be represented as an
    integer with the assumption that the value is an integral percentage out of 100. For
    instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
    whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.

.envoy.config.core.v3.RuntimeFractionalPercent runtime_fraction = 9;

Specified by:: hasRuntimeFraction in interface RouteMatchOrBuilder

getRuntimeFraction

public RuntimeFractionalPercent getRuntimeFraction()

 Indicates that the route should additionally match on a runtime key. Every time the route
 is considered for a match, it must also fall under the percentage of matches indicated by
 this field. For some fraction N/D, a random number in the range [0,D) is selected. If the
 number is <= the value of the numerator N, or if the key is not present, the default
 value, the router continues to evaluate the remaining match criteria. A runtime_fraction
 route configuration can be used to roll out route changes in a gradual manner without full
 code/config deploys. Refer to the :ref:`traffic shifting
 <config_http_conn_man_route_table_traffic_splitting_shift>` docs for additional documentation.
 .. note::
    Parsing this field is implemented such that the runtime key's data may be represented
    as a FractionalPercent proto represented as JSON/YAML and may also be represented as an
    integer with the assumption that the value is an integral percentage out of 100. For
    instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
    whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.

.envoy.config.core.v3.RuntimeFractionalPercent runtime_fraction = 9;

Specified by:: getRuntimeFraction in interface RouteMatchOrBuilder

setRuntimeFraction

public RouteMatch.Builder setRuntimeFraction(RuntimeFractionalPercent value)

 Indicates that the route should additionally match on a runtime key. Every time the route
 is considered for a match, it must also fall under the percentage of matches indicated by
 this field. For some fraction N/D, a random number in the range [0,D) is selected. If the
 number is <= the value of the numerator N, or if the key is not present, the default
 value, the router continues to evaluate the remaining match criteria. A runtime_fraction
 route configuration can be used to roll out route changes in a gradual manner without full
 code/config deploys. Refer to the :ref:`traffic shifting
 <config_http_conn_man_route_table_traffic_splitting_shift>` docs for additional documentation.
 .. note::
    Parsing this field is implemented such that the runtime key's data may be represented
    as a FractionalPercent proto represented as JSON/YAML and may also be represented as an
    integer with the assumption that the value is an integral percentage out of 100. For
    instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
    whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.

.envoy.config.core.v3.RuntimeFractionalPercent runtime_fraction = 9;

setRuntimeFraction

public RouteMatch.Builder setRuntimeFraction(RuntimeFractionalPercent.Builder builderForValue)

 Indicates that the route should additionally match on a runtime key. Every time the route
 is considered for a match, it must also fall under the percentage of matches indicated by
 this field. For some fraction N/D, a random number in the range [0,D) is selected. If the
 number is <= the value of the numerator N, or if the key is not present, the default
 value, the router continues to evaluate the remaining match criteria. A runtime_fraction
 route configuration can be used to roll out route changes in a gradual manner without full
 code/config deploys. Refer to the :ref:`traffic shifting
 <config_http_conn_man_route_table_traffic_splitting_shift>` docs for additional documentation.
 .. note::
    Parsing this field is implemented such that the runtime key's data may be represented
    as a FractionalPercent proto represented as JSON/YAML and may also be represented as an
    integer with the assumption that the value is an integral percentage out of 100. For
    instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
    whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.

.envoy.config.core.v3.RuntimeFractionalPercent runtime_fraction = 9;

mergeRuntimeFraction

public RouteMatch.Builder mergeRuntimeFraction(RuntimeFractionalPercent value)

 Indicates that the route should additionally match on a runtime key. Every time the route
 is considered for a match, it must also fall under the percentage of matches indicated by
 this field. For some fraction N/D, a random number in the range [0,D) is selected. If the
 number is <= the value of the numerator N, or if the key is not present, the default
 value, the router continues to evaluate the remaining match criteria. A runtime_fraction
 route configuration can be used to roll out route changes in a gradual manner without full
 code/config deploys. Refer to the :ref:`traffic shifting
 <config_http_conn_man_route_table_traffic_splitting_shift>` docs for additional documentation.
 .. note::
    Parsing this field is implemented such that the runtime key's data may be represented
    as a FractionalPercent proto represented as JSON/YAML and may also be represented as an
    integer with the assumption that the value is an integral percentage out of 100. For
    instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
    whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.

.envoy.config.core.v3.RuntimeFractionalPercent runtime_fraction = 9;

clearRuntimeFraction

public RouteMatch.Builder clearRuntimeFraction()

 Indicates that the route should additionally match on a runtime key. Every time the route
 is considered for a match, it must also fall under the percentage of matches indicated by
 this field. For some fraction N/D, a random number in the range [0,D) is selected. If the
 number is <= the value of the numerator N, or if the key is not present, the default
 value, the router continues to evaluate the remaining match criteria. A runtime_fraction
 route configuration can be used to roll out route changes in a gradual manner without full
 code/config deploys. Refer to the :ref:`traffic shifting
 <config_http_conn_man_route_table_traffic_splitting_shift>` docs for additional documentation.
 .. note::
    Parsing this field is implemented such that the runtime key's data may be represented
    as a FractionalPercent proto represented as JSON/YAML and may also be represented as an
    integer with the assumption that the value is an integral percentage out of 100. For
    instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
    whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.

.envoy.config.core.v3.RuntimeFractionalPercent runtime_fraction = 9;

getRuntimeFractionBuilder

public RuntimeFractionalPercent.Builder getRuntimeFractionBuilder()

 Indicates that the route should additionally match on a runtime key. Every time the route
 is considered for a match, it must also fall under the percentage of matches indicated by
 this field. For some fraction N/D, a random number in the range [0,D) is selected. If the
 number is <= the value of the numerator N, or if the key is not present, the default
 value, the router continues to evaluate the remaining match criteria. A runtime_fraction
 route configuration can be used to roll out route changes in a gradual manner without full
 code/config deploys. Refer to the :ref:`traffic shifting
 <config_http_conn_man_route_table_traffic_splitting_shift>` docs for additional documentation.
 .. note::
    Parsing this field is implemented such that the runtime key's data may be represented
    as a FractionalPercent proto represented as JSON/YAML and may also be represented as an
    integer with the assumption that the value is an integral percentage out of 100. For
    instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
    whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.

.envoy.config.core.v3.RuntimeFractionalPercent runtime_fraction = 9;

getRuntimeFractionOrBuilder

public RuntimeFractionalPercentOrBuilder getRuntimeFractionOrBuilder()

 Indicates that the route should additionally match on a runtime key. Every time the route
 is considered for a match, it must also fall under the percentage of matches indicated by
 this field. For some fraction N/D, a random number in the range [0,D) is selected. If the
 number is <= the value of the numerator N, or if the key is not present, the default
 value, the router continues to evaluate the remaining match criteria. A runtime_fraction
 route configuration can be used to roll out route changes in a gradual manner without full
 code/config deploys. Refer to the :ref:`traffic shifting
 <config_http_conn_man_route_table_traffic_splitting_shift>` docs for additional documentation.
 .. note::
    Parsing this field is implemented such that the runtime key's data may be represented
    as a FractionalPercent proto represented as JSON/YAML and may also be represented as an
    integer with the assumption that the value is an integral percentage out of 100. For
    instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
    whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.

.envoy.config.core.v3.RuntimeFractionalPercent runtime_fraction = 9;

Specified by:: getRuntimeFractionOrBuilder in interface RouteMatchOrBuilder

getHeadersList

public List<HeaderMatcher> getHeadersList()

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

Specified by:: getHeadersList in interface RouteMatchOrBuilder

getHeadersCount

public int getHeadersCount()

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

Specified by:: getHeadersCount in interface RouteMatchOrBuilder

getHeaders

public HeaderMatcher getHeaders(int index)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

Specified by:: getHeaders in interface RouteMatchOrBuilder

setHeaders

public RouteMatch.Builder setHeaders(int index,
                                     HeaderMatcher value)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

setHeaders

public RouteMatch.Builder setHeaders(int index,
                                     HeaderMatcher.Builder builderForValue)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

addHeaders

public RouteMatch.Builder addHeaders(HeaderMatcher value)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

addHeaders

public RouteMatch.Builder addHeaders(int index,
                                     HeaderMatcher value)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

addHeaders

public RouteMatch.Builder addHeaders(HeaderMatcher.Builder builderForValue)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

addHeaders

public RouteMatch.Builder addHeaders(int index,
                                     HeaderMatcher.Builder builderForValue)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

addAllHeaders

public RouteMatch.Builder addAllHeaders(Iterable<? extends HeaderMatcher> values)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

clearHeaders

public RouteMatch.Builder clearHeaders()

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

removeHeaders

public RouteMatch.Builder removeHeaders(int index)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

getHeadersBuilder

public HeaderMatcher.Builder getHeadersBuilder(int index)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

getHeadersOrBuilder

public HeaderMatcherOrBuilder getHeadersOrBuilder(int index)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

Specified by:: getHeadersOrBuilder in interface RouteMatchOrBuilder

getHeadersOrBuilderList

public List<? extends HeaderMatcherOrBuilder> getHeadersOrBuilderList()

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

Specified by:: getHeadersOrBuilderList in interface RouteMatchOrBuilder

addHeadersBuilder

public HeaderMatcher.Builder addHeadersBuilder()

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

addHeadersBuilder

public HeaderMatcher.Builder addHeadersBuilder(int index)

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;

getHeadersBuilderList

public List<HeaderMatcher.Builder> getHeadersBuilderList()

 Specifies a set of headers that the route should match on. The router will
 check the request’s headers against all the specified headers in the route
 config. A match will happen if all the headers in the route are present in
 the request with the same values (or based on presence if the value field
 is not in the config).

repeated .envoy.config.route.v3.HeaderMatcher headers = 6;