io.fabric8.kubernetes.api.model.ContainerStateFluent Maven / Gradle / Ivy

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

import java.util.HashMap;
import java.util.Map;
import io.fabric8.common.Nested;
import io.fabric8.common.Fluent;

public class ContainerStateFluent> implements Fluent{

    private ContainerStateRunning running ;
    private ContainerStateTerminated termination ;
    private ContainerStateWaiting waiting ;
    private Map additionalProperties  = new HashMap();

    public ContainerStateRunning getRunning(){
    return this.running;
    }
    public T withRunning(ContainerStateRunning running){
    this.running=running; return (T) this;
    }
    public ContainerStateTerminated getTermination(){
    return this.termination;
    }
    public T withTermination(ContainerStateTerminated termination){
    this.termination=termination; return (T) this;
    }
    public ContainerStateWaiting getWaiting(){
    return this.waiting;
    }
    public T withWaiting(ContainerStateWaiting waiting){
    this.waiting=waiting; return (T) this;
    }
    public Map getAdditionalProperties(){
    return this.additionalProperties;
    }
    public T withAdditionalProperties(Map additionalProperties){
    this.additionalProperties.clear();if (additionalProperties != null) {this.additionalProperties.putAll(additionalProperties);} return (T) this;
    }
    public RunningNested withNewRunning(){
    return new RunningNested();
    }
    public TerminationNested withNewTermination(){
    return new TerminationNested();
    }
    public WaitingNested withNewWaiting(){
    return new WaitingNested();
    }
    public T addToAdditionalProperties(String key, Object value){
    if(key != null && value != null) {this.additionalProperties.put(key, value);} return (T)this;
    }

    public class RunningNested extends ContainerStateRunningFluent> implements Nested{

        private final ContainerStateRunningBuilder builder = new ContainerStateRunningBuilder(this);
    
            public N endRunning(){
            return and();
        }
            public N and(){
            return (N) ContainerStateFluent.this.withRunning(builder.build());
        }
    
}
    public class TerminationNested extends ContainerStateTerminatedFluent> implements Nested{

        private final ContainerStateTerminatedBuilder builder = new ContainerStateTerminatedBuilder(this);
    
            public N endTermination(){
            return and();
        }
            public N and(){
            return (N) ContainerStateFluent.this.withTermination(builder.build());
        }
    
}
    public class WaitingNested extends ContainerStateWaitingFluent> implements Nested{

        private final ContainerStateWaitingBuilder builder = new ContainerStateWaitingBuilder(this);
    
            public N endWaiting(){
            return and();
        }
            public N and(){
            return (N) ContainerStateFluent.this.withWaiting(builder.build());
        }
    
}


}