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

Go to download
package me.snowdrop.istio.api.model.v1.routing;

import me.snowdrop.istio.api.model.DurationFluentImpl;
import com.fasterxml.jackson.annotation.JsonPropertyDescription;
import com.fasterxml.jackson.annotation.JsonProperty;
import me.snowdrop.istio.api.builder.Nested;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.JsonDeserializer;
import java.lang.Deprecated;
import me.snowdrop.istio.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.model.Duration;
import java.lang.Double;
import java.lang.Integer;
import javax.validation.Valid;
import java.lang.Long;
import java.lang.Object;
import me.snowdrop.istio.api.model.DurationBuilder;

public class TerminateFluentImpl> extends me.snowdrop.istio.api.builder.BaseFluent implements TerminateFluent{

    private Double percent;
    private DurationBuilder terminateAfterPeriod;

    public TerminateFluentImpl(){
    }
    public TerminateFluentImpl(Terminate instance){
            this.withPercent(instance.getPercent()); 
            this.withTerminateAfterPeriod(instance.getTerminateAfterPeriod()); 
    }

    public Double getPercent(){
            return this.percent;
    }

    public A withPercent(Double percent){
            this.percent=percent; return (A) this;
    }

    public Boolean hasPercent(){
            return this.percent != null;
    }

    
/**
 * This method has been deprecated, please use method buildTerminateAfterPeriod instead.
 */
@Deprecated public Duration getTerminateAfterPeriod(){
            return this.terminateAfterPeriod!=null?this.terminateAfterPeriod.build():null;
    }

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

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

    public Boolean hasTerminateAfterPeriod(){
            return this.terminateAfterPeriod != null;
    }

    public A withNewTerminateAfterPeriod(Integer nanos,Long seconds){
            return (A)withTerminateAfterPeriod(new Duration(nanos, seconds));
    }

    public TerminateFluent.TerminateAfterPeriodNested withNewTerminateAfterPeriod(){
            return new TerminateAfterPeriodNestedImpl();
    }

    public TerminateFluent.TerminateAfterPeriodNested withNewTerminateAfterPeriodLike(Duration item){
            return new TerminateAfterPeriodNestedImpl(item);
    }

    public TerminateFluent.TerminateAfterPeriodNested editTerminateAfterPeriod(){
            return withNewTerminateAfterPeriodLike(getTerminateAfterPeriod());
    }

    public TerminateFluent.TerminateAfterPeriodNested editOrNewTerminateAfterPeriod(){
            return withNewTerminateAfterPeriodLike(getTerminateAfterPeriod() != null ? getTerminateAfterPeriod(): new DurationBuilder().build());
    }

    public TerminateFluent.TerminateAfterPeriodNested editOrNewTerminateAfterPeriodLike(Duration item){
            return withNewTerminateAfterPeriodLike(getTerminateAfterPeriod() != null ? getTerminateAfterPeriod(): item);
    }

    public boolean equals(Object o){
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            if (!super.equals(o)) return false;
            TerminateFluentImpl that = (TerminateFluentImpl) o;
            if (percent != null ? !percent.equals(that.percent) :that.percent != null) return false;
            if (terminateAfterPeriod != null ? !terminateAfterPeriod.equals(that.terminateAfterPeriod) :that.terminateAfterPeriod != null) return false;
            return true;
    }


    public class TerminateAfterPeriodNestedImpl extends DurationFluentImpl> implements TerminateFluent.TerminateAfterPeriodNested,me.snowdrop.istio.api.builder.Nested{

            private final DurationBuilder builder;
    
            TerminateAfterPeriodNestedImpl(Duration item){
                    this.builder = new DurationBuilder(this, item);
            }
            TerminateAfterPeriodNestedImpl(){
                    this.builder = new DurationBuilder(this);
            }
    
    public N and(){
            return (N) TerminateFluentImpl.this.withTerminateAfterPeriod(builder.build());
    }
    public N endTerminateAfterPeriod(){
            return and();
    }

}


}