me.snowdrop.istio.api.networking.v1alpha3.OutlierDetectionFluentImpl Maven / Gradle / Ivy

Go to download
package me.snowdrop.istio.api.networking.v1alpha3;

import me.snowdrop.istio.api.DurationFluentImpl;
import com.fasterxml.jackson.annotation.JsonPropertyDescription;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.fabric8.kubernetes.api.builder.Nested;
import com.fasterxml.jackson.databind.JsonSerializer;
import java.lang.String;
import com.fasterxml.jackson.databind.JsonDeserializer;
import java.lang.Deprecated;
import io.fabric8.kubernetes.api.builder.BaseFluent;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.lang.Boolean;
import java.lang.Override;
import com.fasterxml.jackson.core.JsonParser;
import me.snowdrop.istio.api.Duration;
import java.lang.Integer;
import javax.validation.Valid;
import java.lang.Long;
import java.lang.Object;
import me.snowdrop.istio.api.DurationBuilder;

public class OutlierDetectionFluentImpl> extends io.fabric8.kubernetes.api.builder.BaseFluent implements OutlierDetectionFluent{

    private DurationBuilder baseEjectionTime;
    private Integer consecutiveErrors;
    private DurationBuilder interval;
    private Integer maxEjectionPercent;

    public OutlierDetectionFluentImpl(){
    }
    public OutlierDetectionFluentImpl(OutlierDetection instance){
            this.withBaseEjectionTime(instance.getBaseEjectionTime()); 
            this.withConsecutiveErrors(instance.getConsecutiveErrors()); 
            this.withInterval(instance.getInterval()); 
            this.withMaxEjectionPercent(instance.getMaxEjectionPercent()); 
    }

    
/**
 * This method has been deprecated, please use method buildBaseEjectionTime instead.
 * @return The buildable object.
 */
@Deprecated public Duration getBaseEjectionTime(){
            return this.baseEjectionTime!=null?this.baseEjectionTime.build():null;
    }

    public Duration buildBaseEjectionTime(){
            return this.baseEjectionTime!=null?this.baseEjectionTime.build():null;
    }

    public A withBaseEjectionTime(Duration baseEjectionTime){
            _visitables.remove(this.baseEjectionTime);
            if (baseEjectionTime!=null){ this.baseEjectionTime= new DurationBuilder(baseEjectionTime); _visitables.add(this.baseEjectionTime);} return (A) this;
    }

    public Boolean hasBaseEjectionTime(){
            return this.baseEjectionTime != null;
    }

    public A withNewBaseEjectionTime(Integer nanos,Long seconds){
            return (A)withBaseEjectionTime(new Duration(nanos, seconds));
    }

    public OutlierDetectionFluent.BaseEjectionTimeNested withNewBaseEjectionTime(){
            return new BaseEjectionTimeNestedImpl();
    }

    public OutlierDetectionFluent.BaseEjectionTimeNested withNewBaseEjectionTimeLike(Duration item){
            return new BaseEjectionTimeNestedImpl(item);
    }

    public OutlierDetectionFluent.BaseEjectionTimeNested editBaseEjectionTime(){
            return withNewBaseEjectionTimeLike(getBaseEjectionTime());
    }

    public OutlierDetectionFluent.BaseEjectionTimeNested editOrNewBaseEjectionTime(){
            return withNewBaseEjectionTimeLike(getBaseEjectionTime() != null ? getBaseEjectionTime(): new DurationBuilder().build());
    }

    public OutlierDetectionFluent.BaseEjectionTimeNested editOrNewBaseEjectionTimeLike(Duration item){
            return withNewBaseEjectionTimeLike(getBaseEjectionTime() != null ? getBaseEjectionTime(): item);
    }

    public Integer getConsecutiveErrors(){
            return this.consecutiveErrors;
    }

    public A withConsecutiveErrors(Integer consecutiveErrors){
            this.consecutiveErrors=consecutiveErrors; return (A) this;
    }

    public Boolean hasConsecutiveErrors(){
            return this.consecutiveErrors != null;
    }

    public A withNewConsecutiveErrors(String arg1){
            return (A)withConsecutiveErrors(new Integer(arg1));
    }

    public A withNewConsecutiveErrors(int arg1){
            return (A)withConsecutiveErrors(new Integer(arg1));
    }

    
/**
 * This method has been deprecated, please use method buildInterval instead.
 * @return The buildable object.
 */
@Deprecated public Duration getInterval(){
            return this.interval!=null?this.interval.build():null;
    }

    public Duration buildInterval(){
            return this.interval!=null?this.interval.build():null;
    }

    public A withInterval(Duration interval){
            _visitables.remove(this.interval);
            if (interval!=null){ this.interval= new DurationBuilder(interval); _visitables.add(this.interval);} return (A) this;
    }

    public Boolean hasInterval(){
            return this.interval != null;
    }

    public A withNewInterval(Integer nanos,Long seconds){
            return (A)withInterval(new Duration(nanos, seconds));
    }

    public OutlierDetectionFluent.IntervalNested withNewInterval(){
            return new IntervalNestedImpl();
    }

    public OutlierDetectionFluent.IntervalNested withNewIntervalLike(Duration item){
            return new IntervalNestedImpl(item);
    }

    public OutlierDetectionFluent.IntervalNested editInterval(){
            return withNewIntervalLike(getInterval());
    }

    public OutlierDetectionFluent.IntervalNested editOrNewInterval(){
            return withNewIntervalLike(getInterval() != null ? getInterval(): new DurationBuilder().build());
    }

    public OutlierDetectionFluent.IntervalNested editOrNewIntervalLike(Duration item){
            return withNewIntervalLike(getInterval() != null ? getInterval(): item);
    }

    public Integer getMaxEjectionPercent(){
            return this.maxEjectionPercent;
    }

    public A withMaxEjectionPercent(Integer maxEjectionPercent){
            this.maxEjectionPercent=maxEjectionPercent; return (A) this;
    }

    public Boolean hasMaxEjectionPercent(){
            return this.maxEjectionPercent != null;
    }

    public A withNewMaxEjectionPercent(String arg1){
            return (A)withMaxEjectionPercent(new Integer(arg1));
    }

    public A withNewMaxEjectionPercent(int arg1){
            return (A)withMaxEjectionPercent(new Integer(arg1));
    }

    public boolean equals(Object o){
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            if (!super.equals(o)) return false;
            OutlierDetectionFluentImpl that = (OutlierDetectionFluentImpl) o;
            if (baseEjectionTime != null ? !baseEjectionTime.equals(that.baseEjectionTime) :that.baseEjectionTime != null) return false;
            if (consecutiveErrors != null ? !consecutiveErrors.equals(that.consecutiveErrors) :that.consecutiveErrors != null) return false;
            if (interval != null ? !interval.equals(that.interval) :that.interval != null) return false;
            if (maxEjectionPercent != null ? !maxEjectionPercent.equals(that.maxEjectionPercent) :that.maxEjectionPercent != null) return false;
            return true;
    }


    public class BaseEjectionTimeNestedImpl extends DurationFluentImpl> implements OutlierDetectionFluent.BaseEjectionTimeNested,io.fabric8.kubernetes.api.builder.Nested{

            private final DurationBuilder builder;
    
            BaseEjectionTimeNestedImpl(Duration item){
                    this.builder = new DurationBuilder(this, item);
            }
            BaseEjectionTimeNestedImpl(){
                    this.builder = new DurationBuilder(this);
            }
    
    public N and(){
            return (N) OutlierDetectionFluentImpl.this.withBaseEjectionTime(builder.build());
    }
    public N endBaseEjectionTime(){
            return and();
    }

}
    public class IntervalNestedImpl extends DurationFluentImpl> implements OutlierDetectionFluent.IntervalNested,io.fabric8.kubernetes.api.builder.Nested{

            private final DurationBuilder builder;
    
            IntervalNestedImpl(Duration item){
                    this.builder = new DurationBuilder(this, item);
            }
            IntervalNestedImpl(){
                    this.builder = new DurationBuilder(this);
            }
    
    public N and(){
            return (N) OutlierDetectionFluentImpl.this.withInterval(builder.build());
    }
    public N endInterval(){
            return and();
    }

}


}