Class RedirectAction.Builder

  • All Implemented Interfaces:
    com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, RedirectActionOrBuilder, java.lang.Cloneable
    Enclosing class:
    RedirectAction

    public static final class RedirectAction.Builder
    extends com.google.protobuf.GeneratedMessage.Builder<RedirectAction.Builder>
    implements RedirectActionOrBuilder
     [#next-free-field: 10]
     
    Protobuf type envoy.config.route.v3.RedirectAction
    • Field Detail

      • schemeRewriteSpecifierCase_

        private int schemeRewriteSpecifierCase_
      • schemeRewriteSpecifier_

        private java.lang.Object schemeRewriteSpecifier_
      • pathRewriteSpecifierCase_

        private int pathRewriteSpecifierCase_
      • pathRewriteSpecifier_

        private java.lang.Object pathRewriteSpecifier_
      • bitField0_

        private int bitField0_
      • hostRedirect_

        private java.lang.Object hostRedirect_
      • portRedirect_

        private int portRedirect_
      • responseCode_

        private int responseCode_
      • stripQuery_

        private boolean stripQuery_
    • 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<RedirectAction.Builder>
      • clear

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

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

        public RedirectAction getDefaultInstanceForType()
        Specified by:
        getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder
        Specified by:
        getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder
      • build

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

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

        private void buildPartial0​(RedirectAction result)
      • buildPartialOneofs

        private void buildPartialOneofs​(RedirectAction result)
      • mergeFrom

        public RedirectAction.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<RedirectAction.Builder>
      • isInitialized

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

        public RedirectAction.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<RedirectAction.Builder>
        Throws:
        java.io.IOException
      • hasHttpsRedirect

        public boolean hasHttpsRedirect()
         The scheme portion of the URL will be swapped with "https".
         
        bool https_redirect = 4;
        Specified by:
        hasHttpsRedirect in interface RedirectActionOrBuilder
        Returns:
        Whether the httpsRedirect field is set.
      • getHttpsRedirect

        public boolean getHttpsRedirect()
         The scheme portion of the URL will be swapped with "https".
         
        bool https_redirect = 4;
        Specified by:
        getHttpsRedirect in interface RedirectActionOrBuilder
        Returns:
        The httpsRedirect.
      • setHttpsRedirect

        public RedirectAction.Builder setHttpsRedirect​(boolean value)
         The scheme portion of the URL will be swapped with "https".
         
        bool https_redirect = 4;
        Parameters:
        value - The httpsRedirect to set.
        Returns:
        This builder for chaining.
      • clearHttpsRedirect

        public RedirectAction.Builder clearHttpsRedirect()
         The scheme portion of the URL will be swapped with "https".
         
        bool https_redirect = 4;
        Returns:
        This builder for chaining.
      • hasSchemeRedirect

        public boolean hasSchemeRedirect()
         The scheme portion of the URL will be swapped with this value.
         
        string scheme_redirect = 7;
        Specified by:
        hasSchemeRedirect in interface RedirectActionOrBuilder
        Returns:
        Whether the schemeRedirect field is set.
      • getSchemeRedirect

        public java.lang.String getSchemeRedirect()
         The scheme portion of the URL will be swapped with this value.
         
        string scheme_redirect = 7;
        Specified by:
        getSchemeRedirect in interface RedirectActionOrBuilder
        Returns:
        The schemeRedirect.
      • getSchemeRedirectBytes

        public com.google.protobuf.ByteString getSchemeRedirectBytes()
         The scheme portion of the URL will be swapped with this value.
         
        string scheme_redirect = 7;
        Specified by:
        getSchemeRedirectBytes in interface RedirectActionOrBuilder
        Returns:
        The bytes for schemeRedirect.
      • setSchemeRedirect

        public RedirectAction.Builder setSchemeRedirect​(java.lang.String value)
         The scheme portion of the URL will be swapped with this value.
         
        string scheme_redirect = 7;
        Parameters:
        value - The schemeRedirect to set.
        Returns:
        This builder for chaining.
      • clearSchemeRedirect

        public RedirectAction.Builder clearSchemeRedirect()
         The scheme portion of the URL will be swapped with this value.
         
        string scheme_redirect = 7;
        Returns:
        This builder for chaining.
      • setSchemeRedirectBytes

        public RedirectAction.Builder setSchemeRedirectBytes​(com.google.protobuf.ByteString value)
         The scheme portion of the URL will be swapped with this value.
         
        string scheme_redirect = 7;
        Parameters:
        value - The bytes for schemeRedirect to set.
        Returns:
        This builder for chaining.
      • getHostRedirect

        public java.lang.String getHostRedirect()
         The host portion of the URL will be swapped with this value.
         
        string host_redirect = 1 [(.validate.rules) = { ... }
        Specified by:
        getHostRedirect in interface RedirectActionOrBuilder
        Returns:
        The hostRedirect.
      • getHostRedirectBytes

        public com.google.protobuf.ByteString getHostRedirectBytes()
         The host portion of the URL will be swapped with this value.
         
        string host_redirect = 1 [(.validate.rules) = { ... }
        Specified by:
        getHostRedirectBytes in interface RedirectActionOrBuilder
        Returns:
        The bytes for hostRedirect.
      • setHostRedirect

        public RedirectAction.Builder setHostRedirect​(java.lang.String value)
         The host portion of the URL will be swapped with this value.
         
        string host_redirect = 1 [(.validate.rules) = { ... }
        Parameters:
        value - The hostRedirect to set.
        Returns:
        This builder for chaining.
      • clearHostRedirect

        public RedirectAction.Builder clearHostRedirect()
         The host portion of the URL will be swapped with this value.
         
        string host_redirect = 1 [(.validate.rules) = { ... }
        Returns:
        This builder for chaining.
      • setHostRedirectBytes

        public RedirectAction.Builder setHostRedirectBytes​(com.google.protobuf.ByteString value)
         The host portion of the URL will be swapped with this value.
         
        string host_redirect = 1 [(.validate.rules) = { ... }
        Parameters:
        value - The bytes for hostRedirect to set.
        Returns:
        This builder for chaining.
      • getPortRedirect

        public int getPortRedirect()
         The port value of the URL will be swapped with this value.
         
        uint32 port_redirect = 8;
        Specified by:
        getPortRedirect in interface RedirectActionOrBuilder
        Returns:
        The portRedirect.
      • setPortRedirect

        public RedirectAction.Builder setPortRedirect​(int value)
         The port value of the URL will be swapped with this value.
         
        uint32 port_redirect = 8;
        Parameters:
        value - The portRedirect to set.
        Returns:
        This builder for chaining.
      • clearPortRedirect

        public RedirectAction.Builder clearPortRedirect()
         The port value of the URL will be swapped with this value.
         
        uint32 port_redirect = 8;
        Returns:
        This builder for chaining.
      • hasPathRedirect

        public boolean hasPathRedirect()
         The path portion of the URL will be swapped with this value.
         Please note that query string in path_redirect will override the
         request's query string and will not be stripped.
        
         For example, let's say we have the following routes:
        
         - match: { path: "/old-path-1" }
         redirect: { path_redirect: "/new-path-1" }
         - match: { path: "/old-path-2" }
         redirect: { path_redirect: "/new-path-2", strip-query: "true" }
         - match: { path: "/old-path-3" }
         redirect: { path_redirect: "/new-path-3?foo=1", strip_query: "true" }
        
         1. if request uri is "/old-path-1?bar=1", users will be redirected to "/new-path-1?bar=1"
         2. if request uri is "/old-path-2?bar=1", users will be redirected to "/new-path-2"
         3. if request uri is "/old-path-3?bar=1", users will be redirected to "/new-path-3?foo=1"
         
        string path_redirect = 2 [(.validate.rules) = { ... }
        Specified by:
        hasPathRedirect in interface RedirectActionOrBuilder
        Returns:
        Whether the pathRedirect field is set.
      • getPathRedirect

        public java.lang.String getPathRedirect()
         The path portion of the URL will be swapped with this value.
         Please note that query string in path_redirect will override the
         request's query string and will not be stripped.
        
         For example, let's say we have the following routes:
        
         - match: { path: "/old-path-1" }
         redirect: { path_redirect: "/new-path-1" }
         - match: { path: "/old-path-2" }
         redirect: { path_redirect: "/new-path-2", strip-query: "true" }
         - match: { path: "/old-path-3" }
         redirect: { path_redirect: "/new-path-3?foo=1", strip_query: "true" }
        
         1. if request uri is "/old-path-1?bar=1", users will be redirected to "/new-path-1?bar=1"
         2. if request uri is "/old-path-2?bar=1", users will be redirected to "/new-path-2"
         3. if request uri is "/old-path-3?bar=1", users will be redirected to "/new-path-3?foo=1"
         
        string path_redirect = 2 [(.validate.rules) = { ... }
        Specified by:
        getPathRedirect in interface RedirectActionOrBuilder
        Returns:
        The pathRedirect.
      • getPathRedirectBytes

        public com.google.protobuf.ByteString getPathRedirectBytes()
         The path portion of the URL will be swapped with this value.
         Please note that query string in path_redirect will override the
         request's query string and will not be stripped.
        
         For example, let's say we have the following routes:
        
         - match: { path: "/old-path-1" }
         redirect: { path_redirect: "/new-path-1" }
         - match: { path: "/old-path-2" }
         redirect: { path_redirect: "/new-path-2", strip-query: "true" }
         - match: { path: "/old-path-3" }
         redirect: { path_redirect: "/new-path-3?foo=1", strip_query: "true" }
        
         1. if request uri is "/old-path-1?bar=1", users will be redirected to "/new-path-1?bar=1"
         2. if request uri is "/old-path-2?bar=1", users will be redirected to "/new-path-2"
         3. if request uri is "/old-path-3?bar=1", users will be redirected to "/new-path-3?foo=1"
         
        string path_redirect = 2 [(.validate.rules) = { ... }
        Specified by:
        getPathRedirectBytes in interface RedirectActionOrBuilder
        Returns:
        The bytes for pathRedirect.
      • setPathRedirect

        public RedirectAction.Builder setPathRedirect​(java.lang.String value)
         The path portion of the URL will be swapped with this value.
         Please note that query string in path_redirect will override the
         request's query string and will not be stripped.
        
         For example, let's say we have the following routes:
        
         - match: { path: "/old-path-1" }
         redirect: { path_redirect: "/new-path-1" }
         - match: { path: "/old-path-2" }
         redirect: { path_redirect: "/new-path-2", strip-query: "true" }
         - match: { path: "/old-path-3" }
         redirect: { path_redirect: "/new-path-3?foo=1", strip_query: "true" }
        
         1. if request uri is "/old-path-1?bar=1", users will be redirected to "/new-path-1?bar=1"
         2. if request uri is "/old-path-2?bar=1", users will be redirected to "/new-path-2"
         3. if request uri is "/old-path-3?bar=1", users will be redirected to "/new-path-3?foo=1"
         
        string path_redirect = 2 [(.validate.rules) = { ... }
        Parameters:
        value - The pathRedirect to set.
        Returns:
        This builder for chaining.
      • clearPathRedirect

        public RedirectAction.Builder clearPathRedirect()
         The path portion of the URL will be swapped with this value.
         Please note that query string in path_redirect will override the
         request's query string and will not be stripped.
        
         For example, let's say we have the following routes:
        
         - match: { path: "/old-path-1" }
         redirect: { path_redirect: "/new-path-1" }
         - match: { path: "/old-path-2" }
         redirect: { path_redirect: "/new-path-2", strip-query: "true" }
         - match: { path: "/old-path-3" }
         redirect: { path_redirect: "/new-path-3?foo=1", strip_query: "true" }
        
         1. if request uri is "/old-path-1?bar=1", users will be redirected to "/new-path-1?bar=1"
         2. if request uri is "/old-path-2?bar=1", users will be redirected to "/new-path-2"
         3. if request uri is "/old-path-3?bar=1", users will be redirected to "/new-path-3?foo=1"
         
        string path_redirect = 2 [(.validate.rules) = { ... }
        Returns:
        This builder for chaining.
      • setPathRedirectBytes

        public RedirectAction.Builder setPathRedirectBytes​(com.google.protobuf.ByteString value)
         The path portion of the URL will be swapped with this value.
         Please note that query string in path_redirect will override the
         request's query string and will not be stripped.
        
         For example, let's say we have the following routes:
        
         - match: { path: "/old-path-1" }
         redirect: { path_redirect: "/new-path-1" }
         - match: { path: "/old-path-2" }
         redirect: { path_redirect: "/new-path-2", strip-query: "true" }
         - match: { path: "/old-path-3" }
         redirect: { path_redirect: "/new-path-3?foo=1", strip_query: "true" }
        
         1. if request uri is "/old-path-1?bar=1", users will be redirected to "/new-path-1?bar=1"
         2. if request uri is "/old-path-2?bar=1", users will be redirected to "/new-path-2"
         3. if request uri is "/old-path-3?bar=1", users will be redirected to "/new-path-3?foo=1"
         
        string path_redirect = 2 [(.validate.rules) = { ... }
        Parameters:
        value - The bytes for pathRedirect to set.
        Returns:
        This builder for chaining.
      • hasPrefixRewrite

        public boolean hasPrefixRewrite()
         Indicates that during redirection, the matched prefix (or path)
         should be swapped with this value. This option allows redirect URLs be dynamically created
         based on the request.
        
         .. attention::
        
         Pay attention to the use of trailing slashes as mentioned in
         :ref:`RouteAction's prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`.
         
        string prefix_rewrite = 5 [(.validate.rules) = { ... }
        Specified by:
        hasPrefixRewrite in interface RedirectActionOrBuilder
        Returns:
        Whether the prefixRewrite field is set.
      • getPrefixRewrite

        public java.lang.String getPrefixRewrite()
         Indicates that during redirection, the matched prefix (or path)
         should be swapped with this value. This option allows redirect URLs be dynamically created
         based on the request.
        
         .. attention::
        
         Pay attention to the use of trailing slashes as mentioned in
         :ref:`RouteAction's prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`.
         
        string prefix_rewrite = 5 [(.validate.rules) = { ... }
        Specified by:
        getPrefixRewrite in interface RedirectActionOrBuilder
        Returns:
        The prefixRewrite.
      • getPrefixRewriteBytes

        public com.google.protobuf.ByteString getPrefixRewriteBytes()
         Indicates that during redirection, the matched prefix (or path)
         should be swapped with this value. This option allows redirect URLs be dynamically created
         based on the request.
        
         .. attention::
        
         Pay attention to the use of trailing slashes as mentioned in
         :ref:`RouteAction's prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`.
         
        string prefix_rewrite = 5 [(.validate.rules) = { ... }
        Specified by:
        getPrefixRewriteBytes in interface RedirectActionOrBuilder
        Returns:
        The bytes for prefixRewrite.
      • setPrefixRewrite

        public RedirectAction.Builder setPrefixRewrite​(java.lang.String value)
         Indicates that during redirection, the matched prefix (or path)
         should be swapped with this value. This option allows redirect URLs be dynamically created
         based on the request.
        
         .. attention::
        
         Pay attention to the use of trailing slashes as mentioned in
         :ref:`RouteAction's prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`.
         
        string prefix_rewrite = 5 [(.validate.rules) = { ... }
        Parameters:
        value - The prefixRewrite to set.
        Returns:
        This builder for chaining.
      • clearPrefixRewrite

        public RedirectAction.Builder clearPrefixRewrite()
         Indicates that during redirection, the matched prefix (or path)
         should be swapped with this value. This option allows redirect URLs be dynamically created
         based on the request.
        
         .. attention::
        
         Pay attention to the use of trailing slashes as mentioned in
         :ref:`RouteAction's prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`.
         
        string prefix_rewrite = 5 [(.validate.rules) = { ... }
        Returns:
        This builder for chaining.
      • setPrefixRewriteBytes

        public RedirectAction.Builder setPrefixRewriteBytes​(com.google.protobuf.ByteString value)
         Indicates that during redirection, the matched prefix (or path)
         should be swapped with this value. This option allows redirect URLs be dynamically created
         based on the request.
        
         .. attention::
        
         Pay attention to the use of trailing slashes as mentioned in
         :ref:`RouteAction's prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`.
         
        string prefix_rewrite = 5 [(.validate.rules) = { ... }
        Parameters:
        value - The bytes for prefixRewrite to set.
        Returns:
        This builder for chaining.
      • hasRegexRewrite

        public boolean hasRegexRewrite()
         Indicates that during redirect, portions of the path that match the
         pattern should be rewritten, even allowing the substitution of capture
         groups from the pattern into the new path as specified by the rewrite
         substitution string. This is useful to allow application paths to be
         rewritten in a way that is aware of segments with variable content like
         identifiers.
        
         Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
        
         * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
         string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
         into ``/v1/api/instance/foo``.
        
         * The pattern ``one`` paired with a substitution string of ``two`` would
         transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
        
         * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
         ``\1two\2`` would replace only the first occurrence of ``one``,
         transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
        
         * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
         would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
         ``/aaa/yyy/bbb``.
         
        .envoy.type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 9;
        Specified by:
        hasRegexRewrite in interface RedirectActionOrBuilder
        Returns:
        Whether the regexRewrite field is set.
      • getRegexRewrite

        public RegexMatchAndSubstitute getRegexRewrite()
         Indicates that during redirect, portions of the path that match the
         pattern should be rewritten, even allowing the substitution of capture
         groups from the pattern into the new path as specified by the rewrite
         substitution string. This is useful to allow application paths to be
         rewritten in a way that is aware of segments with variable content like
         identifiers.
        
         Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
        
         * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
         string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
         into ``/v1/api/instance/foo``.
        
         * The pattern ``one`` paired with a substitution string of ``two`` would
         transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
        
         * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
         ``\1two\2`` would replace only the first occurrence of ``one``,
         transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
        
         * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
         would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
         ``/aaa/yyy/bbb``.
         
        .envoy.type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 9;
        Specified by:
        getRegexRewrite in interface RedirectActionOrBuilder
        Returns:
        The regexRewrite.
      • setRegexRewrite

        public RedirectAction.Builder setRegexRewrite​(RegexMatchAndSubstitute value)
         Indicates that during redirect, portions of the path that match the
         pattern should be rewritten, even allowing the substitution of capture
         groups from the pattern into the new path as specified by the rewrite
         substitution string. This is useful to allow application paths to be
         rewritten in a way that is aware of segments with variable content like
         identifiers.
        
         Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
        
         * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
         string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
         into ``/v1/api/instance/foo``.
        
         * The pattern ``one`` paired with a substitution string of ``two`` would
         transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
        
         * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
         ``\1two\2`` would replace only the first occurrence of ``one``,
         transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
        
         * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
         would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
         ``/aaa/yyy/bbb``.
         
        .envoy.type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 9;
      • setRegexRewrite

        public RedirectAction.Builder setRegexRewrite​(RegexMatchAndSubstitute.Builder builderForValue)
         Indicates that during redirect, portions of the path that match the
         pattern should be rewritten, even allowing the substitution of capture
         groups from the pattern into the new path as specified by the rewrite
         substitution string. This is useful to allow application paths to be
         rewritten in a way that is aware of segments with variable content like
         identifiers.
        
         Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
        
         * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
         string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
         into ``/v1/api/instance/foo``.
        
         * The pattern ``one`` paired with a substitution string of ``two`` would
         transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
        
         * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
         ``\1two\2`` would replace only the first occurrence of ``one``,
         transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
        
         * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
         would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
         ``/aaa/yyy/bbb``.
         
        .envoy.type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 9;
      • mergeRegexRewrite

        public RedirectAction.Builder mergeRegexRewrite​(RegexMatchAndSubstitute value)
         Indicates that during redirect, portions of the path that match the
         pattern should be rewritten, even allowing the substitution of capture
         groups from the pattern into the new path as specified by the rewrite
         substitution string. This is useful to allow application paths to be
         rewritten in a way that is aware of segments with variable content like
         identifiers.
        
         Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
        
         * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
         string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
         into ``/v1/api/instance/foo``.
        
         * The pattern ``one`` paired with a substitution string of ``two`` would
         transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
        
         * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
         ``\1two\2`` would replace only the first occurrence of ``one``,
         transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
        
         * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
         would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
         ``/aaa/yyy/bbb``.
         
        .envoy.type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 9;
      • clearRegexRewrite

        public RedirectAction.Builder clearRegexRewrite()
         Indicates that during redirect, portions of the path that match the
         pattern should be rewritten, even allowing the substitution of capture
         groups from the pattern into the new path as specified by the rewrite
         substitution string. This is useful to allow application paths to be
         rewritten in a way that is aware of segments with variable content like
         identifiers.
        
         Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
        
         * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
         string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
         into ``/v1/api/instance/foo``.
        
         * The pattern ``one`` paired with a substitution string of ``two`` would
         transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
        
         * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
         ``\1two\2`` would replace only the first occurrence of ``one``,
         transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
        
         * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
         would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
         ``/aaa/yyy/bbb``.
         
        .envoy.type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 9;
      • getRegexRewriteBuilder

        public RegexMatchAndSubstitute.Builder getRegexRewriteBuilder()
         Indicates that during redirect, portions of the path that match the
         pattern should be rewritten, even allowing the substitution of capture
         groups from the pattern into the new path as specified by the rewrite
         substitution string. This is useful to allow application paths to be
         rewritten in a way that is aware of segments with variable content like
         identifiers.
        
         Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
        
         * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
         string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
         into ``/v1/api/instance/foo``.
        
         * The pattern ``one`` paired with a substitution string of ``two`` would
         transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
        
         * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
         ``\1two\2`` would replace only the first occurrence of ``one``,
         transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
        
         * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
         would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
         ``/aaa/yyy/bbb``.
         
        .envoy.type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 9;
      • getRegexRewriteOrBuilder

        public RegexMatchAndSubstituteOrBuilder getRegexRewriteOrBuilder()
         Indicates that during redirect, portions of the path that match the
         pattern should be rewritten, even allowing the substitution of capture
         groups from the pattern into the new path as specified by the rewrite
         substitution string. This is useful to allow application paths to be
         rewritten in a way that is aware of segments with variable content like
         identifiers.
        
         Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
        
         * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
         string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
         into ``/v1/api/instance/foo``.
        
         * The pattern ``one`` paired with a substitution string of ``two`` would
         transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
        
         * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
         ``\1two\2`` would replace only the first occurrence of ``one``,
         transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
        
         * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
         would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
         ``/aaa/yyy/bbb``.
         
        .envoy.type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 9;
        Specified by:
        getRegexRewriteOrBuilder in interface RedirectActionOrBuilder
      • getRegexRewriteFieldBuilder

        private com.google.protobuf.SingleFieldBuilder<RegexMatchAndSubstitute,​RegexMatchAndSubstitute.Builder,​RegexMatchAndSubstituteOrBuilder> getRegexRewriteFieldBuilder()
         Indicates that during redirect, portions of the path that match the
         pattern should be rewritten, even allowing the substitution of capture
         groups from the pattern into the new path as specified by the rewrite
         substitution string. This is useful to allow application paths to be
         rewritten in a way that is aware of segments with variable content like
         identifiers.
        
         Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
        
         * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
         string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
         into ``/v1/api/instance/foo``.
        
         * The pattern ``one`` paired with a substitution string of ``two`` would
         transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
        
         * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
         ``\1two\2`` would replace only the first occurrence of ``one``,
         transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
        
         * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
         would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
         ``/aaa/yyy/bbb``.
         
        .envoy.type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 9;
      • getResponseCodeValue

        public int getResponseCodeValue()
         The HTTP status code to use in the redirect response. The default response
         code is MOVED_PERMANENTLY (301).
         
        .envoy.config.route.v3.RedirectAction.RedirectResponseCode response_code = 3 [(.validate.rules) = { ... }
        Specified by:
        getResponseCodeValue in interface RedirectActionOrBuilder
        Returns:
        The enum numeric value on the wire for responseCode.
      • setResponseCodeValue

        public RedirectAction.Builder setResponseCodeValue​(int value)
         The HTTP status code to use in the redirect response. The default response
         code is MOVED_PERMANENTLY (301).
         
        .envoy.config.route.v3.RedirectAction.RedirectResponseCode response_code = 3 [(.validate.rules) = { ... }
        Parameters:
        value - The enum numeric value on the wire for responseCode to set.
        Returns:
        This builder for chaining.
      • getResponseCode

        public RedirectAction.RedirectResponseCode getResponseCode()
         The HTTP status code to use in the redirect response. The default response
         code is MOVED_PERMANENTLY (301).
         
        .envoy.config.route.v3.RedirectAction.RedirectResponseCode response_code = 3 [(.validate.rules) = { ... }
        Specified by:
        getResponseCode in interface RedirectActionOrBuilder
        Returns:
        The responseCode.
      • setResponseCode

        public RedirectAction.Builder setResponseCode​(RedirectAction.RedirectResponseCode value)
         The HTTP status code to use in the redirect response. The default response
         code is MOVED_PERMANENTLY (301).
         
        .envoy.config.route.v3.RedirectAction.RedirectResponseCode response_code = 3 [(.validate.rules) = { ... }
        Parameters:
        value - The responseCode to set.
        Returns:
        This builder for chaining.
      • clearResponseCode

        public RedirectAction.Builder clearResponseCode()
         The HTTP status code to use in the redirect response. The default response
         code is MOVED_PERMANENTLY (301).
         
        .envoy.config.route.v3.RedirectAction.RedirectResponseCode response_code = 3 [(.validate.rules) = { ... }
        Returns:
        This builder for chaining.
      • getStripQuery

        public boolean getStripQuery()
         Indicates that during redirection, the query portion of the URL will
         be removed. Default value is false.
         
        bool strip_query = 6;
        Specified by:
        getStripQuery in interface RedirectActionOrBuilder
        Returns:
        The stripQuery.
      • setStripQuery

        public RedirectAction.Builder setStripQuery​(boolean value)
         Indicates that during redirection, the query portion of the URL will
         be removed. Default value is false.
         
        bool strip_query = 6;
        Parameters:
        value - The stripQuery to set.
        Returns:
        This builder for chaining.
      • clearStripQuery

        public RedirectAction.Builder clearStripQuery()
         Indicates that during redirection, the query portion of the URL will
         be removed. Default value is false.
         
        bool strip_query = 6;
        Returns:
        This builder for chaining.