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, java.lang.Cloneable
    Enclosing class:
    RegexMatchAndSubstitute
    public static final class RegexMatchAndSubstitute.Builder
extends com.google.protobuf.GeneratedMessage.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

    • Constructor Detail

      • Builder

        private Builder()

      • Builder

        private Builder​(com.google.protobuf.AbstractMessage.BuilderParent parent)

    • Method Detail

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

      • maybeForceBuilderInitialization

        private void maybeForceBuilderInitialization()

      • 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<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

      • isInitialized

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

      • mergeFrom

        public RegexMatchAndSubstitute.Builder mergeFrom​(com.google.protobuf.CodedInputStream input,
                                                 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                          throws java.io.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:
        java.io.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

      • getPatternFieldBuilder

        private com.google.protobuf.SingleFieldBuilder<RegexMatcher,​RegexMatcher.Builder,​RegexMatcherOrBuilder> getPatternFieldBuilder()
         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) = { ... }

      • getSubstitution

        public java.lang.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 [(.validate.rules) = { ... }
        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 [(.validate.rules) = { ... }
        Specified by:
        getSubstitutionBytes in interface RegexMatchAndSubstituteOrBuilder
        Returns:
        The bytes for substitution.

      • setSubstitution

        public RegexMatchAndSubstitute.Builder setSubstitution​(java.lang.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 [(.validate.rules) = { ... }
        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 [(.validate.rules) = { ... }
        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 [(.validate.rules) = { ... }
        Parameters:
        value - The bytes for substitution to set.
        Returns:
        This builder for chaining.