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

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

Direct Known Subclasses:: PipelineSpecFluent.FinallyNested, PipelineSpecFluent.TasksNested, PipelineTaskBuilder

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

Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`PipelineTaskFluent.MatrixNested<N>`
`class`	`PipelineTaskFluent.ParamsNested<N>`
`class`	`PipelineTaskFluent.ResourcesNested<N>`
`class`	`PipelineTaskFluent.TaskRefNested<N>`
`class`	`PipelineTaskFluent.TaskSpecNested<N>`
`class`	`PipelineTaskFluent.WhenNested<N>`
`class`	`PipelineTaskFluent.WorkspacesNested<N>`

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

Constructor Summary

Constructors
Constructor and Description

PipelineTaskFluent()

PipelineTaskFluent(PipelineTask instance)

Constructors
Constructor and Description
`PipelineTaskFluent()`
`PipelineTaskFluent(PipelineTask instance)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`A`	`addAllToParams(Collection<Param> items)`
`A`	`addAllToRunAfter(Collection<String> items)`
`A`	`addAllToWhen(Collection<WhenExpression> items)`
`A`	`addAllToWorkspaces(Collection<WorkspacePipelineTaskBinding> items)`
`PipelineTaskFluent.ParamsNested<A>`	`addNewParam()`
`PipelineTaskFluent.ParamsNested<A>`	`addNewParamLike(Param item)`
`PipelineTaskFluent.WhenNested<A>`	`addNewWhen()`
`PipelineTaskFluent.WhenNested<A>`	`addNewWhenLike(WhenExpression item)`
`PipelineTaskFluent.WorkspacesNested<A>`	`addNewWorkspace()`
`A`	`addNewWorkspace(String name, String subPath, String workspace)`
`PipelineTaskFluent.WorkspacesNested<A>`	`addNewWorkspaceLike(WorkspacePipelineTaskBinding item)`
`A`	`addToAdditionalProperties(Map<String,Object> map)`
`A`	`addToAdditionalProperties(String key, Object value)`
`A`	`addToParams(int index, Param item)`
`A`	`addToParams(Param... items)`
`A`	`addToRunAfter(int index, String item)`
`A`	`addToRunAfter(String... items)`
`A`	`addToWhen(int index, WhenExpression item)`
`A`	`addToWhen(WhenExpression... items)`
`A`	`addToWorkspaces(int index, WorkspacePipelineTaskBinding item)`
`A`	`addToWorkspaces(WorkspacePipelineTaskBinding... items)`
`Param`	`buildFirstParam()`
`WhenExpression`	`buildFirstWhen()`
`WorkspacePipelineTaskBinding`	`buildFirstWorkspace()`
`Param`	`buildLastParam()`
`WhenExpression`	`buildLastWhen()`
`WorkspacePipelineTaskBinding`	`buildLastWorkspace()`
`Param`	`buildMatchingParam(Predicate<ParamBuilder> predicate)`
`WhenExpression`	`buildMatchingWhen(Predicate<WhenExpressionBuilder> predicate)`
`WorkspacePipelineTaskBinding`	`buildMatchingWorkspace(Predicate<WorkspacePipelineTaskBindingBuilder> predicate)`
`Matrix`	`buildMatrix()`
`Param`	`buildParam(int index)`
`List<Param>`	`buildParams()`
`PipelineTaskResources`	`buildResources()`
`TaskRef`	`buildTaskRef()`
`EmbeddedTask`	`buildTaskSpec()`
`List<WhenExpression>`	`buildWhen()`
`WhenExpression`	`buildWhen(int index)`
`WorkspacePipelineTaskBinding`	`buildWorkspace(int index)`
`List<WorkspacePipelineTaskBinding>`	`buildWorkspaces()`
`protected void`	`copyInstance(PipelineTask instance)`
`PipelineTaskFluent.ParamsNested<A>`	`editFirstParam()`
`PipelineTaskFluent.WhenNested<A>`	`editFirstWhen()`
`PipelineTaskFluent.WorkspacesNested<A>`	`editFirstWorkspace()`
`PipelineTaskFluent.ParamsNested<A>`	`editLastParam()`
`PipelineTaskFluent.WhenNested<A>`	`editLastWhen()`
`PipelineTaskFluent.WorkspacesNested<A>`	`editLastWorkspace()`
`PipelineTaskFluent.ParamsNested<A>`	`editMatchingParam(Predicate<ParamBuilder> predicate)`
`PipelineTaskFluent.WhenNested<A>`	`editMatchingWhen(Predicate<WhenExpressionBuilder> predicate)`
`PipelineTaskFluent.WorkspacesNested<A>`	`editMatchingWorkspace(Predicate<WorkspacePipelineTaskBindingBuilder> predicate)`
`PipelineTaskFluent.MatrixNested<A>`	`editMatrix()`
`PipelineTaskFluent.MatrixNested<A>`	`editOrNewMatrix()`
`PipelineTaskFluent.MatrixNested<A>`	`editOrNewMatrixLike(Matrix item)`
`PipelineTaskFluent.ResourcesNested<A>`	`editOrNewResources()`
`PipelineTaskFluent.ResourcesNested<A>`	`editOrNewResourcesLike(PipelineTaskResources item)`
`PipelineTaskFluent.TaskRefNested<A>`	`editOrNewTaskRef()`
`PipelineTaskFluent.TaskRefNested<A>`	`editOrNewTaskRefLike(TaskRef item)`
`PipelineTaskFluent.TaskSpecNested<A>`	`editOrNewTaskSpec()`
`PipelineTaskFluent.TaskSpecNested<A>`	`editOrNewTaskSpecLike(EmbeddedTask item)`
`PipelineTaskFluent.ParamsNested<A>`	`editParam(int index)`
`PipelineTaskFluent.ResourcesNested<A>`	`editResources()`
`PipelineTaskFluent.TaskRefNested<A>`	`editTaskRef()`
`PipelineTaskFluent.TaskSpecNested<A>`	`editTaskSpec()`
`PipelineTaskFluent.WhenNested<A>`	`editWhen(int index)`
`PipelineTaskFluent.WorkspacesNested<A>`	`editWorkspace(int index)`
`boolean`	`equals(Object o)`
`Map<String,Object>`	`getAdditionalProperties()`
`String`	`getDescription()`
`String`	`getDisplayName()`
`String`	`getFirstRunAfter()`
`String`	`getLastRunAfter()`
`String`	`getMatchingRunAfter(Predicate<String> predicate)`
`String`	`getName()`
`Integer`	`getRetries()`
`List<String>`	`getRunAfter()`
`String`	`getRunAfter(int index)`
`io.fabric8.kubernetes.api.model.Duration`	`getTimeout()`
`boolean`	`hasAdditionalProperties()`
`boolean`	`hasDescription()`
`boolean`	`hasDisplayName()`
`int`	`hashCode()`
`boolean`	`hasMatchingParam(Predicate<ParamBuilder> predicate)`
`boolean`	`hasMatchingRunAfter(Predicate<String> predicate)`
`boolean`	`hasMatchingWhen(Predicate<WhenExpressionBuilder> predicate)`
`boolean`	`hasMatchingWorkspace(Predicate<WorkspacePipelineTaskBindingBuilder> predicate)`
`boolean`	`hasMatrix()`
`boolean`	`hasName()`
`boolean`	`hasParams()`
`boolean`	`hasResources()`
`boolean`	`hasRetries()`
`boolean`	`hasRunAfter()`
`boolean`	`hasTaskRef()`
`boolean`	`hasTaskSpec()`
`boolean`	`hasTimeout()`
`boolean`	`hasWhen()`
`boolean`	`hasWorkspaces()`
`A`	`removeAllFromParams(Collection<Param> items)`
`A`	`removeAllFromRunAfter(Collection<String> items)`
`A`	`removeAllFromWhen(Collection<WhenExpression> items)`
`A`	`removeAllFromWorkspaces(Collection<WorkspacePipelineTaskBinding> items)`
`A`	`removeFromAdditionalProperties(Map<String,Object> map)`
`A`	`removeFromAdditionalProperties(String key)`
`A`	`removeFromParams(Param... items)`
`A`	`removeFromRunAfter(String... items)`
`A`	`removeFromWhen(WhenExpression... items)`
`A`	`removeFromWorkspaces(WorkspacePipelineTaskBinding... items)`
`A`	`removeMatchingFromParams(Predicate<ParamBuilder> predicate)`
`A`	`removeMatchingFromWhen(Predicate<WhenExpressionBuilder> predicate)`
`A`	`removeMatchingFromWorkspaces(Predicate<WorkspacePipelineTaskBindingBuilder> predicate)`
`PipelineTaskFluent.ParamsNested<A>`	`setNewParamLike(int index, Param item)`
`PipelineTaskFluent.WhenNested<A>`	`setNewWhenLike(int index, WhenExpression item)`
`PipelineTaskFluent.WorkspacesNested<A>`	`setNewWorkspaceLike(int index, WorkspacePipelineTaskBinding item)`
`A`	`setToParams(int index, Param item)`
`A`	`setToRunAfter(int index, String item)`
`A`	`setToWhen(int index, WhenExpression item)`
`A`	`setToWorkspaces(int index, WorkspacePipelineTaskBinding item)`
`String`	`toString()`
`<K,V> A`	`withAdditionalProperties(Map<String,Object> additionalProperties)`
`A`	`withDescription(String description)`
`A`	`withDisplayName(String displayName)`
`A`	`withMatrix(Matrix matrix)`
`A`	`withName(String name)`
`PipelineTaskFluent.MatrixNested<A>`	`withNewMatrix()`
`PipelineTaskFluent.MatrixNested<A>`	`withNewMatrixLike(Matrix item)`
`PipelineTaskFluent.ResourcesNested<A>`	`withNewResources()`
`PipelineTaskFluent.ResourcesNested<A>`	`withNewResourcesLike(PipelineTaskResources item)`
`PipelineTaskFluent.TaskRefNested<A>`	`withNewTaskRef()`
`PipelineTaskFluent.TaskRefNested<A>`	`withNewTaskRefLike(TaskRef item)`
`PipelineTaskFluent.TaskSpecNested<A>`	`withNewTaskSpec()`
`PipelineTaskFluent.TaskSpecNested<A>`	`withNewTaskSpecLike(EmbeddedTask item)`
`A`	`withParams(List<Param> params)`
`A`	`withParams(Param... params)`
`A`	`withResources(PipelineTaskResources resources)`
`A`	`withRetries(Integer retries)`
`A`	`withRunAfter(List<String> runAfter)`
`A`	`withRunAfter(String... runAfter)`
`A`	`withTaskRef(TaskRef taskRef)`
`A`	`withTaskSpec(EmbeddedTask taskSpec)`
`A`	`withTimeout(io.fabric8.kubernetes.api.model.Duration timeout)`
`A`	`withWhen(List<WhenExpression> when)`
`A`	`withWhen(WhenExpression... when)`
`A`	`withWorkspaces(List<WorkspacePipelineTaskBinding> workspaces)`
`A`	`withWorkspaces(WorkspacePipelineTaskBinding... 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

PipelineTaskFluent
```
public PipelineTaskFluent()
```

PipelineTaskFluent

public PipelineTaskFluent(PipelineTask instance)

Method Detail

copyInstance

protected void copyInstance(PipelineTask 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()
```

buildMatrix
```
public Matrix buildMatrix()
```

withMatrix
```
public A withMatrix(Matrix matrix)
```

hasMatrix
```
public boolean hasMatrix()
```

withNewMatrix

public PipelineTaskFluent.MatrixNested<A> withNewMatrix()

withNewMatrixLike

public PipelineTaskFluent.MatrixNested<A> withNewMatrixLike(Matrix item)

editMatrix

public PipelineTaskFluent.MatrixNested<A> editMatrix()

editOrNewMatrix

public PipelineTaskFluent.MatrixNested<A> editOrNewMatrix()

editOrNewMatrixLike

public PipelineTaskFluent.MatrixNested<A> editOrNewMatrixLike(Matrix item)

getName
```
public String getName()
```

withName
```
public A withName(String name)
```

hasName
```
public boolean hasName()
```

addToParams

public A addToParams(int index,
                     Param item)

setToParams

public A setToParams(int index,
                     Param item)

addToParams
```
public A addToParams(Param... items)
```

addAllToParams

public A addAllToParams(Collection<Param> items)

removeFromParams

public A removeFromParams(Param... items)

removeAllFromParams

public A removeAllFromParams(Collection<Param> items)

removeMatchingFromParams

public A removeMatchingFromParams(Predicate<ParamBuilder> predicate)

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

buildParam
```
public Param buildParam(int index)
```

buildFirstParam
```
public Param buildFirstParam()
```

buildLastParam
```
public Param buildLastParam()
```

buildMatchingParam

public Param buildMatchingParam(Predicate<ParamBuilder> predicate)

hasMatchingParam

public boolean hasMatchingParam(Predicate<ParamBuilder> predicate)

withParams

public A withParams(List<Param> params)

withParams
```
public A withParams(Param... params)
```

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

addNewParam

public PipelineTaskFluent.ParamsNested<A> addNewParam()

addNewParamLike

public PipelineTaskFluent.ParamsNested<A> addNewParamLike(Param item)

setNewParamLike

public PipelineTaskFluent.ParamsNested<A> setNewParamLike(int index,
                                                          Param item)

editParam

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

editFirstParam

public PipelineTaskFluent.ParamsNested<A> editFirstParam()

editLastParam

public PipelineTaskFluent.ParamsNested<A> editLastParam()

editMatchingParam

public PipelineTaskFluent.ParamsNested<A> editMatchingParam(Predicate<ParamBuilder> predicate)

buildResources

public PipelineTaskResources buildResources()

withResources

public A withResources(PipelineTaskResources resources)

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

withNewResources

public PipelineTaskFluent.ResourcesNested<A> withNewResources()

withNewResourcesLike

public PipelineTaskFluent.ResourcesNested<A> withNewResourcesLike(PipelineTaskResources item)

editResources

public PipelineTaskFluent.ResourcesNested<A> editResources()

editOrNewResources

public PipelineTaskFluent.ResourcesNested<A> editOrNewResources()

editOrNewResourcesLike

public PipelineTaskFluent.ResourcesNested<A> editOrNewResourcesLike(PipelineTaskResources item)

getRetries
```
public Integer getRetries()
```

withRetries

public A withRetries(Integer retries)

hasRetries
```
public boolean hasRetries()
```

addToRunAfter

public A addToRunAfter(int index,
                       String item)

setToRunAfter

public A setToRunAfter(int index,
                       String item)

addToRunAfter

public A addToRunAfter(String... items)

addAllToRunAfter

public A addAllToRunAfter(Collection<String> items)

removeFromRunAfter

public A removeFromRunAfter(String... items)

removeAllFromRunAfter

public A removeAllFromRunAfter(Collection<String> items)

getRunAfter
```
public List<String> getRunAfter()
```

getRunAfter
```
public String getRunAfter(int index)
```

getFirstRunAfter
```
public String getFirstRunAfter()
```

getLastRunAfter
```
public String getLastRunAfter()
```

getMatchingRunAfter

public String getMatchingRunAfter(Predicate<String> predicate)

hasMatchingRunAfter

public boolean hasMatchingRunAfter(Predicate<String> predicate)

withRunAfter

public A withRunAfter(List<String> runAfter)

withRunAfter

public A withRunAfter(String... runAfter)

hasRunAfter
```
public boolean hasRunAfter()
```

buildTaskRef
```
public TaskRef buildTaskRef()
```

withTaskRef

public A withTaskRef(TaskRef taskRef)

hasTaskRef
```
public boolean hasTaskRef()
```

withNewTaskRef

public PipelineTaskFluent.TaskRefNested<A> withNewTaskRef()

withNewTaskRefLike

public PipelineTaskFluent.TaskRefNested<A> withNewTaskRefLike(TaskRef item)

editTaskRef

public PipelineTaskFluent.TaskRefNested<A> editTaskRef()

editOrNewTaskRef

public PipelineTaskFluent.TaskRefNested<A> editOrNewTaskRef()

editOrNewTaskRefLike

public PipelineTaskFluent.TaskRefNested<A> editOrNewTaskRefLike(TaskRef item)

buildTaskSpec
```
public EmbeddedTask buildTaskSpec()
```

withTaskSpec

public A withTaskSpec(EmbeddedTask taskSpec)

hasTaskSpec
```
public boolean hasTaskSpec()
```

withNewTaskSpec

public PipelineTaskFluent.TaskSpecNested<A> withNewTaskSpec()

withNewTaskSpecLike

public PipelineTaskFluent.TaskSpecNested<A> withNewTaskSpecLike(EmbeddedTask item)

editTaskSpec

public PipelineTaskFluent.TaskSpecNested<A> editTaskSpec()

editOrNewTaskSpec

public PipelineTaskFluent.TaskSpecNested<A> editOrNewTaskSpec()

editOrNewTaskSpecLike

public PipelineTaskFluent.TaskSpecNested<A> editOrNewTaskSpecLike(EmbeddedTask item)

getTimeout

public io.fabric8.kubernetes.api.model.Duration getTimeout()

withTimeout

public A withTimeout(io.fabric8.kubernetes.api.model.Duration timeout)

hasTimeout
```
public boolean hasTimeout()
```

addToWhen

public A addToWhen(int index,
                   WhenExpression item)

setToWhen

public A setToWhen(int index,
                   WhenExpression item)

addToWhen

public A addToWhen(WhenExpression... items)

addAllToWhen

public A addAllToWhen(Collection<WhenExpression> items)

removeFromWhen

public A removeFromWhen(WhenExpression... items)

removeAllFromWhen

public A removeAllFromWhen(Collection<WhenExpression> items)

removeMatchingFromWhen

public A removeMatchingFromWhen(Predicate<WhenExpressionBuilder> predicate)

buildWhen

public List<WhenExpression> buildWhen()

buildWhen

public WhenExpression buildWhen(int index)

buildFirstWhen

public WhenExpression buildFirstWhen()

buildLastWhen
```
public WhenExpression buildLastWhen()
```

buildMatchingWhen

public WhenExpression buildMatchingWhen(Predicate<WhenExpressionBuilder> predicate)

hasMatchingWhen

public boolean hasMatchingWhen(Predicate<WhenExpressionBuilder> predicate)

withWhen

public A withWhen(List<WhenExpression> when)

withWhen

public A withWhen(WhenExpression... when)

hasWhen
```
public boolean hasWhen()
```

addNewWhen

public PipelineTaskFluent.WhenNested<A> addNewWhen()

addNewWhenLike

public PipelineTaskFluent.WhenNested<A> addNewWhenLike(WhenExpression item)

setNewWhenLike

public PipelineTaskFluent.WhenNested<A> setNewWhenLike(int index,
                                                       WhenExpression item)

editWhen

public PipelineTaskFluent.WhenNested<A> editWhen(int index)

editFirstWhen

public PipelineTaskFluent.WhenNested<A> editFirstWhen()

editLastWhen

public PipelineTaskFluent.WhenNested<A> editLastWhen()

editMatchingWhen

public PipelineTaskFluent.WhenNested<A> editMatchingWhen(Predicate<WhenExpressionBuilder> predicate)

addToWorkspaces

public A addToWorkspaces(int index,
                         WorkspacePipelineTaskBinding item)

setToWorkspaces

public A setToWorkspaces(int index,
                         WorkspacePipelineTaskBinding item)

addToWorkspaces

public A addToWorkspaces(WorkspacePipelineTaskBinding... items)

addAllToWorkspaces

public A addAllToWorkspaces(Collection<WorkspacePipelineTaskBinding> items)

removeFromWorkspaces

public A removeFromWorkspaces(WorkspacePipelineTaskBinding... items)

removeAllFromWorkspaces

public A removeAllFromWorkspaces(Collection<WorkspacePipelineTaskBinding> items)

removeMatchingFromWorkspaces

public A removeMatchingFromWorkspaces(Predicate<WorkspacePipelineTaskBindingBuilder> predicate)

buildWorkspaces

public List<WorkspacePipelineTaskBinding> buildWorkspaces()

buildWorkspace

public WorkspacePipelineTaskBinding buildWorkspace(int index)

buildFirstWorkspace

public WorkspacePipelineTaskBinding buildFirstWorkspace()

buildLastWorkspace

public WorkspacePipelineTaskBinding buildLastWorkspace()

buildMatchingWorkspace

public WorkspacePipelineTaskBinding buildMatchingWorkspace(Predicate<WorkspacePipelineTaskBindingBuilder> predicate)

hasMatchingWorkspace

public boolean hasMatchingWorkspace(Predicate<WorkspacePipelineTaskBindingBuilder> predicate)

withWorkspaces

public A withWorkspaces(List<WorkspacePipelineTaskBinding> workspaces)

withWorkspaces

public A withWorkspaces(WorkspacePipelineTaskBinding... workspaces)

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

addNewWorkspace

public A addNewWorkspace(String name,
                         String subPath,
                         String workspace)

addNewWorkspace

public PipelineTaskFluent.WorkspacesNested<A> addNewWorkspace()

addNewWorkspaceLike

public PipelineTaskFluent.WorkspacesNested<A> addNewWorkspaceLike(WorkspacePipelineTaskBinding item)

setNewWorkspaceLike

public PipelineTaskFluent.WorkspacesNested<A> setNewWorkspaceLike(int index,
                                                                  WorkspacePipelineTaskBinding item)

editWorkspace

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

editFirstWorkspace

public PipelineTaskFluent.WorkspacesNested<A> editFirstWorkspace()

editLastWorkspace

public PipelineTaskFluent.WorkspacesNested<A> editLastWorkspace()

editMatchingWorkspace

public PipelineTaskFluent.WorkspacesNested<A> editMatchingWorkspace(Predicate<WorkspacePipelineTaskBindingBuilder> 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 PipelineTaskFluent<A>>

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

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

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

toString in class Object

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

PipelineTaskFluent

PipelineTaskFluent

Method Detail

copyInstance

getDescription

withDescription

hasDescription

getDisplayName

withDisplayName

hasDisplayName

buildMatrix

withMatrix

hasMatrix

withNewMatrix

withNewMatrixLike

editMatrix

editOrNewMatrix

editOrNewMatrixLike

getName

withName

hasName

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

getRetries

withRetries

hasRetries

addToRunAfter

setToRunAfter

addToRunAfter

addAllToRunAfter

removeFromRunAfter

removeAllFromRunAfter

getRunAfter

getRunAfter

getFirstRunAfter

getLastRunAfter

getMatchingRunAfter

hasMatchingRunAfter

withRunAfter

withRunAfter

hasRunAfter

buildTaskRef