io.alauda.kubernetes.api.model.PipelineTaskTemplateSpecFluentImpl 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: 0.2.12
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 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.util.Collection;
import java.lang.Object;

public class PipelineTaskTemplateSpecFluentImpl> extends io.alauda.kubernetes.api.builder.BaseFluent implements PipelineTaskTemplateSpecFluent{

    private JenkinsAgentBuilder agent;
    private List arguments =  new ArrayList();
    private String body;
    private PipelineDependencyBuilder dependencies;
    private String engine;
    private List exports =  new ArrayList();
    private List parameters =  new ArrayList();

    public PipelineTaskTemplateSpecFluentImpl(){
    }
    public PipelineTaskTemplateSpecFluentImpl(PipelineTaskTemplateSpec instance){
            this.withAgent(instance.getAgent()); 
            this.withArguments(instance.getArguments()); 
            this.withBody(instance.getBody()); 
            this.withDependencies(instance.getDependencies()); 
            this.withEngine(instance.getEngine()); 
            this.withExports(instance.getExports()); 
            this.withParameters(instance.getParameters()); 
    }

    
/**
 * 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 PipelineTaskTemplateSpecFluent.AgentNested withNewAgent(){
            return new AgentNestedImpl();
    }

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

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

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

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

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

    public A addToArguments(int index,PipelineTaskArgument item){
            PipelineTaskArgumentBuilder builder = new PipelineTaskArgumentBuilder(item);_visitables.add(index >= 0 ? index : _visitables.size(), builder);this.arguments.add(index >= 0 ? index : arguments.size(), builder); return (A)this;
    }

    public A setToArguments(int index,PipelineTaskArgument item){
            PipelineTaskArgumentBuilder builder = new PipelineTaskArgumentBuilder(item);
            if (index < 0 || index >= _visitables.size()) { _visitables.add(builder); } else { _visitables.set(index, builder);}
            if (index < 0 || index >= arguments.size()) { arguments.add(builder); } else { arguments.set(index, builder);}
             return (A)this;
    }

    public A addToArguments(PipelineTaskArgument... items){
            for (PipelineTaskArgument item : items) {PipelineTaskArgumentBuilder builder = new PipelineTaskArgumentBuilder(item);_visitables.add(builder);this.arguments.add(builder);} return (A)this;
    }

    public A addAllToArguments(Collection items){
            for (PipelineTaskArgument item : items) {PipelineTaskArgumentBuilder builder = new PipelineTaskArgumentBuilder(item);_visitables.add(builder);this.arguments.add(builder);} return (A)this;
    }

    public A removeFromArguments(PipelineTaskArgument... items){
            for (PipelineTaskArgument item : items) {PipelineTaskArgumentBuilder builder = new PipelineTaskArgumentBuilder(item);_visitables.remove(builder);this.arguments.remove(builder);} return (A)this;
    }

    public A removeAllFromArguments(Collection items){
            for (PipelineTaskArgument item : items) {PipelineTaskArgumentBuilder builder = new PipelineTaskArgumentBuilder(item);_visitables.remove(builder);this.arguments.remove(builder);} return (A)this;
    }

    
/**
 * This method has been deprecated, please use method buildArguments instead.
 */
@Deprecated public List getArguments(){
            return build(arguments);
    }

    public List buildArguments(){
            return build(arguments);
    }

    public PipelineTaskArgument buildArgument(int index){
            return this.arguments.get(index).build();
    }

    public PipelineTaskArgument buildFirstArgument(){
            return this.arguments.get(0).build();
    }

    public PipelineTaskArgument buildLastArgument(){
            return this.arguments.get(arguments.size() - 1).build();
    }

    public PipelineTaskArgument buildMatchingArgument(io.alauda.kubernetes.api.builder.Predicate predicate){
            for (PipelineTaskArgumentBuilder item: arguments) { if(predicate.apply(item)){return item.build();} } return null;
    }

    public A withArguments(List arguments){
            _visitables.removeAll(this.arguments);
            this.arguments.clear();
            if (arguments != null) {for (PipelineTaskArgument item : arguments){this.addToArguments(item);}} return (A) this;
    }

    public A withArguments(PipelineTaskArgument... arguments){
            this.arguments.clear(); if (arguments != null) {for (PipelineTaskArgument item :arguments){ this.addToArguments(item);}} return (A) this;
    }

    public Boolean hasArguments(){
            return arguments!= null && !arguments.isEmpty();
    }

    public PipelineTaskTemplateSpecFluent.ArgumentsNested addNewArgument(){
            return new ArgumentsNestedImpl();
    }

    public PipelineTaskTemplateSpecFluent.ArgumentsNested addNewArgumentLike(PipelineTaskArgument item){
            return new ArgumentsNestedImpl(-1, item);
    }

    public PipelineTaskTemplateSpecFluent.ArgumentsNested setNewArgumentLike(int index,PipelineTaskArgument item){
            return new ArgumentsNestedImpl(index, item);
    }

    public PipelineTaskTemplateSpecFluent.ArgumentsNested editArgument(int index){
            if (arguments.size() <= index) throw new RuntimeException("Can't edit arguments. Index exceeds size.");
            return setNewArgumentLike(index, buildArgument(index));
    }

    public PipelineTaskTemplateSpecFluent.ArgumentsNested editFirstArgument(){
            if (arguments.size() == 0) throw new RuntimeException("Can't edit first arguments. The list is empty.");
            return setNewArgumentLike(0, buildArgument(0));
    }

    public PipelineTaskTemplateSpecFluent.ArgumentsNested editLastArgument(){
            int index = arguments.size() - 1;
            if (index < 0) throw new RuntimeException("Can't edit last arguments. The list is empty.");
            return setNewArgumentLike(index, buildArgument(index));
    }

    public PipelineTaskTemplateSpecFluent.ArgumentsNested editMatchingArgument(io.alauda.kubernetes.api.builder.Predicate predicate){
            int index = -1;
            for (int i=0;i withNewDependencies(){
            return new DependenciesNestedImpl();
    }

    public PipelineTaskTemplateSpecFluent.DependenciesNested withNewDependenciesLike(PipelineDependency item){
            return new DependenciesNestedImpl(item);
    }

    public PipelineTaskTemplateSpecFluent.DependenciesNested editDependencies(){
            return withNewDependenciesLike(getDependencies());
    }

    public PipelineTaskTemplateSpecFluent.DependenciesNested editOrNewDependencies(){
            return withNewDependenciesLike(getDependencies() != null ? getDependencies(): new PipelineDependencyBuilder().build());
    }

    public PipelineTaskTemplateSpecFluent.DependenciesNested editOrNewDependenciesLike(PipelineDependency item){
            return withNewDependenciesLike(getDependencies() != null ? getDependencies(): item);
    }

    public String getEngine(){
            return this.engine;
    }

    public A withEngine(String engine){
            this.engine=engine; return (A) this;
    }

    public Boolean hasEngine(){
            return this.engine!=null;
    }

    public A addToExports(int index,GlobalParameter item){
            GlobalParameterBuilder builder = new GlobalParameterBuilder(item);_visitables.add(index >= 0 ? index : _visitables.size(), builder);this.exports.add(index >= 0 ? index : exports.size(), builder); return (A)this;
    }

    public A setToExports(int index,GlobalParameter item){
            GlobalParameterBuilder builder = new GlobalParameterBuilder(item);
            if (index < 0 || index >= _visitables.size()) { _visitables.add(builder); } else { _visitables.set(index, builder);}
            if (index < 0 || index >= exports.size()) { exports.add(builder); } else { exports.set(index, builder);}
             return (A)this;
    }

    public A addToExports(GlobalParameter... items){
            for (GlobalParameter item : items) {GlobalParameterBuilder builder = new GlobalParameterBuilder(item);_visitables.add(builder);this.exports.add(builder);} return (A)this;
    }

    public A addAllToExports(Collection items){
            for (GlobalParameter item : items) {GlobalParameterBuilder builder = new GlobalParameterBuilder(item);_visitables.add(builder);this.exports.add(builder);} return (A)this;
    }

    public A removeFromExports(GlobalParameter... items){
            for (GlobalParameter item : items) {GlobalParameterBuilder builder = new GlobalParameterBuilder(item);_visitables.remove(builder);this.exports.remove(builder);} return (A)this;
    }

    public A removeAllFromExports(Collection items){
            for (GlobalParameter item : items) {GlobalParameterBuilder builder = new GlobalParameterBuilder(item);_visitables.remove(builder);this.exports.remove(builder);} return (A)this;
    }

    
/**
 * This method has been deprecated, please use method buildExports instead.
 */
@Deprecated public List getExports(){
            return build(exports);
    }

    public List buildExports(){
            return build(exports);
    }

    public GlobalParameter buildExport(int index){
            return this.exports.get(index).build();
    }

    public GlobalParameter buildFirstExport(){
            return this.exports.get(0).build();
    }

    public GlobalParameter buildLastExport(){
            return this.exports.get(exports.size() - 1).build();
    }

    public GlobalParameter buildMatchingExport(io.alauda.kubernetes.api.builder.Predicate predicate){
            for (GlobalParameterBuilder item: exports) { if(predicate.apply(item)){return item.build();} } return null;
    }

    public A withExports(List exports){
            _visitables.removeAll(this.exports);
            this.exports.clear();
            if (exports != null) {for (GlobalParameter item : exports){this.addToExports(item);}} return (A) this;
    }

    public A withExports(GlobalParameter... exports){
            this.exports.clear(); if (exports != null) {for (GlobalParameter item :exports){ this.addToExports(item);}} return (A) this;
    }

    public Boolean hasExports(){
            return exports!= null && !exports.isEmpty();
    }

    public PipelineTaskTemplateSpecFluent.ExportsNested addNewExport(){
            return new ExportsNestedImpl();
    }

    public PipelineTaskTemplateSpecFluent.ExportsNested addNewExportLike(GlobalParameter item){
            return new ExportsNestedImpl(-1, item);
    }

    public PipelineTaskTemplateSpecFluent.ExportsNested setNewExportLike(int index,GlobalParameter item){
            return new ExportsNestedImpl(index, item);
    }

    public PipelineTaskTemplateSpecFluent.ExportsNested editExport(int index){
            if (exports.size() <= index) throw new RuntimeException("Can't edit exports. Index exceeds size.");
            return setNewExportLike(index, buildExport(index));
    }

    public PipelineTaskTemplateSpecFluent.ExportsNested editFirstExport(){
            if (exports.size() == 0) throw new RuntimeException("Can't edit first exports. The list is empty.");
            return setNewExportLike(0, buildExport(0));
    }

    public PipelineTaskTemplateSpecFluent.ExportsNested editLastExport(){
            int index = exports.size() - 1;
            if (index < 0) throw new RuntimeException("Can't edit last exports. The list is empty.");
            return setNewExportLike(index, buildExport(index));
    }

    public PipelineTaskTemplateSpecFluent.ExportsNested editMatchingExport(io.alauda.kubernetes.api.builder.Predicate predicate){
            int index = -1;
            for (int i=0;i= 0 ? index : _visitables.size(), builder);this.parameters.add(index >= 0 ? index : parameters.size(), builder); return (A)this;
    }

    public A setToParameters(int index,PipelineParameter item){
            PipelineParameterBuilder builder = new PipelineParameterBuilder(item);
            if (index < 0 || index >= _visitables.size()) { _visitables.add(builder); } else { _visitables.set(index, builder);}
            if (index < 0 || index >= parameters.size()) { parameters.add(builder); } else { parameters.set(index, builder);}
             return (A)this;
    }

    public A addToParameters(PipelineParameter... items){
            for (PipelineParameter item : items) {PipelineParameterBuilder builder = new PipelineParameterBuilder(item);_visitables.add(builder);this.parameters.add(builder);} return (A)this;
    }

    public A addAllToParameters(Collection items){
            for (PipelineParameter item : items) {PipelineParameterBuilder builder = new PipelineParameterBuilder(item);_visitables.add(builder);this.parameters.add(builder);} return (A)this;
    }

    public A removeFromParameters(PipelineParameter... items){
            for (PipelineParameter item : items) {PipelineParameterBuilder builder = new PipelineParameterBuilder(item);_visitables.remove(builder);this.parameters.remove(builder);} return (A)this;
    }

    public A removeAllFromParameters(Collection items){
            for (PipelineParameter item : items) {PipelineParameterBuilder builder = new PipelineParameterBuilder(item);_visitables.remove(builder);this.parameters.remove(builder);} return (A)this;
    }

    
/**
 * This method has been deprecated, please use method buildParameters instead.
 */
@Deprecated public List getParameters(){
            return build(parameters);
    }

    public List buildParameters(){
            return build(parameters);
    }

    public PipelineParameter buildParameter(int index){
            return this.parameters.get(index).build();
    }

    public PipelineParameter buildFirstParameter(){
            return this.parameters.get(0).build();
    }

    public PipelineParameter buildLastParameter(){
            return this.parameters.get(parameters.size() - 1).build();
    }

    public PipelineParameter buildMatchingParameter(io.alauda.kubernetes.api.builder.Predicate predicate){
            for (PipelineParameterBuilder item: parameters) { if(predicate.apply(item)){return item.build();} } return null;
    }

    public A withParameters(List parameters){
            _visitables.removeAll(this.parameters);
            this.parameters.clear();
            if (parameters != null) {for (PipelineParameter item : parameters){this.addToParameters(item);}} return (A) this;
    }

    public A withParameters(PipelineParameter... parameters){
            this.parameters.clear(); if (parameters != null) {for (PipelineParameter item :parameters){ this.addToParameters(item);}} return (A) this;
    }

    public Boolean hasParameters(){
            return parameters!= null && !parameters.isEmpty();
    }

    public PipelineTaskTemplateSpecFluent.ParametersNested addNewParameter(){
            return new ParametersNestedImpl();
    }

    public PipelineTaskTemplateSpecFluent.ParametersNested addNewParameterLike(PipelineParameter item){
            return new ParametersNestedImpl(-1, item);
    }

    public PipelineTaskTemplateSpecFluent.ParametersNested setNewParameterLike(int index,PipelineParameter item){
            return new ParametersNestedImpl(index, item);
    }

    public PipelineTaskTemplateSpecFluent.ParametersNested editParameter(int index){
            if (parameters.size() <= index) throw new RuntimeException("Can't edit parameters. Index exceeds size.");
            return setNewParameterLike(index, buildParameter(index));
    }

    public PipelineTaskTemplateSpecFluent.ParametersNested editFirstParameter(){
            if (parameters.size() == 0) throw new RuntimeException("Can't edit first parameters. The list is empty.");
            return setNewParameterLike(0, buildParameter(0));
    }

    public PipelineTaskTemplateSpecFluent.ParametersNested editLastParameter(){
            int index = parameters.size() - 1;
            if (index < 0) throw new RuntimeException("Can't edit last parameters. The list is empty.");
            return setNewParameterLike(index, buildParameter(index));
    }

    public PipelineTaskTemplateSpecFluent.ParametersNested editMatchingParameter(io.alauda.kubernetes.api.builder.Predicate predicate){
            int index = -1;
            for (int i=0;i extends JenkinsAgentFluentImpl> implements PipelineTaskTemplateSpecFluent.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) PipelineTaskTemplateSpecFluentImpl.this.withAgent(builder.build());
    }
    public N endAgent(){
            return and();
    }

}
    public class ArgumentsNestedImpl extends PipelineTaskArgumentFluentImpl> implements PipelineTaskTemplateSpecFluent.ArgumentsNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineTaskArgumentBuilder builder;
        private final int index;
    
            ArgumentsNestedImpl(int index,PipelineTaskArgument item){
                    this.index = index;
                    this.builder = new PipelineTaskArgumentBuilder(this, item);
            }
            ArgumentsNestedImpl(){
                    this.index = -1;
                    this.builder = new PipelineTaskArgumentBuilder(this);
            }
    
    public N and(){
            return (N) PipelineTaskTemplateSpecFluentImpl.this.setToArguments(index, builder.build());
    }
    public N endArgument(){
            return and();
    }

}
    public class DependenciesNestedImpl extends PipelineDependencyFluentImpl> implements PipelineTaskTemplateSpecFluent.DependenciesNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineDependencyBuilder builder;
    
            DependenciesNestedImpl(PipelineDependency item){
                    this.builder = new PipelineDependencyBuilder(this, item);
            }
            DependenciesNestedImpl(){
                    this.builder = new PipelineDependencyBuilder(this);
            }
    
    public N and(){
            return (N) PipelineTaskTemplateSpecFluentImpl.this.withDependencies(builder.build());
    }
    public N endDependencies(){
            return and();
    }

}
    public class ExportsNestedImpl extends GlobalParameterFluentImpl> implements PipelineTaskTemplateSpecFluent.ExportsNested,io.alauda.kubernetes.api.builder.Nested{

            private final GlobalParameterBuilder builder;
        private final int index;
    
            ExportsNestedImpl(int index,GlobalParameter item){
                    this.index = index;
                    this.builder = new GlobalParameterBuilder(this, item);
            }
            ExportsNestedImpl(){
                    this.index = -1;
                    this.builder = new GlobalParameterBuilder(this);
            }
    
    public N and(){
            return (N) PipelineTaskTemplateSpecFluentImpl.this.setToExports(index, builder.build());
    }
    public N endExport(){
            return and();
    }

}
    public class ParametersNestedImpl extends PipelineParameterFluentImpl> implements PipelineTaskTemplateSpecFluent.ParametersNested,io.alauda.kubernetes.api.builder.Nested{

            private final PipelineParameterBuilder builder;
        private final int index;
    
            ParametersNestedImpl(int index,PipelineParameter item){
                    this.index = index;
                    this.builder = new PipelineParameterBuilder(this, item);
            }
            ParametersNestedImpl(){
                    this.index = -1;
                    this.builder = new PipelineParameterBuilder(this);
            }
    
    public N and(){
            return (N) PipelineTaskTemplateSpecFluentImpl.this.setToParameters(index, builder.build());
    }
    public N endParameter(){
            return and();
    }

}


}