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

Class GRPCRouteRuleFluent<A extends GRPCRouteRuleFluent<A>>

java.lang.Object

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

io.fabric8.kubernetes.api.model.gatewayapi.v1alpha2.GRPCRouteRuleFluent<A>

All Implemented Interfaces:

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

Direct Known Subclasses:

GRPCRouteRuleBuilder, GRPCRouteSpecFluent.RulesNested

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

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	GRPCRouteRuleFluent.BackendRefsNested<N>
class	GRPCRouteRuleFluent.FiltersNested<N>
class	GRPCRouteRuleFluent.MatchesNested<N>

Field Summary

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

_visitables, VISIT

Constructor Summary

Constructors

Constructor and Description
GRPCRouteRuleFluent()
GRPCRouteRuleFluent(GRPCRouteRule instance)

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)
protected void	copyInstance(GRPCRouteRule instance)
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)
boolean	equals(Object o)
Map<String,Object>	getAdditionalProperties()
boolean	hasAdditionalProperties()
boolean	hasBackendRefs()
boolean	hasFilters()
int	hashCode()
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)
String	toString()
<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)

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

accept, accept, accept, accept, aggregate, aggregate, build, build, builderOf

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.fabric8.kubernetes.api.builder.Visitable

getTarget

Constructor Detail

GRPCRouteRuleFluent

public GRPCRouteRuleFluent()

GRPCRouteRuleFluent

public GRPCRouteRuleFluent(GRPCRouteRule instance)

Method Detail

copyInstance

protected void copyInstance(GRPCRouteRule instance)

addToBackendRefs

public A addToBackendRefs(int index,
                          GRPCBackendRef item)

setToBackendRefs

public A setToBackendRefs(int index,
                          GRPCBackendRef item)

addToBackendRefs

public A addToBackendRefs(GRPCBackendRef... items)

addAllToBackendRefs

public A addAllToBackendRefs(Collection<GRPCBackendRef> items)

removeFromBackendRefs

public A removeFromBackendRefs(GRPCBackendRef... items)

removeAllFromBackendRefs

public A removeAllFromBackendRefs(Collection<GRPCBackendRef> items)

removeMatchingFromBackendRefs

public A removeMatchingFromBackendRefs(Predicate<GRPCBackendRefBuilder> predicate)

buildBackendRefs

public List<GRPCBackendRef> buildBackendRefs()

buildBackendRef

public GRPCBackendRef buildBackendRef(int index)

buildFirstBackendRef

public GRPCBackendRef buildFirstBackendRef()

buildLastBackendRef

public GRPCBackendRef buildLastBackendRef()

buildMatchingBackendRef

public GRPCBackendRef buildMatchingBackendRef(Predicate<GRPCBackendRefBuilder> predicate)

hasMatchingBackendRef

public boolean hasMatchingBackendRef(Predicate<GRPCBackendRefBuilder> predicate)

withBackendRefs

public A withBackendRefs(List<GRPCBackendRef> backendRefs)

withBackendRefs

public A withBackendRefs(GRPCBackendRef... backendRefs)

hasBackendRefs

public boolean hasBackendRefs()

addNewBackendRef

public GRPCRouteRuleFluent.BackendRefsNested<A> addNewBackendRef()

addNewBackendRefLike

public GRPCRouteRuleFluent.BackendRefsNested<A> addNewBackendRefLike(GRPCBackendRef item)

setNewBackendRefLike

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

editBackendRef

public GRPCRouteRuleFluent.BackendRefsNested<A> editBackendRef(int index)

editFirstBackendRef

public GRPCRouteRuleFluent.BackendRefsNested<A> editFirstBackendRef()

editLastBackendRef

public GRPCRouteRuleFluent.BackendRefsNested<A> editLastBackendRef()

editMatchingBackendRef

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

addToFilters

public A addToFilters(int index,
                      GRPCRouteFilter item)

setToFilters

public A setToFilters(int index,
                      GRPCRouteFilter item)

addToFilters

public A addToFilters(GRPCRouteFilter... items)

addAllToFilters

public A addAllToFilters(Collection<GRPCRouteFilter> items)

removeFromFilters

public A removeFromFilters(GRPCRouteFilter... items)

removeAllFromFilters

public A removeAllFromFilters(Collection<GRPCRouteFilter> items)

removeMatchingFromFilters

public A removeMatchingFromFilters(Predicate<GRPCRouteFilterBuilder> predicate)

buildFilters

public List<GRPCRouteFilter> buildFilters()

buildFilter

public GRPCRouteFilter buildFilter(int index)

buildFirstFilter

public GRPCRouteFilter buildFirstFilter()

buildLastFilter

public GRPCRouteFilter buildLastFilter()

buildMatchingFilter

public GRPCRouteFilter buildMatchingFilter(Predicate<GRPCRouteFilterBuilder> predicate)

hasMatchingFilter

public boolean hasMatchingFilter(Predicate<GRPCRouteFilterBuilder> predicate)

withFilters

public A withFilters(List<GRPCRouteFilter> filters)

withFilters

public A withFilters(GRPCRouteFilter... filters)

hasFilters

public boolean hasFilters()

addNewFilter

public GRPCRouteRuleFluent.FiltersNested<A> addNewFilter()

addNewFilterLike

public GRPCRouteRuleFluent.FiltersNested<A> addNewFilterLike(GRPCRouteFilter item)

setNewFilterLike

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

editFilter

public GRPCRouteRuleFluent.FiltersNested<A> editFilter(int index)

editFirstFilter

public GRPCRouteRuleFluent.FiltersNested<A> editFirstFilter()

editLastFilter

public GRPCRouteRuleFluent.FiltersNested<A> editLastFilter()

editMatchingFilter

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

addToMatches

public A addToMatches(int index,
                      GRPCRouteMatch item)

setToMatches

public A setToMatches(int index,
                      GRPCRouteMatch item)

addToMatches

public A addToMatches(GRPCRouteMatch... items)

addAllToMatches

public A addAllToMatches(Collection<GRPCRouteMatch> items)

removeFromMatches

public A removeFromMatches(GRPCRouteMatch... items)

removeAllFromMatches

public A removeAllFromMatches(Collection<GRPCRouteMatch> items)

removeMatchingFromMatches

public A removeMatchingFromMatches(Predicate<GRPCRouteMatchBuilder> predicate)

buildMatches

public List<GRPCRouteMatch> buildMatches()

buildMatch

public GRPCRouteMatch buildMatch(int index)

buildFirstMatch

public GRPCRouteMatch buildFirstMatch()

buildLastMatch

public GRPCRouteMatch buildLastMatch()

buildMatchingMatch

public GRPCRouteMatch buildMatchingMatch(Predicate<GRPCRouteMatchBuilder> predicate)

hasMatchingMatch

public boolean hasMatchingMatch(Predicate<GRPCRouteMatchBuilder> predicate)

withMatches

public A withMatches(List<GRPCRouteMatch> matches)

withMatches

public A withMatches(GRPCRouteMatch... matches)

hasMatches

public boolean hasMatches()

addNewMatch

public GRPCRouteRuleFluent.MatchesNested<A> addNewMatch()

addNewMatchLike

public GRPCRouteRuleFluent.MatchesNested<A> addNewMatchLike(GRPCRouteMatch item)

setNewMatchLike

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

editMatch

public GRPCRouteRuleFluent.MatchesNested<A> editMatch(int index)

editFirstMatch

public GRPCRouteRuleFluent.MatchesNested<A> editFirstMatch()

editLastMatch

public GRPCRouteRuleFluent.MatchesNested<A> editLastMatch()

editMatchingMatch

public GRPCRouteRuleFluent.MatchesNested<A> editMatchingMatch(Predicate<GRPCRouteMatchBuilder> 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 GRPCRouteRuleFluent<A>>

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object