• Home
• me.snowdrop
• istio-model
• 0.1
• source code
• RouteRuleFluentImpl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

annotations.me.snowdrop.istio.api.model.v1.routing.RouteRuleFluentImpl Maven / Gradle / Ivy

package me.snowdrop.istio.api.model.v1.routing;

import com.fasterxml.jackson.annotation.JsonPropertyDescription;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.ArrayList;
import java.lang.String;
import java.util.LinkedHashMap;
import me.snowdrop.istio.api.builder.Predicate;
import me.snowdrop.istio.api.builder.BaseFluent;
import java.util.List;
import java.lang.Boolean;
import javax.validation.Valid;
import java.util.Collection;
import java.lang.Object;
import java.util.Map;
import me.snowdrop.istio.api.builder.Nested;
import java.lang.Deprecated;
import java.lang.Integer;

public class RouteRuleFluentImpl> extends me.snowdrop.istio.api.builder.BaseFluent implements RouteRuleFluent{

    private Map appendHeaders;
    private CorsPolicyBuilder corsPolicy;
    private IstioServiceBuilder destination;
    private HTTPFaultInjectionBuilder httpFault;
    private HTTPRetryBuilder httpReqRetries;
    private HTTPTimeoutBuilder httpReqTimeout;
    private L4FaultInjectionBuilder l4Fault;
    private MatchConditionBuilder match;
    private IstioServiceBuilder mirror;
    private Integer precedence;
    private HTTPRedirectBuilder redirect;
    private HTTPRewriteBuilder rewrite;
    private List route =  new ArrayList();
    private Boolean websocketUpgrade;

    public RouteRuleFluentImpl(){
    }
    public RouteRuleFluentImpl(RouteRule instance){
            this.withAppendHeaders(instance.getAppendHeaders()); 
            this.withCorsPolicy(instance.getCorsPolicy()); 
            this.withDestination(instance.getDestination()); 
            this.withHttpFault(instance.getHttpFault()); 
            this.withHttpReqRetries(instance.getHttpReqRetries()); 
            this.withHttpReqTimeout(instance.getHttpReqTimeout()); 
            this.withL4Fault(instance.getL4Fault()); 
            this.withMatch(instance.getMatch()); 
            this.withMirror(instance.getMirror()); 
            this.withPrecedence(instance.getPrecedence()); 
            this.withRedirect(instance.getRedirect()); 
            this.withRewrite(instance.getRewrite()); 
            this.withRoute(instance.getRoute()); 
            this.withWebsocketUpgrade(instance.getWebsocketUpgrade()); 
    }

    public A addToAppendHeaders(String key,String value){
            if(key != null && value != null) {this.appendHeaders.put(key, value);} return (A)this;
    }

    public A addToAppendHeaders(Map map){
            if(map != null) { this.appendHeaders.putAll(map);} return (A)this;
    }

    public A removeFromAppendHeaders(String key){
            if(key != null && this.appendHeaders != null) {this.appendHeaders.remove(key);} return (A)this;
    }

    public A removeFromAppendHeaders(Map map){
            if(map != null) { for(Object key : map.keySet()) {if (this.appendHeaders != null){this.appendHeaders.remove(key);}}} return (A)this;
    }

    public Map getAppendHeaders(){
            return this.appendHeaders;
    }

    public A withAppendHeaders(Map appendHeaders){
            if (this.appendHeaders == null) { this.appendHeaders = new LinkedHashMap();} else {this.appendHeaders.clear();}
            if (appendHeaders != null) {this.appendHeaders.putAll(appendHeaders);} return (A) this;
    }

    public Boolean hasAppendHeaders(){
            return this.appendHeaders != null;
    }

    
/**
 * This method has been deprecated, please use method buildCorsPolicy instead.
 */
@Deprecated public CorsPolicy getCorsPolicy(){
            return this.corsPolicy!=null?this.corsPolicy.build():null;
    }

    public CorsPolicy buildCorsPolicy(){
            return this.corsPolicy!=null?this.corsPolicy.build():null;
    }

    public A withCorsPolicy(CorsPolicy corsPolicy){
            _visitables.remove(this.corsPolicy);
            if (corsPolicy!=null){ this.corsPolicy= new CorsPolicyBuilder(corsPolicy); _visitables.add(this.corsPolicy);} return (A) this;
    }

    public Boolean hasCorsPolicy(){
            return this.corsPolicy != null;
    }

    public RouteRuleFluent.CorsPolicyNested withNewCorsPolicy(){
            return new CorsPolicyNestedImpl();
    }

    public RouteRuleFluent.CorsPolicyNested withNewCorsPolicyLike(CorsPolicy item){
            return new CorsPolicyNestedImpl(item);
    }

    public RouteRuleFluent.CorsPolicyNested editCorsPolicy(){
            return withNewCorsPolicyLike(getCorsPolicy());
    }

    public RouteRuleFluent.CorsPolicyNested editOrNewCorsPolicy(){
            return withNewCorsPolicyLike(getCorsPolicy() != null ? getCorsPolicy(): new CorsPolicyBuilder().build());
    }

    public RouteRuleFluent.CorsPolicyNested editOrNewCorsPolicyLike(CorsPolicy item){
            return withNewCorsPolicyLike(getCorsPolicy() != null ? getCorsPolicy(): item);
    }

    
/**
 * This method has been deprecated, please use method buildDestination instead.
 */
@Deprecated public IstioService getDestination(){
            return this.destination!=null?this.destination.build():null;
    }

    public IstioService buildDestination(){
            return this.destination!=null?this.destination.build():null;
    }

    public A withDestination(IstioService destination){
            _visitables.remove(this.destination);
            if (destination!=null){ this.destination= new IstioServiceBuilder(destination); _visitables.add(this.destination);} return (A) this;
    }

    public Boolean hasDestination(){
            return this.destination != null;
    }

    public RouteRuleFluent.DestinationNested withNewDestination(){
            return new DestinationNestedImpl();
    }

    public RouteRuleFluent.DestinationNested withNewDestinationLike(IstioService item){
            return new DestinationNestedImpl(item);
    }

    public RouteRuleFluent.DestinationNested editDestination(){
            return withNewDestinationLike(getDestination());
    }

    public RouteRuleFluent.DestinationNested editOrNewDestination(){
            return withNewDestinationLike(getDestination() != null ? getDestination(): new IstioServiceBuilder().build());
    }

    public RouteRuleFluent.DestinationNested editOrNewDestinationLike(IstioService item){
            return withNewDestinationLike(getDestination() != null ? getDestination(): item);
    }

    
/**
 * This method has been deprecated, please use method buildHttpFault instead.
 */
@Deprecated public HTTPFaultInjection getHttpFault(){
            return this.httpFault!=null?this.httpFault.build():null;
    }

    public HTTPFaultInjection buildHttpFault(){
            return this.httpFault!=null?this.httpFault.build():null;
    }

    public A withHttpFault(HTTPFaultInjection httpFault){
            _visitables.remove(this.httpFault);
            if (httpFault!=null){ this.httpFault= new HTTPFaultInjectionBuilder(httpFault); _visitables.add(this.httpFault);} return (A) this;
    }

    public Boolean hasHttpFault(){
            return this.httpFault != null;
    }

    public RouteRuleFluent.HttpFaultNested withNewHttpFault(){
            return new HttpFaultNestedImpl();
    }

    public RouteRuleFluent.HttpFaultNested withNewHttpFaultLike(HTTPFaultInjection item){
            return new HttpFaultNestedImpl(item);
    }

    public RouteRuleFluent.HttpFaultNested editHttpFault(){
            return withNewHttpFaultLike(getHttpFault());
    }

    public RouteRuleFluent.HttpFaultNested editOrNewHttpFault(){
            return withNewHttpFaultLike(getHttpFault() != null ? getHttpFault(): new HTTPFaultInjectionBuilder().build());
    }

    public RouteRuleFluent.HttpFaultNested editOrNewHttpFaultLike(HTTPFaultInjection item){
            return withNewHttpFaultLike(getHttpFault() != null ? getHttpFault(): item);
    }

    
/**
 * This method has been deprecated, please use method buildHttpReqRetries instead.
 */
@Deprecated public HTTPRetry getHttpReqRetries(){
            return this.httpReqRetries!=null?this.httpReqRetries.build():null;
    }

    public HTTPRetry buildHttpReqRetries(){
            return this.httpReqRetries!=null?this.httpReqRetries.build():null;
    }

    public A withHttpReqRetries(HTTPRetry httpReqRetries){
            _visitables.remove(this.httpReqRetries);
            if (httpReqRetries!=null){ this.httpReqRetries= new HTTPRetryBuilder(httpReqRetries); _visitables.add(this.httpReqRetries);} return (A) this;
    }

    public Boolean hasHttpReqRetries(){
            return this.httpReqRetries != null;
    }

    public A withNewHttpReqRetries(Object retryPolicy){
            return (A)withHttpReqRetries(new HTTPRetry(retryPolicy));
    }

    public RouteRuleFluent.HttpReqRetriesNested withNewHttpReqRetries(){
            return new HttpReqRetriesNestedImpl();
    }

    public RouteRuleFluent.HttpReqRetriesNested withNewHttpReqRetriesLike(HTTPRetry item){
            return new HttpReqRetriesNestedImpl(item);
    }

    public RouteRuleFluent.HttpReqRetriesNested editHttpReqRetries(){
            return withNewHttpReqRetriesLike(getHttpReqRetries());
    }

    public RouteRuleFluent.HttpReqRetriesNested editOrNewHttpReqRetries(){
            return withNewHttpReqRetriesLike(getHttpReqRetries() != null ? getHttpReqRetries(): new HTTPRetryBuilder().build());
    }

    public RouteRuleFluent.HttpReqRetriesNested editOrNewHttpReqRetriesLike(HTTPRetry item){
            return withNewHttpReqRetriesLike(getHttpReqRetries() != null ? getHttpReqRetries(): item);
    }

    
/**
 * This method has been deprecated, please use method buildHttpReqTimeout instead.
 */
@Deprecated public HTTPTimeout getHttpReqTimeout(){
            return this.httpReqTimeout!=null?this.httpReqTimeout.build():null;
    }

    public HTTPTimeout buildHttpReqTimeout(){
            return this.httpReqTimeout!=null?this.httpReqTimeout.build():null;
    }

    public A withHttpReqTimeout(HTTPTimeout httpReqTimeout){
            _visitables.remove(this.httpReqTimeout);
            if (httpReqTimeout!=null){ this.httpReqTimeout= new HTTPTimeoutBuilder(httpReqTimeout); _visitables.add(this.httpReqTimeout);} return (A) this;
    }

    public Boolean hasHttpReqTimeout(){
            return this.httpReqTimeout != null;
    }

    public A withNewHttpReqTimeout(Object timeoutPolicy){
            return (A)withHttpReqTimeout(new HTTPTimeout(timeoutPolicy));
    }

    public RouteRuleFluent.HttpReqTimeoutNested withNewHttpReqTimeout(){
            return new HttpReqTimeoutNestedImpl();
    }

    public RouteRuleFluent.HttpReqTimeoutNested withNewHttpReqTimeoutLike(HTTPTimeout item){
            return new HttpReqTimeoutNestedImpl(item);
    }

    public RouteRuleFluent.HttpReqTimeoutNested editHttpReqTimeout(){
            return withNewHttpReqTimeoutLike(getHttpReqTimeout());
    }

    public RouteRuleFluent.HttpReqTimeoutNested editOrNewHttpReqTimeout(){
            return withNewHttpReqTimeoutLike(getHttpReqTimeout() != null ? getHttpReqTimeout(): new HTTPTimeoutBuilder().build());
    }

    public RouteRuleFluent.HttpReqTimeoutNested editOrNewHttpReqTimeoutLike(HTTPTimeout item){
            return withNewHttpReqTimeoutLike(getHttpReqTimeout() != null ? getHttpReqTimeout(): item);
    }

    
/**
 * This method has been deprecated, please use method buildL4Fault instead.
 */
@Deprecated public L4FaultInjection getL4Fault(){
            return this.l4Fault!=null?this.l4Fault.build():null;
    }

    public L4FaultInjection buildL4Fault(){
            return this.l4Fault!=null?this.l4Fault.build():null;
    }

    public A withL4Fault(L4FaultInjection l4Fault){
            _visitables.remove(this.l4Fault);
            if (l4Fault!=null){ this.l4Fault= new L4FaultInjectionBuilder(l4Fault); _visitables.add(this.l4Fault);} return (A) this;
    }

    public Boolean hasL4Fault(){
            return this.l4Fault != null;
    }

    public RouteRuleFluent.L4FaultNested withNewL4Fault(){
            return new L4FaultNestedImpl();
    }

    public RouteRuleFluent.L4FaultNested withNewL4FaultLike(L4FaultInjection item){
            return new L4FaultNestedImpl(item);
    }

    public RouteRuleFluent.L4FaultNested editL4Fault(){
            return withNewL4FaultLike(getL4Fault());
    }

    public RouteRuleFluent.L4FaultNested editOrNewL4Fault(){
            return withNewL4FaultLike(getL4Fault() != null ? getL4Fault(): new L4FaultInjectionBuilder().build());
    }

    public RouteRuleFluent.L4FaultNested editOrNewL4FaultLike(L4FaultInjection item){
            return withNewL4FaultLike(getL4Fault() != null ? getL4Fault(): item);
    }

    
/**
 * This method has been deprecated, please use method buildMatch instead.
 */
@Deprecated public MatchCondition getMatch(){
            return this.match!=null?this.match.build():null;
    }

    public MatchCondition buildMatch(){
            return this.match!=null?this.match.build():null;
    }

    public A withMatch(MatchCondition match){
            _visitables.remove(this.match);
            if (match!=null){ this.match= new MatchConditionBuilder(match); _visitables.add(this.match);} return (A) this;
    }

    public Boolean hasMatch(){
            return this.match != null;
    }

    public RouteRuleFluent.MatchNested withNewMatch(){
            return new MatchNestedImpl();
    }

    public RouteRuleFluent.MatchNested withNewMatchLike(MatchCondition item){
            return new MatchNestedImpl(item);
    }

    public RouteRuleFluent.MatchNested editMatch(){
            return withNewMatchLike(getMatch());
    }

    public RouteRuleFluent.MatchNested editOrNewMatch(){
            return withNewMatchLike(getMatch() != null ? getMatch(): new MatchConditionBuilder().build());
    }

    public RouteRuleFluent.MatchNested editOrNewMatchLike(MatchCondition item){
            return withNewMatchLike(getMatch() != null ? getMatch(): item);
    }

    
/**
 * This method has been deprecated, please use method buildMirror instead.
 */
@Deprecated public IstioService getMirror(){
            return this.mirror!=null?this.mirror.build():null;
    }

    public IstioService buildMirror(){
            return this.mirror!=null?this.mirror.build():null;
    }

    public A withMirror(IstioService mirror){
            _visitables.remove(this.mirror);
            if (mirror!=null){ this.mirror= new IstioServiceBuilder(mirror); _visitables.add(this.mirror);} return (A) this;
    }

    public Boolean hasMirror(){
            return this.mirror != null;
    }

    public RouteRuleFluent.MirrorNested withNewMirror(){
            return new MirrorNestedImpl();
    }

    public RouteRuleFluent.MirrorNested withNewMirrorLike(IstioService item){
            return new MirrorNestedImpl(item);
    }

    public RouteRuleFluent.MirrorNested editMirror(){
            return withNewMirrorLike(getMirror());
    }

    public RouteRuleFluent.MirrorNested editOrNewMirror(){
            return withNewMirrorLike(getMirror() != null ? getMirror(): new IstioServiceBuilder().build());
    }

    public RouteRuleFluent.MirrorNested editOrNewMirrorLike(IstioService item){
            return withNewMirrorLike(getMirror() != null ? getMirror(): item);
    }

    public Integer getPrecedence(){
            return this.precedence;
    }

    public A withPrecedence(Integer precedence){
            this.precedence=precedence; return (A) this;
    }

    public Boolean hasPrecedence(){
            return this.precedence != null;
    }

    
/**
 * This method has been deprecated, please use method buildRedirect instead.
 */
@Deprecated public HTTPRedirect getRedirect(){
            return this.redirect!=null?this.redirect.build():null;
    }

    public HTTPRedirect buildRedirect(){
            return this.redirect!=null?this.redirect.build():null;
    }

    public A withRedirect(HTTPRedirect redirect){
            _visitables.remove(this.redirect);
            if (redirect!=null){ this.redirect= new HTTPRedirectBuilder(redirect); _visitables.add(this.redirect);} return (A) this;
    }

    public Boolean hasRedirect(){
            return this.redirect != null;
    }

    public A withNewRedirect(String authority,String uri){
            return (A)withRedirect(new HTTPRedirect(authority, uri));
    }

    public RouteRuleFluent.RedirectNested withNewRedirect(){
            return new RedirectNestedImpl();
    }

    public RouteRuleFluent.RedirectNested withNewRedirectLike(HTTPRedirect item){
            return new RedirectNestedImpl(item);
    }

    public RouteRuleFluent.RedirectNested editRedirect(){
            return withNewRedirectLike(getRedirect());
    }

    public RouteRuleFluent.RedirectNested editOrNewRedirect(){
            return withNewRedirectLike(getRedirect() != null ? getRedirect(): new HTTPRedirectBuilder().build());
    }

    public RouteRuleFluent.RedirectNested editOrNewRedirectLike(HTTPRedirect item){
            return withNewRedirectLike(getRedirect() != null ? getRedirect(): item);
    }

    
/**
 * This method has been deprecated, please use method buildRewrite instead.
 */
@Deprecated public HTTPRewrite getRewrite(){
            return this.rewrite!=null?this.rewrite.build():null;
    }

    public HTTPRewrite buildRewrite(){
            return this.rewrite!=null?this.rewrite.build():null;
    }

    public A withRewrite(HTTPRewrite rewrite){
            _visitables.remove(this.rewrite);
            if (rewrite!=null){ this.rewrite= new HTTPRewriteBuilder(rewrite); _visitables.add(this.rewrite);} return (A) this;
    }

    public Boolean hasRewrite(){
            return this.rewrite != null;
    }

    public A withNewRewrite(String authority,String uri){
            return (A)withRewrite(new HTTPRewrite(authority, uri));
    }

    public RouteRuleFluent.RewriteNested withNewRewrite(){
            return new RewriteNestedImpl();
    }

    public RouteRuleFluent.RewriteNested withNewRewriteLike(HTTPRewrite item){
            return new RewriteNestedImpl(item);
    }

    public RouteRuleFluent.RewriteNested editRewrite(){
            return withNewRewriteLike(getRewrite());
    }

    public RouteRuleFluent.RewriteNested editOrNewRewrite(){
            return withNewRewriteLike(getRewrite() != null ? getRewrite(): new HTTPRewriteBuilder().build());
    }

    public RouteRuleFluent.RewriteNested editOrNewRewriteLike(HTTPRewrite item){
            return withNewRewriteLike(getRewrite() != null ? getRewrite(): item);
    }

    public A addToRoute(int index,DestinationWeight item){
            if (this.route == null) {this.route = new ArrayList();}
            DestinationWeightBuilder builder = new DestinationWeightBuilder(item);_visitables.add(index >= 0 ? index : _visitables.size(), builder);this.route.add(index >= 0 ? index : route.size(), builder); return (A)this;
    }

    public A setToRoute(int index,DestinationWeight item){
            if (this.route == null) {this.route = new ArrayList();}
            DestinationWeightBuilder builder = new DestinationWeightBuilder(item);
            if (index < 0 || index >= _visitables.size()) { _visitables.add(builder); } else { _visitables.set(index, builder);}
            if (index < 0 || index >= route.size()) { route.add(builder); } else { route.set(index, builder);}
             return (A)this;
    }

    public A addToRoute(DestinationWeight... items){
            if (this.route == null) {this.route = new ArrayList();}
            for (DestinationWeight item : items) {DestinationWeightBuilder builder = new DestinationWeightBuilder(item);_visitables.add(builder);this.route.add(builder);} return (A)this;
    }

    public A addAllToRoute(Collection items){
            if (this.route == null) {this.route = new ArrayList();}
            for (DestinationWeight item : items) {DestinationWeightBuilder builder = new DestinationWeightBuilder(item);_visitables.add(builder);this.route.add(builder);} return (A)this;
    }

    public A removeFromRoute(DestinationWeight... items){
            for (DestinationWeight item : items) {DestinationWeightBuilder builder = new DestinationWeightBuilder(item);_visitables.remove(builder);if (this.route != null) {this.route.remove(builder);}} return (A)this;
    }

    public A removeAllFromRoute(Collection items){
            for (DestinationWeight item : items) {DestinationWeightBuilder builder = new DestinationWeightBuilder(item);_visitables.remove(builder);if (this.route != null) {this.route.remove(builder);}} return (A)this;
    }

    
/**
 * This method has been deprecated, please use method buildRoute instead.
 */
@Deprecated public List getRoute(){
            return build(route);
    }

    public List buildRoute(){
            return build(route);
    }

    public DestinationWeight buildRoute(int index){
            return this.route.get(index).build();
    }

    public DestinationWeight buildFirstRoute(){
            return this.route.get(0).build();
    }

    public DestinationWeight buildLastRoute(){
            return this.route.get(route.size() - 1).build();
    }

    public DestinationWeight buildMatchingRoute(me.snowdrop.istio.api.builder.Predicate predicate){
            for (DestinationWeightBuilder item: route) { if(predicate.apply(item)){return item.build();} } return null;
    }

    public A withRoute(List route){
            if (this.route == null) { this.route = new ArrayList();} else {_visitables.removeAll(this.route); this.route.clear();}
            if (route != null) {for (DestinationWeight item : route){this.addToRoute(item);}} return (A) this;
    }

    public A withRoute(DestinationWeight... route){
            this.route.clear(); if (route != null) {for (DestinationWeight item :route){ this.addToRoute(item);}} return (A) this;
    }

    public Boolean hasRoute(){
            return route != null && !route.isEmpty();
    }

    public RouteRuleFluent.RouteNested addNewRoute(){
            return new RouteNestedImpl();
    }

    public RouteRuleFluent.RouteNested addNewRouteLike(DestinationWeight item){
            return new RouteNestedImpl(-1, item);
    }

    public RouteRuleFluent.RouteNested setNewRouteLike(int index,DestinationWeight item){
            return new RouteNestedImpl(index, item);
    }

    public RouteRuleFluent.RouteNested editRoute(int index){
            if (route.size() <= index) throw new RuntimeException("Can't edit route. Index exceeds size.");
            return setNewRouteLike(index, buildRoute(index));
    }

    public RouteRuleFluent.RouteNested editFirstRoute(){
            if (route.size() == 0) throw new RuntimeException("Can't edit first route. The list is empty.");
            return setNewRouteLike(0, buildRoute(0));
    }

    public RouteRuleFluent.RouteNested editLastRoute(){
            int index = route.size() - 1;
            if (index < 0) throw new RuntimeException("Can't edit last route. The list is empty.");
            return setNewRouteLike(index, buildRoute(index));
    }

    public RouteRuleFluent.RouteNested editMatchingRoute(me.snowdrop.istio.api.builder.Predicate predicate){
            int index = -1;
            for (int i=0;i extends CorsPolicyFluentImpl> implements RouteRuleFluent.CorsPolicyNested,me.snowdrop.istio.api.builder.Nested{

            private final CorsPolicyBuilder builder;
    
            CorsPolicyNestedImpl(CorsPolicy item){
                    this.builder = new CorsPolicyBuilder(this, item);
            }
            CorsPolicyNestedImpl(){
                    this.builder = new CorsPolicyBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.withCorsPolicy(builder.build());
    }
    public N endCorsPolicy(){
            return and();
    }

}
    public class DestinationNestedImpl extends IstioServiceFluentImpl> implements RouteRuleFluent.DestinationNested,me.snowdrop.istio.api.builder.Nested{

            private final IstioServiceBuilder builder;
    
            DestinationNestedImpl(IstioService item){
                    this.builder = new IstioServiceBuilder(this, item);
            }
            DestinationNestedImpl(){
                    this.builder = new IstioServiceBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.withDestination(builder.build());
    }
    public N endDestination(){
            return and();
    }

}
    public class HttpFaultNestedImpl extends HTTPFaultInjectionFluentImpl> implements RouteRuleFluent.HttpFaultNested,me.snowdrop.istio.api.builder.Nested{

            private final HTTPFaultInjectionBuilder builder;
    
            HttpFaultNestedImpl(HTTPFaultInjection item){
                    this.builder = new HTTPFaultInjectionBuilder(this, item);
            }
            HttpFaultNestedImpl(){
                    this.builder = new HTTPFaultInjectionBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.withHttpFault(builder.build());
    }
    public N endHttpFault(){
            return and();
    }

}
    public class HttpReqRetriesNestedImpl extends HTTPRetryFluentImpl> implements RouteRuleFluent.HttpReqRetriesNested,me.snowdrop.istio.api.builder.Nested{

            private final HTTPRetryBuilder builder;
    
            HttpReqRetriesNestedImpl(HTTPRetry item){
                    this.builder = new HTTPRetryBuilder(this, item);
            }
            HttpReqRetriesNestedImpl(){
                    this.builder = new HTTPRetryBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.withHttpReqRetries(builder.build());
    }
    public N endHttpReqRetries(){
            return and();
    }

}
    public class HttpReqTimeoutNestedImpl extends HTTPTimeoutFluentImpl> implements RouteRuleFluent.HttpReqTimeoutNested,me.snowdrop.istio.api.builder.Nested{

            private final HTTPTimeoutBuilder builder;
    
            HttpReqTimeoutNestedImpl(HTTPTimeout item){
                    this.builder = new HTTPTimeoutBuilder(this, item);
            }
            HttpReqTimeoutNestedImpl(){
                    this.builder = new HTTPTimeoutBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.withHttpReqTimeout(builder.build());
    }
    public N endHttpReqTimeout(){
            return and();
    }

}
    public class L4FaultNestedImpl extends L4FaultInjectionFluentImpl> implements RouteRuleFluent.L4FaultNested,me.snowdrop.istio.api.builder.Nested{

            private final L4FaultInjectionBuilder builder;
    
            L4FaultNestedImpl(L4FaultInjection item){
                    this.builder = new L4FaultInjectionBuilder(this, item);
            }
            L4FaultNestedImpl(){
                    this.builder = new L4FaultInjectionBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.withL4Fault(builder.build());
    }
    public N endL4Fault(){
            return and();
    }

}
    public class MatchNestedImpl extends MatchConditionFluentImpl> implements RouteRuleFluent.MatchNested,me.snowdrop.istio.api.builder.Nested{

            private final MatchConditionBuilder builder;
    
            MatchNestedImpl(MatchCondition item){
                    this.builder = new MatchConditionBuilder(this, item);
            }
            MatchNestedImpl(){
                    this.builder = new MatchConditionBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.withMatch(builder.build());
    }
    public N endMatch(){
            return and();
    }

}
    public class MirrorNestedImpl extends IstioServiceFluentImpl> implements RouteRuleFluent.MirrorNested,me.snowdrop.istio.api.builder.Nested{

            private final IstioServiceBuilder builder;
    
            MirrorNestedImpl(IstioService item){
                    this.builder = new IstioServiceBuilder(this, item);
            }
            MirrorNestedImpl(){
                    this.builder = new IstioServiceBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.withMirror(builder.build());
    }
    public N endMirror(){
            return and();
    }

}
    public class RedirectNestedImpl extends HTTPRedirectFluentImpl> implements RouteRuleFluent.RedirectNested,me.snowdrop.istio.api.builder.Nested{

            private final HTTPRedirectBuilder builder;
    
            RedirectNestedImpl(HTTPRedirect item){
                    this.builder = new HTTPRedirectBuilder(this, item);
            }
            RedirectNestedImpl(){
                    this.builder = new HTTPRedirectBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.withRedirect(builder.build());
    }
    public N endRedirect(){
            return and();
    }

}
    public class RewriteNestedImpl extends HTTPRewriteFluentImpl> implements RouteRuleFluent.RewriteNested,me.snowdrop.istio.api.builder.Nested{

            private final HTTPRewriteBuilder builder;
    
            RewriteNestedImpl(HTTPRewrite item){
                    this.builder = new HTTPRewriteBuilder(this, item);
            }
            RewriteNestedImpl(){
                    this.builder = new HTTPRewriteBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.withRewrite(builder.build());
    }
    public N endRewrite(){
            return and();
    }

}
    public class RouteNestedImpl extends DestinationWeightFluentImpl> implements RouteRuleFluent.RouteNested,me.snowdrop.istio.api.builder.Nested{

            private final DestinationWeightBuilder builder;
        private final int index;
    
            RouteNestedImpl(int index,DestinationWeight item){
                    this.index = index;
                    this.builder = new DestinationWeightBuilder(this, item);
            }
            RouteNestedImpl(){
                    this.index = -1;
                    this.builder = new DestinationWeightBuilder(this);
            }
    
    public N and(){
            return (N) RouteRuleFluentImpl.this.setToRoute(index, builder.build());
    }
    public N endRoute(){
            return and();
    }

}


}