EmbeddedTaskFluent (Fabric8 :: Tekton :: Model v1beta1 6.9.2 API)

java.lang.Object
- io.fabric8.kubernetes.api.builder.BaseFluent<A>
- - io.fabric8.tekton.pipeline.v1beta1.EmbeddedTaskFluent<A>

Direct Known Subclasses:: EmbeddedTaskBuilder, PipelineTaskFluent.TaskSpecNested

public class EmbeddedTaskFluent<A extends EmbeddedTaskFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>

Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`EmbeddedTaskFluent.MetadataNested<N>`
`class`	`EmbeddedTaskFluent.ParamsNested<N>`
`class`	`EmbeddedTaskFluent.ResourcesNested<N>`
`class`	`EmbeddedTaskFluent.ResultsNested<N>`
`class`	`EmbeddedTaskFluent.SidecarsNested<N>`
`class`	`EmbeddedTaskFluent.StepsNested<N>`
`class`	`EmbeddedTaskFluent.StepTemplateNested<N>`
`class`	`EmbeddedTaskFluent.VolumesNested<N>`
`class`	`EmbeddedTaskFluent.WorkspacesNested<N>`

Field Summary
- Fields inherited from class io.fabric8.kubernetes.api.builder.BaseFluent
  _visitables, VISIT

Constructor Summary

Constructors
Constructor and Description

EmbeddedTaskFluent()

EmbeddedTaskFluent(EmbeddedTask instance)

Constructors
Constructor and Description
`EmbeddedTaskFluent()`
`EmbeddedTaskFluent(EmbeddedTask instance)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`A`	`addAllToParams(Collection<ParamSpec> items)`
`A`	`addAllToResults(Collection<TaskResult> items)`
`A`	`addAllToSidecars(Collection<Sidecar> items)`
`A`	`addAllToSteps(Collection<Step> items)`
`A`	`addAllToVolumes(Collection<io.fabric8.kubernetes.api.model.Volume> items)`
`A`	`addAllToWorkspaces(Collection<WorkspaceDeclaration> items)`
`EmbeddedTaskFluent.ParamsNested<A>`	`addNewParam()`
`EmbeddedTaskFluent.ParamsNested<A>`	`addNewParamLike(ParamSpec item)`
`EmbeddedTaskFluent.ResultsNested<A>`	`addNewResult()`
`EmbeddedTaskFluent.ResultsNested<A>`	`addNewResultLike(TaskResult item)`
`EmbeddedTaskFluent.SidecarsNested<A>`	`addNewSidecar()`
`EmbeddedTaskFluent.SidecarsNested<A>`	`addNewSidecarLike(Sidecar item)`
`EmbeddedTaskFluent.StepsNested<A>`	`addNewStep()`
`EmbeddedTaskFluent.StepsNested<A>`	`addNewStepLike(Step item)`
`EmbeddedTaskFluent.VolumesNested<A>`	`addNewVolume()`
`EmbeddedTaskFluent.VolumesNested<A>`	`addNewVolumeLike(io.fabric8.kubernetes.api.model.Volume item)`
`EmbeddedTaskFluent.WorkspacesNested<A>`	`addNewWorkspace()`
`A`	`addNewWorkspace(String description, String mountPath, String name, Boolean optional, Boolean readOnly)`
`EmbeddedTaskFluent.WorkspacesNested<A>`	`addNewWorkspaceLike(WorkspaceDeclaration item)`
`A`	`addToAdditionalProperties(Map<String,Object> map)`
`A`	`addToAdditionalProperties(String key, Object value)`
`A`	`addToParams(int index, ParamSpec item)`
`A`	`addToParams(ParamSpec... items)`
`A`	`addToResults(int index, TaskResult item)`
`A`	`addToResults(TaskResult... items)`
`A`	`addToSidecars(int index, Sidecar item)`
`A`	`addToSidecars(Sidecar... items)`
`A`	`addToSpec(Map<String,Object> map)`
`A`	`addToSpec(String key, Object value)`
`A`	`addToSteps(int index, Step item)`
`A`	`addToSteps(Step... items)`
`A`	`addToVolumes(int index, io.fabric8.kubernetes.api.model.Volume item)`
`A`	`addToVolumes(io.fabric8.kubernetes.api.model.Volume... items)`
`A`	`addToWorkspaces(int index, WorkspaceDeclaration item)`
`A`	`addToWorkspaces(WorkspaceDeclaration... items)`
`ParamSpec`	`buildFirstParam()`
`TaskResult`	`buildFirstResult()`
`Sidecar`	`buildFirstSidecar()`
`Step`	`buildFirstStep()`
`io.fabric8.kubernetes.api.model.Volume`	`buildFirstVolume()`
`WorkspaceDeclaration`	`buildFirstWorkspace()`
`ParamSpec`	`buildLastParam()`
`TaskResult`	`buildLastResult()`
`Sidecar`	`buildLastSidecar()`
`Step`	`buildLastStep()`
`io.fabric8.kubernetes.api.model.Volume`	`buildLastVolume()`
`WorkspaceDeclaration`	`buildLastWorkspace()`
`ParamSpec`	`buildMatchingParam(Predicate<ParamSpecBuilder> predicate)`
`TaskResult`	`buildMatchingResult(Predicate<TaskResultBuilder> predicate)`
`Sidecar`	`buildMatchingSidecar(Predicate<SidecarBuilder> predicate)`
`Step`	`buildMatchingStep(Predicate<StepBuilder> predicate)`
`io.fabric8.kubernetes.api.model.Volume`	`buildMatchingVolume(Predicate<io.fabric8.kubernetes.api.model.VolumeBuilder> predicate)`
`WorkspaceDeclaration`	`buildMatchingWorkspace(Predicate<WorkspaceDeclarationBuilder> predicate)`
`PipelineTaskMetadata`	`buildMetadata()`
`ParamSpec`	`buildParam(int index)`
`List<ParamSpec>`	`buildParams()`
`TaskResources`	`buildResources()`
`TaskResult`	`buildResult(int index)`
`List<TaskResult>`	`buildResults()`
`Sidecar`	`buildSidecar(int index)`
`List<Sidecar>`	`buildSidecars()`
`Step`	`buildStep(int index)`
`List<Step>`	`buildSteps()`
`StepTemplate`	`buildStepTemplate()`
`io.fabric8.kubernetes.api.model.Volume`	`buildVolume(int index)`
`List<io.fabric8.kubernetes.api.model.Volume>`	`buildVolumes()`
`WorkspaceDeclaration`	`buildWorkspace(int index)`
`List<WorkspaceDeclaration>`	`buildWorkspaces()`
`protected void`	`copyInstance(EmbeddedTask instance)`
`EmbeddedTaskFluent.ParamsNested<A>`	`editFirstParam()`
`EmbeddedTaskFluent.ResultsNested<A>`	`editFirstResult()`
`EmbeddedTaskFluent.SidecarsNested<A>`	`editFirstSidecar()`
`EmbeddedTaskFluent.StepsNested<A>`	`editFirstStep()`
`EmbeddedTaskFluent.VolumesNested<A>`	`editFirstVolume()`
`EmbeddedTaskFluent.WorkspacesNested<A>`	`editFirstWorkspace()`
`EmbeddedTaskFluent.ParamsNested<A>`	`editLastParam()`
`EmbeddedTaskFluent.ResultsNested<A>`	`editLastResult()`
`EmbeddedTaskFluent.SidecarsNested<A>`	`editLastSidecar()`
`EmbeddedTaskFluent.StepsNested<A>`	`editLastStep()`
`EmbeddedTaskFluent.VolumesNested<A>`	`editLastVolume()`
`EmbeddedTaskFluent.WorkspacesNested<A>`	`editLastWorkspace()`
`EmbeddedTaskFluent.ParamsNested<A>`	`editMatchingParam(Predicate<ParamSpecBuilder> predicate)`
`EmbeddedTaskFluent.ResultsNested<A>`	`editMatchingResult(Predicate<TaskResultBuilder> predicate)`
`EmbeddedTaskFluent.SidecarsNested<A>`	`editMatchingSidecar(Predicate<SidecarBuilder> predicate)`
`EmbeddedTaskFluent.StepsNested<A>`	`editMatchingStep(Predicate<StepBuilder> predicate)`
`EmbeddedTaskFluent.VolumesNested<A>`	`editMatchingVolume(Predicate<io.fabric8.kubernetes.api.model.VolumeBuilder> predicate)`
`EmbeddedTaskFluent.WorkspacesNested<A>`	`editMatchingWorkspace(Predicate<WorkspaceDeclarationBuilder> predicate)`
`EmbeddedTaskFluent.MetadataNested<A>`	`editMetadata()`
`EmbeddedTaskFluent.MetadataNested<A>`	`editOrNewMetadata()`
`EmbeddedTaskFluent.MetadataNested<A>`	`editOrNewMetadataLike(PipelineTaskMetadata item)`
`EmbeddedTaskFluent.ResourcesNested<A>`	`editOrNewResources()`
`EmbeddedTaskFluent.ResourcesNested<A>`	`editOrNewResourcesLike(TaskResources item)`
`EmbeddedTaskFluent.StepTemplateNested<A>`	`editOrNewStepTemplate()`
`EmbeddedTaskFluent.StepTemplateNested<A>`	`editOrNewStepTemplateLike(StepTemplate item)`
`EmbeddedTaskFluent.ParamsNested<A>`	`editParam(int index)`
`EmbeddedTaskFluent.ResourcesNested<A>`	`editResources()`
`EmbeddedTaskFluent.ResultsNested<A>`	`editResult(int index)`
`EmbeddedTaskFluent.SidecarsNested<A>`	`editSidecar(int index)`
`EmbeddedTaskFluent.StepsNested<A>`	`editStep(int index)`
`EmbeddedTaskFluent.StepTemplateNested<A>`	`editStepTemplate()`
`EmbeddedTaskFluent.VolumesNested<A>`	`editVolume(int index)`
`EmbeddedTaskFluent.WorkspacesNested<A>`	`editWorkspace(int index)`
`boolean`	`equals(Object o)`
`Map<String,Object>`	`getAdditionalProperties()`
`String`	`getApiVersion()`
`String`	`getDescription()`
`String`	`getDisplayName()`
`String`	`getKind()`
`Map<String,Object>`	`getSpec()`
`boolean`	`hasAdditionalProperties()`
`boolean`	`hasApiVersion()`
`boolean`	`hasDescription()`
`boolean`	`hasDisplayName()`
`int`	`hashCode()`
`boolean`	`hasKind()`
`boolean`	`hasMatchingParam(Predicate<ParamSpecBuilder> predicate)`
`boolean`	`hasMatchingResult(Predicate<TaskResultBuilder> predicate)`
`boolean`	`hasMatchingSidecar(Predicate<SidecarBuilder> predicate)`
`boolean`	`hasMatchingStep(Predicate<StepBuilder> predicate)`
`boolean`	`hasMatchingVolume(Predicate<io.fabric8.kubernetes.api.model.VolumeBuilder> predicate)`
`boolean`	`hasMatchingWorkspace(Predicate<WorkspaceDeclarationBuilder> predicate)`
`boolean`	`hasMetadata()`
`boolean`	`hasParams()`
`boolean`	`hasResources()`
`boolean`	`hasResults()`
`boolean`	`hasSidecars()`
`boolean`	`hasSpec()`
`boolean`	`hasSteps()`
`boolean`	`hasStepTemplate()`
`boolean`	`hasVolumes()`
`boolean`	`hasWorkspaces()`
`A`	`removeAllFromParams(Collection<ParamSpec> items)`
`A`	`removeAllFromResults(Collection<TaskResult> items)`
`A`	`removeAllFromSidecars(Collection<Sidecar> items)`
`A`	`removeAllFromSteps(Collection<Step> items)`
`A`	`removeAllFromVolumes(Collection<io.fabric8.kubernetes.api.model.Volume> items)`
`A`	`removeAllFromWorkspaces(Collection<WorkspaceDeclaration> items)`
`A`	`removeFromAdditionalProperties(Map<String,Object> map)`
`A`	`removeFromAdditionalProperties(String key)`
`A`	`removeFromParams(ParamSpec... items)`
`A`	`removeFromResults(TaskResult... items)`
`A`	`removeFromSidecars(Sidecar... items)`
`A`	`removeFromSpec(Map<String,Object> map)`
`A`	`removeFromSpec(String key)`
`A`	`removeFromSteps(Step... items)`
`A`	`removeFromVolumes(io.fabric8.kubernetes.api.model.Volume... items)`
`A`	`removeFromWorkspaces(WorkspaceDeclaration... items)`
`A`	`removeMatchingFromParams(Predicate<ParamSpecBuilder> predicate)`
`A`	`removeMatchingFromResults(Predicate<TaskResultBuilder> predicate)`
`A`	`removeMatchingFromSidecars(Predicate<SidecarBuilder> predicate)`
`A`	`removeMatchingFromSteps(Predicate<StepBuilder> predicate)`
`A`	`removeMatchingFromVolumes(Predicate<io.fabric8.kubernetes.api.model.VolumeBuilder> predicate)`
`A`	`removeMatchingFromWorkspaces(Predicate<WorkspaceDeclarationBuilder> predicate)`
`EmbeddedTaskFluent.ParamsNested<A>`	`setNewParamLike(int index, ParamSpec item)`
`EmbeddedTaskFluent.ResultsNested<A>`	`setNewResultLike(int index, TaskResult item)`
`EmbeddedTaskFluent.SidecarsNested<A>`	`setNewSidecarLike(int index, Sidecar item)`
`EmbeddedTaskFluent.StepsNested<A>`	`setNewStepLike(int index, Step item)`
`EmbeddedTaskFluent.VolumesNested<A>`	`setNewVolumeLike(int index, io.fabric8.kubernetes.api.model.Volume item)`
`EmbeddedTaskFluent.WorkspacesNested<A>`	`setNewWorkspaceLike(int index, WorkspaceDeclaration item)`
`A`	`setToParams(int index, ParamSpec item)`
`A`	`setToResults(int index, TaskResult item)`
`A`	`setToSidecars(int index, Sidecar item)`
`A`	`setToSteps(int index, Step item)`
`A`	`setToVolumes(int index, io.fabric8.kubernetes.api.model.Volume item)`
`A`	`setToWorkspaces(int index, WorkspaceDeclaration item)`
`String`	`toString()`
`<K,V> A`	`withAdditionalProperties(Map<String,Object> additionalProperties)`
`A`	`withApiVersion(String apiVersion)`
`A`	`withDescription(String description)`
`A`	`withDisplayName(String displayName)`
`A`	`withKind(String kind)`
`A`	`withMetadata(PipelineTaskMetadata metadata)`
`EmbeddedTaskFluent.MetadataNested<A>`	`withNewMetadata()`
`EmbeddedTaskFluent.MetadataNested<A>`	`withNewMetadataLike(PipelineTaskMetadata item)`
`EmbeddedTaskFluent.ResourcesNested<A>`	`withNewResources()`
`EmbeddedTaskFluent.ResourcesNested<A>`	`withNewResourcesLike(TaskResources item)`
`EmbeddedTaskFluent.StepTemplateNested<A>`	`withNewStepTemplate()`
`EmbeddedTaskFluent.StepTemplateNested<A>`	`withNewStepTemplateLike(StepTemplate item)`
`A`	`withParams(List<ParamSpec> params)`
`A`	`withParams(ParamSpec... params)`
`A`	`withResources(TaskResources resources)`
`A`	`withResults(List<TaskResult> results)`
`A`	`withResults(TaskResult... results)`
`A`	`withSidecars(List<Sidecar> sidecars)`
`A`	`withSidecars(Sidecar... sidecars)`
`<K,V> A`	`withSpec(Map<String,Object> spec)`
`A`	`withSteps(List<Step> steps)`
`A`	`withSteps(Step... steps)`
`A`	`withStepTemplate(StepTemplate stepTemplate)`
`A`	`withVolumes(List<io.fabric8.kubernetes.api.model.Volume> volumes)`
`A`	`withVolumes(io.fabric8.kubernetes.api.model.Volume... volumes)`
`A`	`withWorkspaces(List<WorkspaceDeclaration> workspaces)`
`A`	`withWorkspaces(WorkspaceDeclaration... workspaces)`

Methods inherited from class io.fabric8.kubernetes.api.builder.BaseFluent
aggregate, aggregate, build, build, builderOf, getVisitableMap

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

EmbeddedTaskFluent
```
public EmbeddedTaskFluent()
```

EmbeddedTaskFluent

public EmbeddedTaskFluent(EmbeddedTask instance)

Method Detail

copyInstance

protected void copyInstance(EmbeddedTask instance)

getApiVersion
```
public String getApiVersion()
```

withApiVersion

public A withApiVersion(String apiVersion)

hasApiVersion
```
public boolean hasApiVersion()
```

getDescription
```
public String getDescription()
```

withDescription

public A withDescription(String description)

hasDescription
```
public boolean hasDescription()
```

getDisplayName
```
public String getDisplayName()
```

withDisplayName

public A withDisplayName(String displayName)

hasDisplayName
```
public boolean hasDisplayName()
```

getKind
```
public String getKind()
```

withKind
```
public A withKind(String kind)
```

hasKind
```
public boolean hasKind()
```

buildMetadata

public PipelineTaskMetadata buildMetadata()

withMetadata

public A withMetadata(PipelineTaskMetadata metadata)

hasMetadata
```
public boolean hasMetadata()
```

withNewMetadata

public EmbeddedTaskFluent.MetadataNested<A> withNewMetadata()

withNewMetadataLike

public EmbeddedTaskFluent.MetadataNested<A> withNewMetadataLike(PipelineTaskMetadata item)

editMetadata

public EmbeddedTaskFluent.MetadataNested<A> editMetadata()

editOrNewMetadata

public EmbeddedTaskFluent.MetadataNested<A> editOrNewMetadata()

editOrNewMetadataLike

public EmbeddedTaskFluent.MetadataNested<A> editOrNewMetadataLike(PipelineTaskMetadata item)

addToParams

public A addToParams(int index,
                     ParamSpec item)

setToParams

public A setToParams(int index,
                     ParamSpec item)

addToParams

public A addToParams(ParamSpec... items)

addAllToParams

public A addAllToParams(Collection<ParamSpec> items)

removeFromParams

public A removeFromParams(ParamSpec... items)

removeAllFromParams

public A removeAllFromParams(Collection<ParamSpec> items)

removeMatchingFromParams

public A removeMatchingFromParams(Predicate<ParamSpecBuilder> predicate)

buildParams
```
public List<ParamSpec> buildParams()
```

buildParam

public ParamSpec buildParam(int index)

buildFirstParam
```
public ParamSpec buildFirstParam()
```

buildLastParam
```
public ParamSpec buildLastParam()
```

buildMatchingParam

public ParamSpec buildMatchingParam(Predicate<ParamSpecBuilder> predicate)

hasMatchingParam

public boolean hasMatchingParam(Predicate<ParamSpecBuilder> predicate)

withParams

public A withParams(List<ParamSpec> params)

withParams

public A withParams(ParamSpec... params)

hasParams
```
public boolean hasParams()
```

addNewParam

public EmbeddedTaskFluent.ParamsNested<A> addNewParam()

addNewParamLike

public EmbeddedTaskFluent.ParamsNested<A> addNewParamLike(ParamSpec item)

setNewParamLike

public EmbeddedTaskFluent.ParamsNested<A> setNewParamLike(int index,
                                                          ParamSpec item)

editParam

public EmbeddedTaskFluent.ParamsNested<A> editParam(int index)

editFirstParam

public EmbeddedTaskFluent.ParamsNested<A> editFirstParam()

editLastParam

public EmbeddedTaskFluent.ParamsNested<A> editLastParam()

editMatchingParam

public EmbeddedTaskFluent.ParamsNested<A> editMatchingParam(Predicate<ParamSpecBuilder> predicate)

buildResources
```
public TaskResources buildResources()
```

withResources

public A withResources(TaskResources resources)

hasResources
```
public boolean hasResources()
```

withNewResources

public EmbeddedTaskFluent.ResourcesNested<A> withNewResources()

withNewResourcesLike

public EmbeddedTaskFluent.ResourcesNested<A> withNewResourcesLike(TaskResources item)

editResources

public EmbeddedTaskFluent.ResourcesNested<A> editResources()

editOrNewResources

public EmbeddedTaskFluent.ResourcesNested<A> editOrNewResources()

editOrNewResourcesLike

public EmbeddedTaskFluent.ResourcesNested<A> editOrNewResourcesLike(TaskResources item)

addToResults

public A addToResults(int index,
                      TaskResult item)

setToResults

public A setToResults(int index,
                      TaskResult item)

addToResults

public A addToResults(TaskResult... items)

addAllToResults

public A addAllToResults(Collection<TaskResult> items)

removeFromResults

public A removeFromResults(TaskResult... items)

removeAllFromResults

public A removeAllFromResults(Collection<TaskResult> items)

removeMatchingFromResults

public A removeMatchingFromResults(Predicate<TaskResultBuilder> predicate)

buildResults

public List<TaskResult> buildResults()

buildResult

public TaskResult buildResult(int index)

buildFirstResult
```
public TaskResult buildFirstResult()
```

buildLastResult
```
public TaskResult buildLastResult()
```

buildMatchingResult

public TaskResult buildMatchingResult(Predicate<TaskResultBuilder> predicate)

hasMatchingResult

public boolean hasMatchingResult(Predicate<TaskResultBuilder> predicate)

withResults

public A withResults(List<TaskResult> results)

withResults

public A withResults(TaskResult... results)

hasResults
```
public boolean hasResults()
```

addNewResult

public EmbeddedTaskFluent.ResultsNested<A> addNewResult()

addNewResultLike

public EmbeddedTaskFluent.ResultsNested<A> addNewResultLike(TaskResult item)

setNewResultLike

public EmbeddedTaskFluent.ResultsNested<A> setNewResultLike(int index,
                                                            TaskResult item)

editResult

public EmbeddedTaskFluent.ResultsNested<A> editResult(int index)

editFirstResult

public EmbeddedTaskFluent.ResultsNested<A> editFirstResult()

editLastResult

public EmbeddedTaskFluent.ResultsNested<A> editLastResult()

editMatchingResult

public EmbeddedTaskFluent.ResultsNested<A> editMatchingResult(Predicate<TaskResultBuilder> predicate)

addToSidecars

public A addToSidecars(int index,
                       Sidecar item)

setToSidecars

public A setToSidecars(int index,
                       Sidecar item)

addToSidecars

public A addToSidecars(Sidecar... items)

addAllToSidecars

public A addAllToSidecars(Collection<Sidecar> items)

removeFromSidecars

public A removeFromSidecars(Sidecar... items)

removeAllFromSidecars

public A removeAllFromSidecars(Collection<Sidecar> items)

removeMatchingFromSidecars

public A removeMatchingFromSidecars(Predicate<SidecarBuilder> predicate)

buildSidecars
```
public List<Sidecar> buildSidecars()
```

buildSidecar

public Sidecar buildSidecar(int index)

buildFirstSidecar
```
public Sidecar buildFirstSidecar()
```

buildLastSidecar
```
public Sidecar buildLastSidecar()
```

buildMatchingSidecar

public Sidecar buildMatchingSidecar(Predicate<SidecarBuilder> predicate)

hasMatchingSidecar

public boolean hasMatchingSidecar(Predicate<SidecarBuilder> predicate)

withSidecars

public A withSidecars(List<Sidecar> sidecars)

withSidecars

public A withSidecars(Sidecar... sidecars)

hasSidecars
```
public boolean hasSidecars()
```

addNewSidecar

public EmbeddedTaskFluent.SidecarsNested<A> addNewSidecar()

addNewSidecarLike

public EmbeddedTaskFluent.SidecarsNested<A> addNewSidecarLike(Sidecar item)

setNewSidecarLike

public EmbeddedTaskFluent.SidecarsNested<A> setNewSidecarLike(int index,
                                                              Sidecar item)

editSidecar

public EmbeddedTaskFluent.SidecarsNested<A> editSidecar(int index)

editFirstSidecar

public EmbeddedTaskFluent.SidecarsNested<A> editFirstSidecar()

editLastSidecar

public EmbeddedTaskFluent.SidecarsNested<A> editLastSidecar()

editMatchingSidecar

public EmbeddedTaskFluent.SidecarsNested<A> editMatchingSidecar(Predicate<SidecarBuilder> predicate)

addToSpec

public A addToSpec(String key,
                   Object value)

addToSpec

public A addToSpec(Map<String,Object> map)

removeFromSpec
```
public A removeFromSpec(String key)
```

removeFromSpec

public A removeFromSpec(Map<String,Object> map)

getSpec
```
public Map<String,Object> getSpec()
```

withSpec

public <K,V> A withSpec(Map<String,Object> spec)

hasSpec
```
public boolean hasSpec()
```

buildStepTemplate

public StepTemplate buildStepTemplate()

withStepTemplate

public A withStepTemplate(StepTemplate stepTemplate)

hasStepTemplate
```
public boolean hasStepTemplate()
```

withNewStepTemplate

public EmbeddedTaskFluent.StepTemplateNested<A> withNewStepTemplate()

withNewStepTemplateLike

public EmbeddedTaskFluent.StepTemplateNested<A> withNewStepTemplateLike(StepTemplate item)

editStepTemplate

public EmbeddedTaskFluent.StepTemplateNested<A> editStepTemplate()

editOrNewStepTemplate

public EmbeddedTaskFluent.StepTemplateNested<A> editOrNewStepTemplate()

editOrNewStepTemplateLike

public EmbeddedTaskFluent.StepTemplateNested<A> editOrNewStepTemplateLike(StepTemplate item)

addToSteps

public A addToSteps(int index,
                    Step item)

setToSteps

public A setToSteps(int index,
                    Step item)

addToSteps
```
public A addToSteps(Step... items)
```

addAllToSteps

public A addAllToSteps(Collection<Step> items)

removeFromSteps

public A removeFromSteps(Step... items)

removeAllFromSteps

public A removeAllFromSteps(Collection<Step> items)

removeMatchingFromSteps

public A removeMatchingFromSteps(Predicate<StepBuilder> predicate)

buildSteps
```
public List<Step> buildSteps()
```

buildStep
```
public Step buildStep(int index)
```

buildFirstStep
```
public Step buildFirstStep()
```

buildLastStep
```
public Step buildLastStep()
```

buildMatchingStep

public Step buildMatchingStep(Predicate<StepBuilder> predicate)

hasMatchingStep

public boolean hasMatchingStep(Predicate<StepBuilder> predicate)

withSteps
```
public A withSteps(List<Step> steps)
```

withSteps
```
public A withSteps(Step... steps)
```

hasSteps
```
public boolean hasSteps()
```

addNewStep

public EmbeddedTaskFluent.StepsNested<A> addNewStep()

addNewStepLike

public EmbeddedTaskFluent.StepsNested<A> addNewStepLike(Step item)

setNewStepLike

public EmbeddedTaskFluent.StepsNested<A> setNewStepLike(int index,
                                                        Step item)

editStep

public EmbeddedTaskFluent.StepsNested<A> editStep(int index)

editFirstStep

public EmbeddedTaskFluent.StepsNested<A> editFirstStep()

editLastStep

public EmbeddedTaskFluent.StepsNested<A> editLastStep()

editMatchingStep

public EmbeddedTaskFluent.StepsNested<A> editMatchingStep(Predicate<StepBuilder> predicate)

addToVolumes

public A addToVolumes(int index,
                      io.fabric8.kubernetes.api.model.Volume item)

setToVolumes

public A setToVolumes(int index,
                      io.fabric8.kubernetes.api.model.Volume item)

addToVolumes

public A addToVolumes(io.fabric8.kubernetes.api.model.Volume... items)

addAllToVolumes

public A addAllToVolumes(Collection<io.fabric8.kubernetes.api.model.Volume> items)

removeFromVolumes

public A removeFromVolumes(io.fabric8.kubernetes.api.model.Volume... items)

removeAllFromVolumes

public A removeAllFromVolumes(Collection<io.fabric8.kubernetes.api.model.Volume> items)

removeMatchingFromVolumes

public A removeMatchingFromVolumes(Predicate<io.fabric8.kubernetes.api.model.VolumeBuilder> predicate)

buildVolumes

public List<io.fabric8.kubernetes.api.model.Volume> buildVolumes()

buildVolume

public io.fabric8.kubernetes.api.model.Volume buildVolume(int index)

buildFirstVolume

public io.fabric8.kubernetes.api.model.Volume buildFirstVolume()

buildLastVolume

public io.fabric8.kubernetes.api.model.Volume buildLastVolume()

buildMatchingVolume

public io.fabric8.kubernetes.api.model.Volume buildMatchingVolume(Predicate<io.fabric8.kubernetes.api.model.VolumeBuilder> predicate)

hasMatchingVolume

public boolean hasMatchingVolume(Predicate<io.fabric8.kubernetes.api.model.VolumeBuilder> predicate)

withVolumes

public A withVolumes(List<io.fabric8.kubernetes.api.model.Volume> volumes)

withVolumes

public A withVolumes(io.fabric8.kubernetes.api.model.Volume... volumes)

hasVolumes
```
public boolean hasVolumes()
```

addNewVolume

public EmbeddedTaskFluent.VolumesNested<A> addNewVolume()

addNewVolumeLike

public EmbeddedTaskFluent.VolumesNested<A> addNewVolumeLike(io.fabric8.kubernetes.api.model.Volume item)

setNewVolumeLike

public EmbeddedTaskFluent.VolumesNested<A> setNewVolumeLike(int index,
                                                            io.fabric8.kubernetes.api.model.Volume item)

editVolume

public EmbeddedTaskFluent.VolumesNested<A> editVolume(int index)

editFirstVolume

public EmbeddedTaskFluent.VolumesNested<A> editFirstVolume()

editLastVolume

public EmbeddedTaskFluent.VolumesNested<A> editLastVolume()

editMatchingVolume

public EmbeddedTaskFluent.VolumesNested<A> editMatchingVolume(Predicate<io.fabric8.kubernetes.api.model.VolumeBuilder> predicate)

addToWorkspaces

public A addToWorkspaces(int index,
                         WorkspaceDeclaration item)

setToWorkspaces

public A setToWorkspaces(int index,
                         WorkspaceDeclaration item)

addToWorkspaces

public A addToWorkspaces(WorkspaceDeclaration... items)

addAllToWorkspaces

public A addAllToWorkspaces(Collection<WorkspaceDeclaration> items)

removeFromWorkspaces

public A removeFromWorkspaces(WorkspaceDeclaration... items)

removeAllFromWorkspaces

public A removeAllFromWorkspaces(Collection<WorkspaceDeclaration> items)

removeMatchingFromWorkspaces

public A removeMatchingFromWorkspaces(Predicate<WorkspaceDeclarationBuilder> predicate)

buildWorkspaces

public List<WorkspaceDeclaration> buildWorkspaces()

buildWorkspace

public WorkspaceDeclaration buildWorkspace(int index)

buildFirstWorkspace

public WorkspaceDeclaration buildFirstWorkspace()

buildLastWorkspace

public WorkspaceDeclaration buildLastWorkspace()

buildMatchingWorkspace

public WorkspaceDeclaration buildMatchingWorkspace(Predicate<WorkspaceDeclarationBuilder> predicate)

hasMatchingWorkspace

public boolean hasMatchingWorkspace(Predicate<WorkspaceDeclarationBuilder> predicate)

withWorkspaces

public A withWorkspaces(List<WorkspaceDeclaration> workspaces)

withWorkspaces

public A withWorkspaces(WorkspaceDeclaration... workspaces)

hasWorkspaces
```
public boolean hasWorkspaces()
```

addNewWorkspace

public A addNewWorkspace(String description,
                         String mountPath,
                         String name,
                         Boolean optional,
                         Boolean readOnly)

addNewWorkspace

public EmbeddedTaskFluent.WorkspacesNested<A> addNewWorkspace()

addNewWorkspaceLike

public EmbeddedTaskFluent.WorkspacesNested<A> addNewWorkspaceLike(WorkspaceDeclaration item)

setNewWorkspaceLike

public EmbeddedTaskFluent.WorkspacesNested<A> setNewWorkspaceLike(int index,
                                                                  WorkspaceDeclaration item)

editWorkspace

public EmbeddedTaskFluent.WorkspacesNested<A> editWorkspace(int index)

editFirstWorkspace

public EmbeddedTaskFluent.WorkspacesNested<A> editFirstWorkspace()

editLastWorkspace

public EmbeddedTaskFluent.WorkspacesNested<A> editLastWorkspace()

editMatchingWorkspace

public EmbeddedTaskFluent.WorkspacesNested<A> editMatchingWorkspace(Predicate<WorkspaceDeclarationBuilder> predicate)

addToAdditionalProperties

public A addToAdditionalProperties(String key,
                                   Object value)

addToAdditionalProperties

public A addToAdditionalProperties(Map<String,Object> map)

removeFromAdditionalProperties

public A removeFromAdditionalProperties(String key)

removeFromAdditionalProperties

public A removeFromAdditionalProperties(Map<String,Object> map)

getAdditionalProperties

public Map<String,Object> getAdditionalProperties()

withAdditionalProperties

public <K,V> A withAdditionalProperties(Map<String,Object> additionalProperties)

hasAdditionalProperties

public boolean hasAdditionalProperties()

equals
```
public boolean equals(Object o)
```
Overrides:

equals in class io.fabric8.kubernetes.api.builder.BaseFluent<A extends EmbeddedTaskFluent<A>>

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class io.fabric8.kubernetes.api.builder.BaseFluent<A extends EmbeddedTaskFluent<A>>

toString
```
public String toString()
```
Overrides:

toString in class Object

Class EmbeddedTaskFluent<A extends EmbeddedTaskFluent<A>>

Nested Class Summary

Field Summary

Fields inherited from class io.fabric8.kubernetes.api.builder.BaseFluent

Constructor Summary

Method Summary

Methods inherited from class io.fabric8.kubernetes.api.builder.BaseFluent

Methods inherited from class java.lang.Object

Constructor Detail

EmbeddedTaskFluent

EmbeddedTaskFluent

Method Detail

copyInstance

getApiVersion

withApiVersion

hasApiVersion

getDescription

withDescription

hasDescription

getDisplayName

withDisplayName

hasDisplayName

getKind

withKind

hasKind

buildMetadata

withMetadata

hasMetadata

withNewMetadata

withNewMetadataLike

editMetadata

editOrNewMetadata

editOrNewMetadataLike

addToParams

setToParams

addToParams

addAllToParams

removeFromParams

removeAllFromParams

removeMatchingFromParams

buildParams

buildParam

buildFirstParam

buildLastParam

buildMatchingParam

hasMatchingParam

withParams

withParams

hasParams

addNewParam

addNewParamLike

setNewParamLike

editParam

editFirstParam

editLastParam

editMatchingParam

buildResources

withResources

hasResources

withNewResources

withNewResourcesLike

editResources

editOrNewResources

editOrNewResourcesLike

addToResults

setToResults

addToResults

addAllToResults

removeFromResults

removeAllFromResults

removeMatchingFromResults

buildResults

buildResult

buildFirstResult

buildLastResult

buildMatchingResult

hasMatchingResult

withResults

withResults

hasResults