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

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

Direct Known Subclasses:

ClusterTaskFluent.SpecNested, TaskFluent.SpecNested, TaskRunSpecFluent.TaskSpecNested, TaskRunStatusFluent.TaskSpecNested, TaskSpecBuilder
```
public class TaskSpecFluent<A extends TaskSpecFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>
```
Generated

Nested Class Summary

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

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

Constructor Summary

Constructors
Constructor and Description

TaskSpecFluent()

TaskSpecFluent(TaskSpec instance)

Constructors
Constructor and Description
`TaskSpecFluent()`
`TaskSpecFluent(TaskSpec 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)`
`TaskSpecFluent.ParamsNested<A>`	`addNewParam()`
`TaskSpecFluent.ParamsNested<A>`	`addNewParamLike(ParamSpec item)`
`TaskSpecFluent.ResultsNested<A>`	`addNewResult()`
`TaskSpecFluent.ResultsNested<A>`	`addNewResultLike(TaskResult item)`
`TaskSpecFluent.SidecarsNested<A>`	`addNewSidecar()`
`TaskSpecFluent.SidecarsNested<A>`	`addNewSidecarLike(Sidecar item)`
`TaskSpecFluent.StepsNested<A>`	`addNewStep()`
`TaskSpecFluent.StepsNested<A>`	`addNewStepLike(Step item)`
`TaskSpecFluent.VolumesNested<A>`	`addNewVolume()`
`TaskSpecFluent.VolumesNested<A>`	`addNewVolumeLike(io.fabric8.kubernetes.api.model.Volume item)`
`TaskSpecFluent.WorkspacesNested<A>`	`addNewWorkspace()`
`A`	`addNewWorkspace(String description, String mountPath, String name, Boolean optional, Boolean readOnly)`
`TaskSpecFluent.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`	`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)`
`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(TaskSpec instance)`
`TaskSpecFluent.ParamsNested<A>`	`editFirstParam()`
`TaskSpecFluent.ResultsNested<A>`	`editFirstResult()`
`TaskSpecFluent.SidecarsNested<A>`	`editFirstSidecar()`
`TaskSpecFluent.StepsNested<A>`	`editFirstStep()`
`TaskSpecFluent.VolumesNested<A>`	`editFirstVolume()`
`TaskSpecFluent.WorkspacesNested<A>`	`editFirstWorkspace()`
`TaskSpecFluent.ParamsNested<A>`	`editLastParam()`
`TaskSpecFluent.ResultsNested<A>`	`editLastResult()`
`TaskSpecFluent.SidecarsNested<A>`	`editLastSidecar()`
`TaskSpecFluent.StepsNested<A>`	`editLastStep()`
`TaskSpecFluent.VolumesNested<A>`	`editLastVolume()`
`TaskSpecFluent.WorkspacesNested<A>`	`editLastWorkspace()`
`TaskSpecFluent.ParamsNested<A>`	`editMatchingParam(Predicate<ParamSpecBuilder> predicate)`
`TaskSpecFluent.ResultsNested<A>`	`editMatchingResult(Predicate<TaskResultBuilder> predicate)`
`TaskSpecFluent.SidecarsNested<A>`	`editMatchingSidecar(Predicate<SidecarBuilder> predicate)`
`TaskSpecFluent.StepsNested<A>`	`editMatchingStep(Predicate<StepBuilder> predicate)`
`TaskSpecFluent.VolumesNested<A>`	`editMatchingVolume(Predicate<io.fabric8.kubernetes.api.model.VolumeBuilder> predicate)`
`TaskSpecFluent.WorkspacesNested<A>`	`editMatchingWorkspace(Predicate<WorkspaceDeclarationBuilder> predicate)`
`TaskSpecFluent.ResourcesNested<A>`	`editOrNewResources()`
`TaskSpecFluent.ResourcesNested<A>`	`editOrNewResourcesLike(TaskResources item)`
`TaskSpecFluent.StepTemplateNested<A>`	`editOrNewStepTemplate()`
`TaskSpecFluent.StepTemplateNested<A>`	`editOrNewStepTemplateLike(StepTemplate item)`
`TaskSpecFluent.ParamsNested<A>`	`editParam(int index)`
`TaskSpecFluent.ResourcesNested<A>`	`editResources()`
`TaskSpecFluent.ResultsNested<A>`	`editResult(int index)`
`TaskSpecFluent.SidecarsNested<A>`	`editSidecar(int index)`
`TaskSpecFluent.StepsNested<A>`	`editStep(int index)`
`TaskSpecFluent.StepTemplateNested<A>`	`editStepTemplate()`
`TaskSpecFluent.VolumesNested<A>`	`editVolume(int index)`
`TaskSpecFluent.WorkspacesNested<A>`	`editWorkspace(int index)`
`boolean`	`equals(Object o)`
`Map<String,Object>`	`getAdditionalProperties()`
`String`	`getDescription()`
`String`	`getDisplayName()`
`boolean`	`hasAdditionalProperties()`
`boolean`	`hasDescription()`
`boolean`	`hasDisplayName()`
`int`	`hashCode()`
`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`	`hasParams()`
`boolean`	`hasResources()`
`boolean`	`hasResults()`
`boolean`	`hasSidecars()`
`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`	`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)`
`TaskSpecFluent.ParamsNested<A>`	`setNewParamLike(int index, ParamSpec item)`
`TaskSpecFluent.ResultsNested<A>`	`setNewResultLike(int index, TaskResult item)`
`TaskSpecFluent.SidecarsNested<A>`	`setNewSidecarLike(int index, Sidecar item)`
`TaskSpecFluent.StepsNested<A>`	`setNewStepLike(int index, Step item)`
`TaskSpecFluent.VolumesNested<A>`	`setNewVolumeLike(int index, io.fabric8.kubernetes.api.model.Volume item)`
`TaskSpecFluent.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`	`withDescription(String description)`
`A`	`withDisplayName(String displayName)`
`TaskSpecFluent.ResourcesNested<A>`	`withNewResources()`
`TaskSpecFluent.ResourcesNested<A>`	`withNewResourcesLike(TaskResources item)`
`TaskSpecFluent.StepTemplateNested<A>`	`withNewStepTemplate()`
`TaskSpecFluent.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)`
`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

TaskSpecFluent
```
public TaskSpecFluent()
```

TaskSpecFluent

public TaskSpecFluent(TaskSpec instance)

Method Detail

copyInstance

protected void copyInstance(TaskSpec instance)

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()
```

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 TaskSpecFluent.ParamsNested<A> addNewParam()

addNewParamLike

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

setNewParamLike

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

editParam

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

editFirstParam

public TaskSpecFluent.ParamsNested<A> editFirstParam()

editLastParam

public TaskSpecFluent.ParamsNested<A> editLastParam()

editMatchingParam

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

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

withResources

public A withResources(TaskResources resources)

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

withNewResources

public TaskSpecFluent.ResourcesNested<A> withNewResources()

withNewResourcesLike

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

editResources

public TaskSpecFluent.ResourcesNested<A> editResources()

editOrNewResources

public TaskSpecFluent.ResourcesNested<A> editOrNewResources()

editOrNewResourcesLike

public TaskSpecFluent.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 TaskSpecFluent.ResultsNested<A> addNewResult()

addNewResultLike

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

setNewResultLike

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

editResult

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

editFirstResult

public TaskSpecFluent.ResultsNested<A> editFirstResult()

editLastResult

public TaskSpecFluent.ResultsNested<A> editLastResult()

editMatchingResult

public TaskSpecFluent.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 TaskSpecFluent.SidecarsNested<A> addNewSidecar()

addNewSidecarLike

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

setNewSidecarLike

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

editSidecar

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

editFirstSidecar

public TaskSpecFluent.SidecarsNested<A> editFirstSidecar()

editLastSidecar

public TaskSpecFluent.SidecarsNested<A> editLastSidecar()

editMatchingSidecar

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

buildStepTemplate

public StepTemplate buildStepTemplate()

withStepTemplate

public A withStepTemplate(StepTemplate stepTemplate)

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

withNewStepTemplate

public TaskSpecFluent.StepTemplateNested<A> withNewStepTemplate()

withNewStepTemplateLike

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

editStepTemplate

public TaskSpecFluent.StepTemplateNested<A> editStepTemplate()

editOrNewStepTemplate

public TaskSpecFluent.StepTemplateNested<A> editOrNewStepTemplate()

editOrNewStepTemplateLike

public TaskSpecFluent.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 TaskSpecFluent.StepsNested<A> addNewStep()

addNewStepLike

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

setNewStepLike

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

editStep

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

editFirstStep

public TaskSpecFluent.StepsNested<A> editFirstStep()

editLastStep

public TaskSpecFluent.StepsNested<A> editLastStep()

editMatchingStep

public TaskSpecFluent.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 TaskSpecFluent.VolumesNested<A> addNewVolume()

addNewVolumeLike

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

setNewVolumeLike

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

editVolume

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

editFirstVolume

public TaskSpecFluent.VolumesNested<A> editFirstVolume()

editLastVolume

public TaskSpecFluent.VolumesNested<A> editLastVolume()

editMatchingVolume

public TaskSpecFluent.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 TaskSpecFluent.WorkspacesNested<A> addNewWorkspace()

addNewWorkspaceLike

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

setNewWorkspaceLike

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

editWorkspace

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

editFirstWorkspace

public TaskSpecFluent.WorkspacesNested<A> editFirstWorkspace()

editLastWorkspace

public TaskSpecFluent.WorkspacesNested<A> editLastWorkspace()

editMatchingWorkspace

public TaskSpecFluent.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 TaskSpecFluent<A>>

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

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

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

toString in class Object

Class TaskSpecFluent<A extends TaskSpecFluent<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

TaskSpecFluent

TaskSpecFluent

Method Detail

copyInstance

getDescription

withDescription

hasDescription

getDisplayName

withDisplayName

hasDisplayName

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

addNewResult

addNewResultLike

setNewResultLike

editResult

editFirstResult

editLastResult

editMatchingResult

addToSidecars

setToSidecars

addToSidecars

addAllToSidecars

removeFromSidecars

removeAllFromSidecars

removeMatchingFromSidecars