io.fabric8.tekton.pipeline.v1

Interface MatrixFluent<A extends MatrixFluent<A>>

All Superinterfaces:

io.fabric8.kubernetes.api.builder.Fluent<A>

All Known Subinterfaces:

PipelineTaskFluent.MatrixNested<N>

All Known Implementing Classes:

MatrixBuilder, MatrixFluentImpl

public interface MatrixFluent<A extends MatrixFluent<A>>
extends io.fabric8.kubernetes.api.builder.Fluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	MatrixFluent.IncludeNested<N>
static interface	MatrixFluent.ParamsNested<N>

Method Summary

Modifier and Type	Method and Description
A	addAllToInclude(Collection<IncludeParams> items)
A	addAllToParams(Collection<Param> items)
MatrixFluent.IncludeNested<A>	addNewInclude()
MatrixFluent.IncludeNested<A>	addNewIncludeLike(IncludeParams item)
MatrixFluent.ParamsNested<A>	addNewParam()
MatrixFluent.ParamsNested<A>	addNewParamLike(Param item)
A	addToInclude(IncludeParams... items)
A	addToInclude(int index, IncludeParams item)
A	addToParams(int index, Param item)
A	addToParams(Param... items)
IncludeParams	buildFirstInclude()
Param	buildFirstParam()
List<IncludeParams>	buildInclude()
IncludeParams	buildInclude(int index)
IncludeParams	buildLastInclude()
Param	buildLastParam()
IncludeParams	buildMatchingInclude(Predicate<IncludeParamsBuilder> predicate)
Param	buildMatchingParam(Predicate<ParamBuilder> predicate)
Param	buildParam(int index)
List<Param>	buildParams()
MatrixFluent.IncludeNested<A>	editFirstInclude()
MatrixFluent.ParamsNested<A>	editFirstParam()
MatrixFluent.IncludeNested<A>	editInclude(int index)
MatrixFluent.IncludeNested<A>	editLastInclude()
MatrixFluent.ParamsNested<A>	editLastParam()
MatrixFluent.IncludeNested<A>	editMatchingInclude(Predicate<IncludeParamsBuilder> predicate)
MatrixFluent.ParamsNested<A>	editMatchingParam(Predicate<ParamBuilder> predicate)
MatrixFluent.ParamsNested<A>	editParam(int index)
List<IncludeParams>	getInclude() Deprecated.
List<Param>	getParams() Deprecated.
Boolean	hasInclude()
Boolean	hasMatchingInclude(Predicate<IncludeParamsBuilder> predicate)
Boolean	hasMatchingParam(Predicate<ParamBuilder> predicate)
Boolean	hasParams()
A	removeAllFromInclude(Collection<IncludeParams> items)
A	removeAllFromParams(Collection<Param> items)
A	removeFromInclude(IncludeParams... items)
A	removeFromParams(Param... items)
A	removeMatchingFromInclude(Predicate<IncludeParamsBuilder> predicate)
A	removeMatchingFromParams(Predicate<ParamBuilder> predicate)
MatrixFluent.IncludeNested<A>	setNewIncludeLike(int index, IncludeParams item)
MatrixFluent.ParamsNested<A>	setNewParamLike(int index, Param item)
A	setToInclude(int index, IncludeParams item)
A	setToParams(int index, Param item)
A	withInclude(IncludeParams... include)
A	withInclude(List<IncludeParams> include)
A	withParams(List<Param> params)
A	withParams(Param... params)

Method Detail

addToInclude

A addToInclude(int index,
               IncludeParams item)

setToInclude

A setToInclude(int index,
               IncludeParams item)

addToInclude

A addToInclude(IncludeParams... items)

addAllToInclude

A addAllToInclude(Collection<IncludeParams> items)

removeFromInclude

A removeFromInclude(IncludeParams... items)

removeAllFromInclude

A removeAllFromInclude(Collection<IncludeParams> items)

removeMatchingFromInclude

A removeMatchingFromInclude(Predicate<IncludeParamsBuilder> predicate)

getInclude

@Deprecated
List<IncludeParams> getInclude()

Deprecated.

This method has been deprecated, please use method buildInclude instead.

Returns:

The buildable object.

buildInclude

List<IncludeParams> buildInclude()

buildInclude

IncludeParams buildInclude(int index)

buildFirstInclude

IncludeParams buildFirstInclude()

buildLastInclude

IncludeParams buildLastInclude()

buildMatchingInclude

IncludeParams buildMatchingInclude(Predicate<IncludeParamsBuilder> predicate)

hasMatchingInclude

Boolean hasMatchingInclude(Predicate<IncludeParamsBuilder> predicate)

withInclude

A withInclude(List<IncludeParams> include)

withInclude

A withInclude(IncludeParams... include)

hasInclude

Boolean hasInclude()

addNewInclude

MatrixFluent.IncludeNested<A> addNewInclude()

addNewIncludeLike

MatrixFluent.IncludeNested<A> addNewIncludeLike(IncludeParams item)

setNewIncludeLike

MatrixFluent.IncludeNested<A> setNewIncludeLike(int index,
                                                IncludeParams item)

editInclude

MatrixFluent.IncludeNested<A> editInclude(int index)

editFirstInclude

MatrixFluent.IncludeNested<A> editFirstInclude()

editLastInclude

MatrixFluent.IncludeNested<A> editLastInclude()

editMatchingInclude

MatrixFluent.IncludeNested<A> editMatchingInclude(Predicate<IncludeParamsBuilder> predicate)

addToParams

A addToParams(int index,
              Param item)

setToParams

A setToParams(int index,
              Param item)

addToParams

A addToParams(Param... items)

addAllToParams

A addAllToParams(Collection<Param> items)

removeFromParams

A removeFromParams(Param... items)

removeAllFromParams

A removeAllFromParams(Collection<Param> items)

removeMatchingFromParams

A removeMatchingFromParams(Predicate<ParamBuilder> predicate)

getParams

@Deprecated
List<Param> getParams()

Deprecated.

This method has been deprecated, please use method buildParams instead.

Returns:

The buildable object.

buildParams

List<Param> buildParams()

buildParam

Param buildParam(int index)

buildFirstParam

Param buildFirstParam()

buildLastParam

Param buildLastParam()

buildMatchingParam

Param buildMatchingParam(Predicate<ParamBuilder> predicate)

hasMatchingParam

Boolean hasMatchingParam(Predicate<ParamBuilder> predicate)

withParams

A withParams(List<Param> params)

withParams

A withParams(Param... params)

hasParams

Boolean hasParams()

addNewParam

MatrixFluent.ParamsNested<A> addNewParam()

addNewParamLike

MatrixFluent.ParamsNested<A> addNewParamLike(Param item)

setNewParamLike

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

editParam

MatrixFluent.ParamsNested<A> editParam(int index)

editFirstParam

MatrixFluent.ParamsNested<A> editFirstParam()

editLastParam

MatrixFluent.ParamsNested<A> editLastParam()

editMatchingParam

MatrixFluent.ParamsNested<A> editMatchingParam(Predicate<ParamBuilder> predicate)