annotations.io.fabric8.openshift.api.model.RollingDeploymentStrategyParamsFluentImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of kubernetes-model Show documentation
There is a newer version: 4.1.1
package io.fabric8.openshift.api.model;

import io.fabric8.kubernetes.api.builder.BaseFluent;
import java.lang.Long;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.fabric8.kubernetes.api.builder.VisitableBuilder;
import javax.validation.Valid;
import java.lang.Integer;
import io.fabric8.kubernetes.api.model.IntOrString;
import java.lang.String;
import java.lang.Object;
import io.fabric8.kubernetes.api.builder.Nested;
import io.fabric8.kubernetes.api.model.IntOrStringFluentImpl;
import io.fabric8.kubernetes.api.model.IntOrStringBuilder;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.lang.Override;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;

public class RollingDeploymentStrategyParamsFluentImpl> extends BaseFluent implements RollingDeploymentStrategyParamsFluent{

    private Long intervalSeconds;
    private VisitableBuilder maxSurge;
    private VisitableBuilder maxUnavailable;
    private VisitableBuilder post;
    private VisitableBuilder pre;
    private Long timeoutSeconds;
    private Integer updatePercent;
    private Long updatePeriodSeconds;

    public RollingDeploymentStrategyParamsFluentImpl(){
    }
    public RollingDeploymentStrategyParamsFluentImpl(RollingDeploymentStrategyParams instance){
            this.withIntervalSeconds(instance.getIntervalSeconds()); 
            this.withMaxSurge(instance.getMaxSurge()); 
            this.withMaxUnavailable(instance.getMaxUnavailable()); 
            this.withPost(instance.getPost()); 
            this.withPre(instance.getPre()); 
            this.withTimeoutSeconds(instance.getTimeoutSeconds()); 
            this.withUpdatePercent(instance.getUpdatePercent()); 
            this.withUpdatePeriodSeconds(instance.getUpdatePeriodSeconds()); 
    }

    public Long getIntervalSeconds(){
            return this.intervalSeconds;
    }

    public A withIntervalSeconds(Long intervalSeconds){
            this.intervalSeconds=intervalSeconds; return (A) this;
    }

    public IntOrString getMaxSurge(){
            return this.maxSurge!=null?this.maxSurge.build():null;
    }

    public A withMaxSurge(IntOrString maxSurge){
            if (maxSurge!=null){ this.maxSurge= new IntOrStringBuilder(maxSurge); _visitables.add(this.maxSurge);} return (A) this;
    }

    public RollingDeploymentStrategyParamsFluent.MaxSurgeNested withNewMaxSurge(){
            return new MaxSurgeNestedImpl();
    }

    public RollingDeploymentStrategyParamsFluent.MaxSurgeNested withNewMaxSurgeLike(IntOrString item){
            return new MaxSurgeNestedImpl(item);
    }

    public RollingDeploymentStrategyParamsFluent.MaxSurgeNested editMaxSurge(){
            return withNewMaxSurgeLike(getMaxSurge());
    }

    public A withNewMaxSurge(String strVal){
            return (A)withMaxSurge(new IntOrString(strVal));
    }

    public A withNewMaxSurge(Integer intVal){
            return (A)withMaxSurge(new IntOrString(intVal));
    }

    public IntOrString getMaxUnavailable(){
            return this.maxUnavailable!=null?this.maxUnavailable.build():null;
    }

    public A withMaxUnavailable(IntOrString maxUnavailable){
            if (maxUnavailable!=null){ this.maxUnavailable= new IntOrStringBuilder(maxUnavailable); _visitables.add(this.maxUnavailable);} return (A) this;
    }

    public RollingDeploymentStrategyParamsFluent.MaxUnavailableNested withNewMaxUnavailable(){
            return new MaxUnavailableNestedImpl();
    }

    public RollingDeploymentStrategyParamsFluent.MaxUnavailableNested withNewMaxUnavailableLike(IntOrString item){
            return new MaxUnavailableNestedImpl(item);
    }

    public RollingDeploymentStrategyParamsFluent.MaxUnavailableNested editMaxUnavailable(){
            return withNewMaxUnavailableLike(getMaxUnavailable());
    }

    public A withNewMaxUnavailable(String strVal){
            return (A)withMaxUnavailable(new IntOrString(strVal));
    }

    public A withNewMaxUnavailable(Integer intVal){
            return (A)withMaxUnavailable(new IntOrString(intVal));
    }

    public LifecycleHook getPost(){
            return this.post!=null?this.post.build():null;
    }

    public A withPost(LifecycleHook post){
            if (post!=null){ this.post= new LifecycleHookBuilder(post); _visitables.add(this.post);} return (A) this;
    }

    public RollingDeploymentStrategyParamsFluent.PostNested withNewPost(){
            return new PostNestedImpl();
    }

    public RollingDeploymentStrategyParamsFluent.PostNested withNewPostLike(LifecycleHook item){
            return new PostNestedImpl(item);
    }

    public RollingDeploymentStrategyParamsFluent.PostNested editPost(){
            return withNewPostLike(getPost());
    }

    public LifecycleHook getPre(){
            return this.pre!=null?this.pre.build():null;
    }

    public A withPre(LifecycleHook pre){
            if (pre!=null){ this.pre= new LifecycleHookBuilder(pre); _visitables.add(this.pre);} return (A) this;
    }

    public RollingDeploymentStrategyParamsFluent.PreNested withNewPre(){
            return new PreNestedImpl();
    }

    public RollingDeploymentStrategyParamsFluent.PreNested withNewPreLike(LifecycleHook item){
            return new PreNestedImpl(item);
    }

    public RollingDeploymentStrategyParamsFluent.PreNested editPre(){
            return withNewPreLike(getPre());
    }

    public Long getTimeoutSeconds(){
            return this.timeoutSeconds;
    }

    public A withTimeoutSeconds(Long timeoutSeconds){
            this.timeoutSeconds=timeoutSeconds; return (A) this;
    }

    public Integer getUpdatePercent(){
            return this.updatePercent;
    }

    public A withUpdatePercent(Integer updatePercent){
            this.updatePercent=updatePercent; return (A) this;
    }

    public Long getUpdatePeriodSeconds(){
            return this.updatePeriodSeconds;
    }

    public A withUpdatePeriodSeconds(Long updatePeriodSeconds){
            this.updatePeriodSeconds=updatePeriodSeconds; return (A) this;
    }

    public boolean equals(Object o){
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            if (!super.equals(o)) return false;
            RollingDeploymentStrategyParamsFluentImpl that = (RollingDeploymentStrategyParamsFluentImpl) o;
            if (intervalSeconds != null ? !intervalSeconds.equals(that.intervalSeconds) :that.intervalSeconds != null) return false;
            if (maxSurge != null ? !maxSurge.equals(that.maxSurge) :that.maxSurge != null) return false;
            if (maxUnavailable != null ? !maxUnavailable.equals(that.maxUnavailable) :that.maxUnavailable != null) return false;
            if (post != null ? !post.equals(that.post) :that.post != null) return false;
            if (pre != null ? !pre.equals(that.pre) :that.pre != null) return false;
            if (timeoutSeconds != null ? !timeoutSeconds.equals(that.timeoutSeconds) :that.timeoutSeconds != null) return false;
            if (updatePercent != null ? !updatePercent.equals(that.updatePercent) :that.updatePercent != null) return false;
            if (updatePeriodSeconds != null ? !updatePeriodSeconds.equals(that.updatePeriodSeconds) :that.updatePeriodSeconds != null) return false;
            return true;
    }


    public class MaxSurgeNestedImpl extends IntOrStringFluentImpl> implements RollingDeploymentStrategyParamsFluent.MaxSurgeNested,Nested{

            private final IntOrStringBuilder builder;
    
            MaxSurgeNestedImpl(){
                    this.builder = new IntOrStringBuilder(this);
            }
            MaxSurgeNestedImpl(IntOrString item){
                    this.builder = new IntOrStringBuilder(this, item);
            }
    
    public N and(){
            return (N) RollingDeploymentStrategyParamsFluentImpl.this.withMaxSurge(builder.build());
    }
    public N endMaxSurge(){
            return and();
    }

}
    public class MaxUnavailableNestedImpl extends IntOrStringFluentImpl> implements RollingDeploymentStrategyParamsFluent.MaxUnavailableNested,Nested{

            private final IntOrStringBuilder builder;
    
            MaxUnavailableNestedImpl(){
                    this.builder = new IntOrStringBuilder(this);
            }
            MaxUnavailableNestedImpl(IntOrString item){
                    this.builder = new IntOrStringBuilder(this, item);
            }
    
    public N endMaxUnavailable(){
            return and();
    }
    public N and(){
            return (N) RollingDeploymentStrategyParamsFluentImpl.this.withMaxUnavailable(builder.build());
    }

}
    public class PostNestedImpl extends LifecycleHookFluentImpl> implements RollingDeploymentStrategyParamsFluent.PostNested,Nested{

            private final LifecycleHookBuilder builder;
    
            PostNestedImpl(){
                    this.builder = new LifecycleHookBuilder(this);
            }
            PostNestedImpl(LifecycleHook item){
                    this.builder = new LifecycleHookBuilder(this, item);
            }
    
    public N endPost(){
            return and();
    }
    public N and(){
            return (N) RollingDeploymentStrategyParamsFluentImpl.this.withPost(builder.build());
    }

}
    public class PreNestedImpl extends LifecycleHookFluentImpl> implements RollingDeploymentStrategyParamsFluent.PreNested,Nested{

            private final LifecycleHookBuilder builder;
    
            PreNestedImpl(){
                    this.builder = new LifecycleHookBuilder(this);
            }
            PreNestedImpl(LifecycleHook item){
                    this.builder = new LifecycleHookBuilder(this, item);
            }
    
    public N and(){
            return (N) RollingDeploymentStrategyParamsFluentImpl.this.withPre(builder.build());
    }
    public N endPre(){
            return and();
    }

}


}