Package io.envoyproxy.envoy.type.matcher.v3

Class RegexMatchAndSubstitute.Builder

  • All Implemented Interfaces:
    com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, RegexMatchAndSubstituteOrBuilder, Cloneable
    Enclosing class:
    RegexMatchAndSubstitute
    public static final class RegexMatchAndSubstitute.Builder
extends com.google.protobuf.GeneratedMessageV3.Builder<RegexMatchAndSubstitute.Builder>
implements RegexMatchAndSubstituteOrBuilder
     Describes how to match a string and then produce a new string using a regular
 expression and a substitution string.
    Protobuf type envoy.type.matcher.v3.RegexMatchAndSubstitute

    • 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<RegexMatchAndSubstitute.Builder>

      • clear

        public RegexMatchAndSubstitute.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<RegexMatchAndSubstitute.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<RegexMatchAndSubstitute.Builder>

      • getDefaultInstanceForType

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

      • build

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

      • buildPartial

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

      • clone

        public RegexMatchAndSubstitute.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<RegexMatchAndSubstitute.Builder>

      • clearField

        public RegexMatchAndSubstitute.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<RegexMatchAndSubstitute.Builder>

      • clearOneof

        public RegexMatchAndSubstitute.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<RegexMatchAndSubstitute.Builder>

      • setRepeatedField

        public RegexMatchAndSubstitute.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<RegexMatchAndSubstitute.Builder>

      • addRepeatedField

        public RegexMatchAndSubstitute.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<RegexMatchAndSubstitute.Builder>

      • isInitialized

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

      • mergeFrom

        public RegexMatchAndSubstitute.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<RegexMatchAndSubstitute.Builder>
        Throws:
        IOException

      • hasPattern

        public boolean hasPattern()
         The regular expression used to find portions of a string (hereafter called
 the "subject string") that should be replaced. When a new string is
 produced during the substitution operation, the new string is initially
 the same as the subject string, but then all matches in the subject string
 are replaced by the substitution string. If replacing all matches isn't
 desired, regular expression anchors can be used to ensure a single match,
 so as to replace just one occurrence of a pattern. Capture groups can be
 used in the pattern to extract portions of the subject string, and then
 referenced in the substitution string.
        .envoy.type.matcher.v3.RegexMatcher pattern = 1 [(.validate.rules) = { ... }
        Specified by:
        hasPattern in interface RegexMatchAndSubstituteOrBuilder
        Returns:
        Whether the pattern field is set.

      • getPattern

        public RegexMatcher getPattern()
         The regular expression used to find portions of a string (hereafter called
 the "subject string") that should be replaced. When a new string is
 produced during the substitution operation, the new string is initially
 the same as the subject string, but then all matches in the subject string
 are replaced by the substitution string. If replacing all matches isn't
 desired, regular expression anchors can be used to ensure a single match,
 so as to replace just one occurrence of a pattern. Capture groups can be
 used in the pattern to extract portions of the subject string, and then
 referenced in the substitution string.
        .envoy.type.matcher.v3.RegexMatcher pattern = 1 [(.validate.rules) = { ... }
        Specified by:
        getPattern in interface RegexMatchAndSubstituteOrBuilder
        Returns:
        The pattern.

      • setPattern

        public RegexMatchAndSubstitute.Builder setPattern​(RegexMatcher value)
         The regular expression used to find portions of a string (hereafter called
 the "subject string") that should be replaced. When a new string is
 produced during the substitution operation, the new string is initially
 the same as the subject string, but then all matches in the subject string
 are replaced by the substitution string. If replacing all matches isn't
 desired, regular expression anchors can be used to ensure a single match,
 so as to replace just one occurrence of a pattern. Capture groups can be
 used in the pattern to extract portions of the subject string, and then
 referenced in the substitution string.
        .envoy.type.matcher.v3.RegexMatcher pattern = 1 [(.validate.rules) = { ... }

      • setPattern

        public RegexMatchAndSubstitute.Builder setPattern​(RegexMatcher.Builder builderForValue)
         The regular expression used to find portions of a string (hereafter called
 the "subject string") that should be replaced. When a new string is
 produced during the substitution operation, the new string is initially
 the same as the subject string, but then all matches in the subject string
 are replaced by the substitution string. If replacing all matches isn't
 desired, regular expression anchors can be used to ensure a single match,
 so as to replace just one occurrence of a pattern. Capture groups can be
 used in the pattern to extract portions of the subject string, and then
 referenced in the substitution string.
        .envoy.type.matcher.v3.RegexMatcher pattern = 1 [(.validate.rules) = { ... }

      • mergePattern

        public RegexMatchAndSubstitute.Builder mergePattern​(RegexMatcher value)
         The regular expression used to find portions of a string (hereafter called
 the "subject string") that should be replaced. When a new string is
 produced during the substitution operation, the new string is initially
 the same as the subject string, but then all matches in the subject string
 are replaced by the substitution string. If replacing all matches isn't
 desired, regular expression anchors can be used to ensure a single match,
 so as to replace just one occurrence of a pattern. Capture groups can be
 used in the pattern to extract portions of the subject string, and then
 referenced in the substitution string.
        .envoy.type.matcher.v3.RegexMatcher pattern = 1 [(.validate.rules) = { ... }

      • clearPattern

        public RegexMatchAndSubstitute.Builder clearPattern()
         The regular expression used to find portions of a string (hereafter called
 the "subject string") that should be replaced. When a new string is
 produced during the substitution operation, the new string is initially
 the same as the subject string, but then all matches in the subject string
 are replaced by the substitution string. If replacing all matches isn't
 desired, regular expression anchors can be used to ensure a single match,
 so as to replace just one occurrence of a pattern. Capture groups can be
 used in the pattern to extract portions of the subject string, and then
 referenced in the substitution string.
        .envoy.type.matcher.v3.RegexMatcher pattern = 1 [(.validate.rules) = { ... }

      • getPatternBuilder

        public RegexMatcher.Builder getPatternBuilder()
         The regular expression used to find portions of a string (hereafter called
 the "subject string") that should be replaced. When a new string is
 produced during the substitution operation, the new string is initially
 the same as the subject string, but then all matches in the subject string
 are replaced by the substitution string. If replacing all matches isn't
 desired, regular expression anchors can be used to ensure a single match,
 so as to replace just one occurrence of a pattern. Capture groups can be
 used in the pattern to extract portions of the subject string, and then
 referenced in the substitution string.
        .envoy.type.matcher.v3.RegexMatcher pattern = 1 [(.validate.rules) = { ... }

      • getPatternOrBuilder

        public RegexMatcherOrBuilder getPatternOrBuilder()
         The regular expression used to find portions of a string (hereafter called
 the "subject string") that should be replaced. When a new string is
 produced during the substitution operation, the new string is initially
 the same as the subject string, but then all matches in the subject string
 are replaced by the substitution string. If replacing all matches isn't
 desired, regular expression anchors can be used to ensure a single match,
 so as to replace just one occurrence of a pattern. Capture groups can be
 used in the pattern to extract portions of the subject string, and then
 referenced in the substitution string.
        .envoy.type.matcher.v3.RegexMatcher pattern = 1 [(.validate.rules) = { ... }
        Specified by:
        getPatternOrBuilder in interface RegexMatchAndSubstituteOrBuilder

      • getSubstitution

        public String getSubstitution()
         The string that should be substituted into matching portions of the
 subject string during a substitution operation to produce a new string.
 Capture groups in the pattern can be referenced in the substitution
 string. Note, however, that the syntax for referring to capture groups is
 defined by the chosen regular expression engine. Google's `RE2
 <https://github.com/google/re2>`_ regular expression engine uses a
 backslash followed by the capture group number to denote a numbered
 capture group. E.g., ``\1`` refers to capture group 1, and ``\2`` refers
 to capture group 2.
        string substitution = 2;
        Specified by:
        getSubstitution in interface RegexMatchAndSubstituteOrBuilder
        Returns:
        The substitution.

      • getSubstitutionBytes

        public com.google.protobuf.ByteString getSubstitutionBytes()
         The string that should be substituted into matching portions of the
 subject string during a substitution operation to produce a new string.
 Capture groups in the pattern can be referenced in the substitution
 string. Note, however, that the syntax for referring to capture groups is
 defined by the chosen regular expression engine. Google's `RE2
 <https://github.com/google/re2>`_ regular expression engine uses a
 backslash followed by the capture group number to denote a numbered
 capture group. E.g., ``\1`` refers to capture group 1, and ``\2`` refers
 to capture group 2.
        string substitution = 2;
        Specified by:
        getSubstitutionBytes in interface RegexMatchAndSubstituteOrBuilder
        Returns:
        The bytes for substitution.

      • setSubstitution

        public RegexMatchAndSubstitute.Builder setSubstitution​(String value)
         The string that should be substituted into matching portions of the
 subject string during a substitution operation to produce a new string.
 Capture groups in the pattern can be referenced in the substitution
 string. Note, however, that the syntax for referring to capture groups is
 defined by the chosen regular expression engine. Google's `RE2
 <https://github.com/google/re2>`_ regular expression engine uses a
 backslash followed by the capture group number to denote a numbered
 capture group. E.g., ``\1`` refers to capture group 1, and ``\2`` refers
 to capture group 2.
        string substitution = 2;
        Parameters:
        value - The substitution to set.
        Returns:
        This builder for chaining.

      • clearSubstitution

        public RegexMatchAndSubstitute.Builder clearSubstitution()
         The string that should be substituted into matching portions of the
 subject string during a substitution operation to produce a new string.
 Capture groups in the pattern can be referenced in the substitution
 string. Note, however, that the syntax for referring to capture groups is
 defined by the chosen regular expression engine. Google's `RE2
 <https://github.com/google/re2>`_ regular expression engine uses a
 backslash followed by the capture group number to denote a numbered
 capture group. E.g., ``\1`` refers to capture group 1, and ``\2`` refers
 to capture group 2.
        string substitution = 2;
        Returns:
        This builder for chaining.

      • setSubstitutionBytes

        public RegexMatchAndSubstitute.Builder setSubstitutionBytes​(com.google.protobuf.ByteString value)
         The string that should be substituted into matching portions of the
 subject string during a substitution operation to produce a new string.
 Capture groups in the pattern can be referenced in the substitution
 string. Note, however, that the syntax for referring to capture groups is
 defined by the chosen regular expression engine. Google's `RE2
 <https://github.com/google/re2>`_ regular expression engine uses a
 backslash followed by the capture group number to denote a numbered
 capture group. E.g., ``\1`` refers to capture group 1, and ``\2`` refers
 to capture group 2.
        string substitution = 2;
        Parameters:
        value - The bytes for substitution to set.
        Returns:
        This builder for chaining.

      • setUnknownFields

        public final RegexMatchAndSubstitute.Builder setUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)
        Specified by:
        setUnknownFields in interface com.google.protobuf.Message.Builder
        Overrides:
        setUnknownFields in class com.google.protobuf.GeneratedMessageV3.Builder<RegexMatchAndSubstitute.Builder>

      • mergeUnknownFields

        public final RegexMatchAndSubstitute.Builder mergeUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)
        Specified by:
        mergeUnknownFields in interface com.google.protobuf.Message.Builder
        Overrides:
        mergeUnknownFields in class com.google.protobuf.GeneratedMessageV3.Builder<RegexMatchAndSubstitute.Builder>