annotations.io.alauda.kubernetes.api.model.PipelineTemplateTaskFluentImpl Maven / Gradle / Ivy

Go to download
package io.alauda.kubernetes.api.model;

import com.fasterxml.jackson.annotation.JsonProperty;
import io.alauda.kubernetes.api.builder.Nested;
import java.util.ArrayList;
import java.lang.String;
import javax.validation.constraints.NotNull;
import io.alauda.kubernetes.api.builder.Predicate;
import java.lang.Deprecated;
import io.alauda.kubernetes.api.builder.BaseFluent;
import java.util.List;
import java.lang.Boolean;
import javax.validation.Valid;
import java.lang.Long;
import java.util.Collection;
import java.lang.Object;

public class PipelineTemplateTaskFluentImpl> extends io.alauda.kubernetes.api.builder.BaseFluent implements PipelineTemplateTaskFluent{

    private JenkinsAgentBuilder agent;
    private PipelineTaskApproveBuilder approve;
    private List environments =  new ArrayList();
    private String kind;
    private String name;
    private PipelineTaskOptionBuilder options;
    private String type;

    public PipelineTemplateTaskFluentImpl(){
    }
    public PipelineTemplateTaskFluentImpl(PipelineTemplateTask instance){
            this.withAgent(instance.getAgent()); 
            this.withApprove(instance.getApprove()); 
            this.withEnvironments(instance.getEnvironments()); 
            this.withKind(instance.getKind()); 
            this.withName(instance.getName()); 
            this.withOptions(instance.getOptions()); 
            this.withType(instance.getType()); 
    }

    
/**
 * This method has been deprecated, please use method buildAgent instead.
 */
@Deprecated public JenkinsAgent getAgent(){
            return this.agent!=null?this.agent.build():null;
    }

    public JenkinsAgent buildAgent(){
            return this.agent!=null?this.agent.build():null;
    }

    public A withAgent(JenkinsAgent agent){
            _visitables.remove(this.agent);
            if (agent!=null){ this.agent= new JenkinsAgentBuilder(agent); _visitables.add(this.agent);} return (A) this;
    }

    public Boolean hasAgent(){
            return this.agent!=null;
    }

    public PipelineTemplateTaskFluent.AgentNested withNewAgent(){
            return new AgentNestedImpl();
    }

    public PipelineTemplateTaskFluent.AgentNested withNewAgentLike(JenkinsAgent item){
            return new AgentNestedImpl(item);
    }

    public PipelineTemplateTaskFluent.AgentNested editAgent(){
            return withNewAgentLike(getAgent());
    }

    public PipelineTemplateTaskFluent.AgentNested editOrNewAgent(){
            return withNewAgentLike(getAgent() != null ? getAgent(): new JenkinsAgentBuilder().build());
    }

    public PipelineTemplateTaskFluent.AgentNested editOrNewAgentLike(JenkinsAgent item){
            return withNewAgentLike(getAgent() != null ? getAgent(): item);
    }

    public A withNewAgent(String label){
            return (A)withAgent(new JenkinsAgent(label));
    }

    
/**
 * This method has been deprecated, please use method buildApprove instead.
 */
@Deprecated public PipelineTaskApprove getApprove(){
            return this.approve!=null?this.approve.build():null;
    }

    public PipelineTaskApprove buildApprove(){
            return this.approve!=null?this.approve.build():null;
    }

    public A withApprove(PipelineTaskApprove approve){
            _visitables.remove(this.approve);
            if (approve!=null){ this.approve= new PipelineTaskApproveBuilder(approve); _visitables.add(this.approve);} return (A) this;
    }

    public Boolean hasApprove(){
            return this.approve!=null;
    }

    public PipelineTemplateTaskFluent.ApproveNested withNewApprove(){
            return new ApproveNestedImpl();
    }

    public PipelineTemplateTaskFluent.ApproveNested withNewApproveLike(PipelineTaskApprove item){
            return new ApproveNestedImpl(item);
    }

    public PipelineTemplateTaskFluent.ApproveNested editApprove(){
            return withNewApproveLike(getApprove());
    }

    public PipelineTemplateTaskFluent.ApproveNested editOrNewApprove(){
            return withNewApproveLike(getApprove() != null ? getApprove(): new PipelineTaskApproveBuilder().build());
    }

    public PipelineTemplateTaskFluent.ApproveNested editOrNewApproveLike(PipelineTaskApprove item){
            return withNewApproveLike(getApprove() != null ? getApprove(): item);
    }

    public A withNewApprove(String message,Long timeout){
            return (A)withApprove(new PipelineTaskApprove(message, timeout));
    }

    public A addToEnvironments(int index,PipelineEnvironment item){
            PipelineEnvironmentBuilder builder = new PipelineEnvironmentBuilder(item);_visitables.add(index >= 0 ? index : _visitables.size(), builder);this.environments.add(index >= 0 ? index : environments.size(), builder); return (A)this;
    }

    public A setToEnvironments(int index,PipelineEnvironment item){
            PipelineEnvironmentBuilder builder = new PipelineEnvironmentBuilder(item);
            if (index < 0 || index >= _visitables.size()) { _visitables.add(builder); } else { _visitables.set(index, builder);}
            if (index < 0 || index >= environments.size()) { environments.add(builder); } else { environments.set(index, builder);}
             return (A)this;
    }

    public A addToEnvironments(PipelineEnvironment... items){
            for (PipelineEnvironment item : items) {PipelineEnvironmentBuilder builder = new PipelineEnvironmentBuilder(item);_visitables.add(builder);this.environments.add(builder);} return (A)this;
    }

    public A addAllToEnvironments(Collection items){
            for (PipelineEnvironment item : items) {PipelineEnvironmentBuilder builder = new PipelineEnvironmentBuilder(item);_visitables.add(builder);this.environments.add(builder);} return (A)this;
    }

    public A removeFromEnvironments(PipelineEnvironment... items){
            for (PipelineEnvironment item : items) {PipelineEnvironmentBuilder builder = new PipelineEnvironmentBuilder(item);_visitables.remove(builder);this.environments.remove(builder);} return (A)this;
    }

    public A removeAllFromEnvironments(Collection items){
            for (PipelineEnvironment item : items) {PipelineEnvironmentBuilder builder = new PipelineEnvironmentBuilder(item);_visitables.remove(builder);this.environments.remove(builder);} return (A)this;
    }

    
/**
 * This method has been deprecated, please use method buildEnvironments instead.
 */
@Deprecated public List getEnvironments(){
            return build(environments);
    }

    public List buildEnvironments(){
            return build(environments);
    }

    public PipelineEnvironment buildEnvironment(int index){
            return this.environments.get(index).build();
    }

    public PipelineEnvironment buildFirstEnvironment(){
            return this.environments.get(0).build();
    }

    public PipelineEnvironment buildLastEnvironment(){
            return this.environments.get(environments.size() - 1).build();
    }

    public PipelineEnvironment buildMatchingEnvironment(io.alauda.kubernetes.api.builder.Predicate predicate){
            for (PipelineEnvironmentBuilder item: environments) { if(predicate.apply(item)){return item.build();} } return null;
    }

    public A withEnvironments(List environments){
            _visitables.removeAll(this.environments);
            this.environments.clear();
            if (environments != null) {for (PipelineEnvironment item : environments){this.addToEnvironments(item);}} return (A) this;
    }

    public A withEnvironments(PipelineEnvironment... environments){
            this.environments.clear(); if (environments != null) {for (PipelineEnvironment item :environments){ this.addToEnvironments(item);}} return (A) this;
    }

    public Boolean hasEnvironments(){
            return environments!= null && !environments.isEmpty();
    }

    public PipelineTemplateTaskFluent.EnvironmentsNested addNewEnvironment(){
            return new EnvironmentsNestedImpl();
    }

    public PipelineTemplateTaskFluent.EnvironmentsNested addNewEnvironmentLike(PipelineEnvironment item){
            return new EnvironmentsNestedImpl(-1, item);
    }

    public PipelineTemplateTaskFluent.EnvironmentsNested setNewEnvironmentLike(int index,PipelineEnvironment item){
            return new EnvironmentsNestedImpl(index, item);
    }

    public PipelineTemplateTaskFluent.EnvironmentsNested editEnvironment(int index){
            if (environments.size() <= index) throw new RuntimeException("Can't edit environments. Index exceeds size.");
            return setNewEnvironmentLike(index, buildEnvironment(index));
    }

    public PipelineTemplateTaskFluent.EnvironmentsNested editFirstEnvironment(){
            if (environments.size() == 0) throw new RuntimeException("Can't edit first environments. The list is empty.");
            return setNewEnvironmentLike(0, buildEnvironment(0));
    }

    public PipelineTemplateTaskFluent.EnvironmentsNested editLastEnvironment(){
            int index = environments.size() - 1;
            if (index < 0) throw new RuntimeException("Can't edit last environments. The list is empty.");
            return setNewEnvironmentLike(index, buildEnvironment(index));
    }

    public PipelineTemplateTaskFluent.EnvironmentsNested editMatchingEnvironment(io.alauda.kubernetes.api.builder.Predicate predicate){
            int index = -1;
            for (int i=0;i withNewOptions(){
            return new OptionsNestedImpl();
    }

    public PipelineTemplateTaskFluent.OptionsNested withNewOptionsLike(PipelineTaskOption item){
            return new OptionsNestedImpl(item);
    }

    public PipelineTemplateTaskFluent.OptionsNested editOptions(){
            return withNewOptionsLike(getOptions());
    }

    public PipelineTemplateTaskFluent.OptionsNested editOrNewOptions(){
            return withNewOptionsLike(getOptions() != null ? getOptions(): new PipelineTaskOptionBuilder().build());
    }

    public PipelineTemplateTaskFluent.OptionsNested editOrNewOptionsLike(PipelineTaskOption item){
            return withNewOptionsLike(getOptions() != null ? getOptions(): item);
    }

    public A withNewOptions(Long timeout){
            return (A)withOptions(new PipelineTaskOption(timeout));
    }

    public String getType(){
            return this.type;
    }

    public A withType(String type){
            this.type=type; return (A) this;
    }

    public Boolean hasType(){
            return this.type!=null;
    }

    public boolean equals(Object o){
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            if (!super.equals(o)) return false;
            PipelineTemplateTaskFluentImpl that = (PipelineTemplateTaskFluentImpl) o;
            if (agent != null ? !agent.equals(that.agent) :that.agent != null) return false;
            if (approve != null ? !approve.equals(that.approve) :that.approve != null) return false;
            if (environments != null ? !environments.equals(that.environments) :that.environments != null) return false;
            if (kind != null ? !kind.equals(that.kind) :that.kind != null) return false;
            if (name != null ? !name.equals(that.name) :that.name != null) return false;
            if (options != null ? !options.equals(that.options) :that.options != null) return false;
            if (type != null ? !type.equals(that.type) :that.type != null) return false;
            return true;
    }


    public class AgentNestedImpl extends JenkinsAgentFluentImpl> implements PipelineTemplateTaskFluent.AgentNested,io.alauda.kubernetes.api.builder.Nested{

            private final JenkinsAgentBuilder builder;
    
            AgentNestedImpl(JenkinsAgent item){
                    this.builder = new JenkinsAgentBuilder(this, item);
            }
            AgentNestedImpl(){
                    this.builder = new JenkinsAgentBuilder(this);
            }
    
    public N and(){
            return (N) PipelineTemplateTaskFluentImpl.this.withAgent(builder.build());
    }
    public N endAgent(){
            return and();
    }

}
    public class ApproveNestedImpl extends PipelineTaskApproveFluentImpl> implements PipelineTemplateTaskFluent.ApproveNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskApproveBuilder builder;
    
            ApproveNestedImpl(PipelineTaskApprove item){
                    this.builder = new PipelineTaskApproveBuilder(this, item);
            }
            ApproveNestedImpl(){
                    this.builder = new PipelineTaskApproveBuilder(this);
            }
    
    public N and(){
            return (N) PipelineTemplateTaskFluentImpl.this.withApprove(builder.build());
    }
    public N endApprove(){
            return and();
    }

}
    public class EnvironmentsNestedImpl extends PipelineEnvironmentFluentImpl> implements PipelineTemplateTaskFluent.EnvironmentsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineEnvironmentBuilder builder;
        private final int index;
    
            EnvironmentsNestedImpl(int index,PipelineEnvironment item){
                    this.index = index;
                    this.builder = new PipelineEnvironmentBuilder(this, item);
            }
            EnvironmentsNestedImpl(){
                    this.index = -1;
                    this.builder = new PipelineEnvironmentBuilder(this);
            }
    
    public N and(){
            return (N) PipelineTemplateTaskFluentImpl.this.setToEnvironments(index, builder.build());
    }
    public N endEnvironment(){
            return and();
    }

}
    public class OptionsNestedImpl extends PipelineTaskOptionFluentImpl> implements PipelineTemplateTaskFluent.OptionsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskOptionBuilder builder;
    
            OptionsNestedImpl(PipelineTaskOption item){
                    this.builder = new PipelineTaskOptionBuilder(this, item);
            }
            OptionsNestedImpl(){
                    this.builder = new PipelineTaskOptionBuilder(this);
            }
    
    public N and(){
            return (N) PipelineTemplateTaskFluentImpl.this.withOptions(builder.build());
    }
    public N endOptions(){
            return and();
    }

}


}