io.fabric8.kubernetes.api.model.gatewayapi.v1alpha2

Interface GRPCRouteRuleFluent<A extends GRPCRouteRuleFluent<A>>

All Superinterfaces:

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

All Known Subinterfaces:

GRPCRouteSpecFluent.RulesNested<N>

All Known Implementing Classes:

GRPCRouteRuleBuilder, GRPCRouteRuleFluentImpl

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

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	GRPCRouteRuleFluent.BackendRefsNested<N>
static interface	GRPCRouteRuleFluent.FiltersNested<N>
static interface	GRPCRouteRuleFluent.MatchesNested<N>

Method Summary

Modifier and Type	Method and Description
A	addAllToBackendRefs(Collection<GRPCBackendRef> items)
A	addAllToFilters(Collection<GRPCRouteFilter> items)
A	addAllToMatches(Collection<GRPCRouteMatch> items)
GRPCRouteRuleFluent.BackendRefsNested<A>	addNewBackendRef()
GRPCRouteRuleFluent.BackendRefsNested<A>	addNewBackendRefLike(GRPCBackendRef item)
GRPCRouteRuleFluent.FiltersNested<A>	addNewFilter()
GRPCRouteRuleFluent.FiltersNested<A>	addNewFilterLike(GRPCRouteFilter item)
GRPCRouteRuleFluent.MatchesNested<A>	addNewMatch()
GRPCRouteRuleFluent.MatchesNested<A>	addNewMatchLike(GRPCRouteMatch item)
A	addToAdditionalProperties(Map<String,Object> map)
A	addToAdditionalProperties(String key, Object value)
A	addToBackendRefs(GRPCBackendRef... items)
A	addToBackendRefs(int index, GRPCBackendRef item)
A	addToFilters(GRPCRouteFilter... items)
A	addToFilters(int index, GRPCRouteFilter item)
A	addToMatches(GRPCRouteMatch... items)
A	addToMatches(int index, GRPCRouteMatch item)
GRPCBackendRef	buildBackendRef(int index)
List<GRPCBackendRef>	buildBackendRefs()
GRPCRouteFilter	buildFilter(int index)
List<GRPCRouteFilter>	buildFilters()
GRPCBackendRef	buildFirstBackendRef()
GRPCRouteFilter	buildFirstFilter()
GRPCRouteMatch	buildFirstMatch()
GRPCBackendRef	buildLastBackendRef()
GRPCRouteFilter	buildLastFilter()
GRPCRouteMatch	buildLastMatch()
GRPCRouteMatch	buildMatch(int index)
List<GRPCRouteMatch>	buildMatches()
GRPCBackendRef	buildMatchingBackendRef(Predicate<GRPCBackendRefBuilder> predicate)
GRPCRouteFilter	buildMatchingFilter(Predicate<GRPCRouteFilterBuilder> predicate)
GRPCRouteMatch	buildMatchingMatch(Predicate<GRPCRouteMatchBuilder> predicate)
GRPCRouteRuleFluent.BackendRefsNested<A>	editBackendRef(int index)
GRPCRouteRuleFluent.FiltersNested<A>	editFilter(int index)
GRPCRouteRuleFluent.BackendRefsNested<A>	editFirstBackendRef()
GRPCRouteRuleFluent.FiltersNested<A>	editFirstFilter()
GRPCRouteRuleFluent.MatchesNested<A>	editFirstMatch()
GRPCRouteRuleFluent.BackendRefsNested<A>	editLastBackendRef()
GRPCRouteRuleFluent.FiltersNested<A>	editLastFilter()
GRPCRouteRuleFluent.MatchesNested<A>	editLastMatch()
GRPCRouteRuleFluent.MatchesNested<A>	editMatch(int index)
GRPCRouteRuleFluent.BackendRefsNested<A>	editMatchingBackendRef(Predicate<GRPCBackendRefBuilder> predicate)
GRPCRouteRuleFluent.FiltersNested<A>	editMatchingFilter(Predicate<GRPCRouteFilterBuilder> predicate)
GRPCRouteRuleFluent.MatchesNested<A>	editMatchingMatch(Predicate<GRPCRouteMatchBuilder> predicate)
Map<String,Object>	getAdditionalProperties()
List<GRPCBackendRef>	getBackendRefs() Deprecated.
List<GRPCRouteFilter>	getFilters() Deprecated.
List<GRPCRouteMatch>	getMatches() Deprecated.
Boolean	hasAdditionalProperties()
Boolean	hasBackendRefs()
Boolean	hasFilters()
Boolean	hasMatches()
Boolean	hasMatchingBackendRef(Predicate<GRPCBackendRefBuilder> predicate)
Boolean	hasMatchingFilter(Predicate<GRPCRouteFilterBuilder> predicate)
Boolean	hasMatchingMatch(Predicate<GRPCRouteMatchBuilder> predicate)
A	removeAllFromBackendRefs(Collection<GRPCBackendRef> items)
A	removeAllFromFilters(Collection<GRPCRouteFilter> items)
A	removeAllFromMatches(Collection<GRPCRouteMatch> items)
A	removeFromAdditionalProperties(Map<String,Object> map)
A	removeFromAdditionalProperties(String key)
A	removeFromBackendRefs(GRPCBackendRef... items)
A	removeFromFilters(GRPCRouteFilter... items)
A	removeFromMatches(GRPCRouteMatch... items)
A	removeMatchingFromBackendRefs(Predicate<GRPCBackendRefBuilder> predicate)
A	removeMatchingFromFilters(Predicate<GRPCRouteFilterBuilder> predicate)
A	removeMatchingFromMatches(Predicate<GRPCRouteMatchBuilder> predicate)
GRPCRouteRuleFluent.BackendRefsNested<A>	setNewBackendRefLike(int index, GRPCBackendRef item)
GRPCRouteRuleFluent.FiltersNested<A>	setNewFilterLike(int index, GRPCRouteFilter item)
GRPCRouteRuleFluent.MatchesNested<A>	setNewMatchLike(int index, GRPCRouteMatch item)
A	setToBackendRefs(int index, GRPCBackendRef item)
A	setToFilters(int index, GRPCRouteFilter item)
A	setToMatches(int index, GRPCRouteMatch item)
<K,V> A	withAdditionalProperties(Map<String,Object> additionalProperties)
A	withBackendRefs(GRPCBackendRef... backendRefs)
A	withBackendRefs(List<GRPCBackendRef> backendRefs)
A	withFilters(GRPCRouteFilter... filters)
A	withFilters(List<GRPCRouteFilter> filters)
A	withMatches(GRPCRouteMatch... matches)
A	withMatches(List<GRPCRouteMatch> matches)

Method Detail

addToBackendRefs

A addToBackendRefs(int index,
                   GRPCBackendRef item)

setToBackendRefs

A setToBackendRefs(int index,
                   GRPCBackendRef item)

addToBackendRefs

A addToBackendRefs(GRPCBackendRef... items)

addAllToBackendRefs

A addAllToBackendRefs(Collection<GRPCBackendRef> items)

removeFromBackendRefs

A removeFromBackendRefs(GRPCBackendRef... items)

removeAllFromBackendRefs

A removeAllFromBackendRefs(Collection<GRPCBackendRef> items)

removeMatchingFromBackendRefs

A removeMatchingFromBackendRefs(Predicate<GRPCBackendRefBuilder> predicate)

getBackendRefs

@Deprecated
List<GRPCBackendRef> getBackendRefs()

Deprecated.

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

Returns:

The buildable object.

buildBackendRefs

List<GRPCBackendRef> buildBackendRefs()

buildBackendRef

GRPCBackendRef buildBackendRef(int index)

buildFirstBackendRef

GRPCBackendRef buildFirstBackendRef()

buildLastBackendRef

GRPCBackendRef buildLastBackendRef()

buildMatchingBackendRef

GRPCBackendRef buildMatchingBackendRef(Predicate<GRPCBackendRefBuilder> predicate)

hasMatchingBackendRef

Boolean hasMatchingBackendRef(Predicate<GRPCBackendRefBuilder> predicate)

withBackendRefs

A withBackendRefs(List<GRPCBackendRef> backendRefs)

withBackendRefs

A withBackendRefs(GRPCBackendRef... backendRefs)

hasBackendRefs

Boolean hasBackendRefs()

addNewBackendRef

GRPCRouteRuleFluent.BackendRefsNested<A> addNewBackendRef()

addNewBackendRefLike

GRPCRouteRuleFluent.BackendRefsNested<A> addNewBackendRefLike(GRPCBackendRef item)

setNewBackendRefLike

GRPCRouteRuleFluent.BackendRefsNested<A> setNewBackendRefLike(int index,
                                                              GRPCBackendRef item)

editBackendRef

GRPCRouteRuleFluent.BackendRefsNested<A> editBackendRef(int index)

editFirstBackendRef

GRPCRouteRuleFluent.BackendRefsNested<A> editFirstBackendRef()

editLastBackendRef

GRPCRouteRuleFluent.BackendRefsNested<A> editLastBackendRef()

editMatchingBackendRef

GRPCRouteRuleFluent.BackendRefsNested<A> editMatchingBackendRef(Predicate<GRPCBackendRefBuilder> predicate)

addToFilters

A addToFilters(int index,
               GRPCRouteFilter item)

setToFilters

A setToFilters(int index,
               GRPCRouteFilter item)

addToFilters

A addToFilters(GRPCRouteFilter... items)

addAllToFilters

A addAllToFilters(Collection<GRPCRouteFilter> items)

removeFromFilters

A removeFromFilters(GRPCRouteFilter... items)

removeAllFromFilters

A removeAllFromFilters(Collection<GRPCRouteFilter> items)

removeMatchingFromFilters

A removeMatchingFromFilters(Predicate<GRPCRouteFilterBuilder> predicate)

getFilters

@Deprecated
List<GRPCRouteFilter> getFilters()

Deprecated.

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

Returns:

The buildable object.

buildFilters

List<GRPCRouteFilter> buildFilters()

buildFilter

GRPCRouteFilter buildFilter(int index)

buildFirstFilter

GRPCRouteFilter buildFirstFilter()

buildLastFilter

GRPCRouteFilter buildLastFilter()

buildMatchingFilter

GRPCRouteFilter buildMatchingFilter(Predicate<GRPCRouteFilterBuilder> predicate)

hasMatchingFilter

Boolean hasMatchingFilter(Predicate<GRPCRouteFilterBuilder> predicate)

withFilters

A withFilters(List<GRPCRouteFilter> filters)

withFilters

A withFilters(GRPCRouteFilter... filters)

hasFilters

Boolean hasFilters()

addNewFilter

GRPCRouteRuleFluent.FiltersNested<A> addNewFilter()

addNewFilterLike

GRPCRouteRuleFluent.FiltersNested<A> addNewFilterLike(GRPCRouteFilter item)

setNewFilterLike

GRPCRouteRuleFluent.FiltersNested<A> setNewFilterLike(int index,
                                                      GRPCRouteFilter item)

editFilter

GRPCRouteRuleFluent.FiltersNested<A> editFilter(int index)

editFirstFilter

GRPCRouteRuleFluent.FiltersNested<A> editFirstFilter()

editLastFilter

GRPCRouteRuleFluent.FiltersNested<A> editLastFilter()

editMatchingFilter

GRPCRouteRuleFluent.FiltersNested<A> editMatchingFilter(Predicate<GRPCRouteFilterBuilder> predicate)

addToMatches

A addToMatches(int index,
               GRPCRouteMatch item)

setToMatches

A setToMatches(int index,
               GRPCRouteMatch item)

addToMatches

A addToMatches(GRPCRouteMatch... items)

addAllToMatches

A addAllToMatches(Collection<GRPCRouteMatch> items)

removeFromMatches

A removeFromMatches(GRPCRouteMatch... items)

removeAllFromMatches

A removeAllFromMatches(Collection<GRPCRouteMatch> items)

removeMatchingFromMatches

A removeMatchingFromMatches(Predicate<GRPCRouteMatchBuilder> predicate)

getMatches

@Deprecated
List<GRPCRouteMatch> getMatches()

Deprecated.

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

Returns:

The buildable object.

buildMatches

List<GRPCRouteMatch> buildMatches()

buildMatch

GRPCRouteMatch buildMatch(int index)

buildFirstMatch

GRPCRouteMatch buildFirstMatch()

buildLastMatch

GRPCRouteMatch buildLastMatch()

buildMatchingMatch

GRPCRouteMatch buildMatchingMatch(Predicate<GRPCRouteMatchBuilder> predicate)

hasMatchingMatch

Boolean hasMatchingMatch(Predicate<GRPCRouteMatchBuilder> predicate)

withMatches

A withMatches(List<GRPCRouteMatch> matches)

withMatches

A withMatches(GRPCRouteMatch... matches)

hasMatches

Boolean hasMatches()

addNewMatch

GRPCRouteRuleFluent.MatchesNested<A> addNewMatch()

addNewMatchLike

GRPCRouteRuleFluent.MatchesNested<A> addNewMatchLike(GRPCRouteMatch item)

setNewMatchLike

GRPCRouteRuleFluent.MatchesNested<A> setNewMatchLike(int index,
                                                     GRPCRouteMatch item)

editMatch

GRPCRouteRuleFluent.MatchesNested<A> editMatch(int index)

editFirstMatch

GRPCRouteRuleFluent.MatchesNested<A> editFirstMatch()

editLastMatch

GRPCRouteRuleFluent.MatchesNested<A> editLastMatch()

editMatchingMatch

GRPCRouteRuleFluent.MatchesNested<A> editMatchingMatch(Predicate<GRPCRouteMatchBuilder> predicate)

addToAdditionalProperties

A addToAdditionalProperties(String key,
                            Object value)

addToAdditionalProperties

A addToAdditionalProperties(Map<String,Object> map)

removeFromAdditionalProperties

A removeFromAdditionalProperties(String key)

removeFromAdditionalProperties

A removeFromAdditionalProperties(Map<String,Object> map)

getAdditionalProperties

Map<String,Object> getAdditionalProperties()

withAdditionalProperties

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

hasAdditionalProperties

Boolean hasAdditionalProperties()