io.fabric8.kubernetes.api.model.gatewayapi.v1

Class HTTPRouteRuleFluent<A extends HTTPRouteRuleFluent<A>>

java.lang.Object

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

io.fabric8.kubernetes.api.model.gatewayapi.v1.HTTPRouteRuleFluent<A>

Direct Known Subclasses:

HTTPRouteRuleBuilder, HTTPRouteSpecFluent.RulesNested

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

Generated

Nested Class Summary

Nested Classes

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

Field Summary

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

_visitables, VISIT

Constructor Summary

Constructors

Constructor and Description
HTTPRouteRuleFluent()
HTTPRouteRuleFluent(HTTPRouteRule instance)

Method Summary

Modifier and Type	Method and Description
A	addAllToBackendRefs(Collection<HTTPBackendRef> items)
A	addAllToFilters(Collection<HTTPRouteFilter> items)
A	addAllToMatches(Collection<HTTPRouteMatch> items)
HTTPRouteRuleFluent.BackendRefsNested<A>	addNewBackendRef()
HTTPRouteRuleFluent.BackendRefsNested<A>	addNewBackendRefLike(HTTPBackendRef item)
HTTPRouteRuleFluent.FiltersNested<A>	addNewFilter()
HTTPRouteRuleFluent.FiltersNested<A>	addNewFilterLike(HTTPRouteFilter item)
HTTPRouteRuleFluent.MatchesNested<A>	addNewMatch()
HTTPRouteRuleFluent.MatchesNested<A>	addNewMatchLike(HTTPRouteMatch item)
A	addToAdditionalProperties(Map<String,Object> map)
A	addToAdditionalProperties(String key, Object value)
A	addToBackendRefs(HTTPBackendRef... items)
A	addToBackendRefs(int index, HTTPBackendRef item)
A	addToFilters(HTTPRouteFilter... items)
A	addToFilters(int index, HTTPRouteFilter item)
A	addToMatches(HTTPRouteMatch... items)
A	addToMatches(int index, HTTPRouteMatch item)
HTTPBackendRef	buildBackendRef(int index)
List<HTTPBackendRef>	buildBackendRefs()
HTTPRouteFilter	buildFilter(int index)
List<HTTPRouteFilter>	buildFilters()
HTTPBackendRef	buildFirstBackendRef()
HTTPRouteFilter	buildFirstFilter()
HTTPRouteMatch	buildFirstMatch()
HTTPBackendRef	buildLastBackendRef()
HTTPRouteFilter	buildLastFilter()
HTTPRouteMatch	buildLastMatch()
HTTPRouteMatch	buildMatch(int index)
List<HTTPRouteMatch>	buildMatches()
HTTPBackendRef	buildMatchingBackendRef(Predicate<HTTPBackendRefBuilder> predicate)
HTTPRouteFilter	buildMatchingFilter(Predicate<HTTPRouteFilterBuilder> predicate)
HTTPRouteMatch	buildMatchingMatch(Predicate<HTTPRouteMatchBuilder> predicate)
HTTPRouteTimeouts	buildTimeouts()
protected void	copyInstance(HTTPRouteRule instance)
HTTPRouteRuleFluent.BackendRefsNested<A>	editBackendRef(int index)
HTTPRouteRuleFluent.FiltersNested<A>	editFilter(int index)
HTTPRouteRuleFluent.BackendRefsNested<A>	editFirstBackendRef()
HTTPRouteRuleFluent.FiltersNested<A>	editFirstFilter()
HTTPRouteRuleFluent.MatchesNested<A>	editFirstMatch()
HTTPRouteRuleFluent.BackendRefsNested<A>	editLastBackendRef()
HTTPRouteRuleFluent.FiltersNested<A>	editLastFilter()
HTTPRouteRuleFluent.MatchesNested<A>	editLastMatch()
HTTPRouteRuleFluent.MatchesNested<A>	editMatch(int index)
HTTPRouteRuleFluent.BackendRefsNested<A>	editMatchingBackendRef(Predicate<HTTPBackendRefBuilder> predicate)
HTTPRouteRuleFluent.FiltersNested<A>	editMatchingFilter(Predicate<HTTPRouteFilterBuilder> predicate)
HTTPRouteRuleFluent.MatchesNested<A>	editMatchingMatch(Predicate<HTTPRouteMatchBuilder> predicate)
HTTPRouteRuleFluent.TimeoutsNested<A>	editOrNewTimeouts()
HTTPRouteRuleFluent.TimeoutsNested<A>	editOrNewTimeoutsLike(HTTPRouteTimeouts item)
HTTPRouteRuleFluent.TimeoutsNested<A>	editTimeouts()
boolean	equals(Object o)
Map<String,Object>	getAdditionalProperties()
boolean	hasAdditionalProperties()
boolean	hasBackendRefs()
boolean	hasFilters()
int	hashCode()
boolean	hasMatches()
boolean	hasMatchingBackendRef(Predicate<HTTPBackendRefBuilder> predicate)
boolean	hasMatchingFilter(Predicate<HTTPRouteFilterBuilder> predicate)
boolean	hasMatchingMatch(Predicate<HTTPRouteMatchBuilder> predicate)
boolean	hasTimeouts()
A	removeAllFromBackendRefs(Collection<HTTPBackendRef> items)
A	removeAllFromFilters(Collection<HTTPRouteFilter> items)
A	removeAllFromMatches(Collection<HTTPRouteMatch> items)
A	removeFromAdditionalProperties(Map<String,Object> map)
A	removeFromAdditionalProperties(String key)
A	removeFromBackendRefs(HTTPBackendRef... items)
A	removeFromFilters(HTTPRouteFilter... items)
A	removeFromMatches(HTTPRouteMatch... items)
A	removeMatchingFromBackendRefs(Predicate<HTTPBackendRefBuilder> predicate)
A	removeMatchingFromFilters(Predicate<HTTPRouteFilterBuilder> predicate)
A	removeMatchingFromMatches(Predicate<HTTPRouteMatchBuilder> predicate)
HTTPRouteRuleFluent.BackendRefsNested<A>	setNewBackendRefLike(int index, HTTPBackendRef item)
HTTPRouteRuleFluent.FiltersNested<A>	setNewFilterLike(int index, HTTPRouteFilter item)
HTTPRouteRuleFluent.MatchesNested<A>	setNewMatchLike(int index, HTTPRouteMatch item)
A	setToBackendRefs(int index, HTTPBackendRef item)
A	setToFilters(int index, HTTPRouteFilter item)
A	setToMatches(int index, HTTPRouteMatch item)
String	toString()
<K,V> A	withAdditionalProperties(Map<String,Object> additionalProperties)
A	withBackendRefs(HTTPBackendRef... backendRefs)
A	withBackendRefs(List<HTTPBackendRef> backendRefs)
A	withFilters(HTTPRouteFilter... filters)
A	withFilters(List<HTTPRouteFilter> filters)
A	withMatches(HTTPRouteMatch... matches)
A	withMatches(List<HTTPRouteMatch> matches)
HTTPRouteRuleFluent.TimeoutsNested<A>	withNewTimeouts()
A	withNewTimeouts(String backendRequest, String request)
HTTPRouteRuleFluent.TimeoutsNested<A>	withNewTimeoutsLike(HTTPRouteTimeouts item)
A	withTimeouts(HTTPRouteTimeouts timeouts)

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

HTTPRouteRuleFluent

public HTTPRouteRuleFluent()

HTTPRouteRuleFluent

public HTTPRouteRuleFluent(HTTPRouteRule instance)

Method Detail

copyInstance

protected void copyInstance(HTTPRouteRule instance)

addToBackendRefs

public A addToBackendRefs(int index,
                          HTTPBackendRef item)

setToBackendRefs

public A setToBackendRefs(int index,
                          HTTPBackendRef item)

addToBackendRefs

public A addToBackendRefs(HTTPBackendRef... items)

addAllToBackendRefs

public A addAllToBackendRefs(Collection<HTTPBackendRef> items)

removeFromBackendRefs

public A removeFromBackendRefs(HTTPBackendRef... items)

removeAllFromBackendRefs

public A removeAllFromBackendRefs(Collection<HTTPBackendRef> items)

removeMatchingFromBackendRefs

public A removeMatchingFromBackendRefs(Predicate<HTTPBackendRefBuilder> predicate)

buildBackendRefs

public List<HTTPBackendRef> buildBackendRefs()

buildBackendRef

public HTTPBackendRef buildBackendRef(int index)

buildFirstBackendRef

public HTTPBackendRef buildFirstBackendRef()

buildLastBackendRef

public HTTPBackendRef buildLastBackendRef()

buildMatchingBackendRef

public HTTPBackendRef buildMatchingBackendRef(Predicate<HTTPBackendRefBuilder> predicate)

hasMatchingBackendRef

public boolean hasMatchingBackendRef(Predicate<HTTPBackendRefBuilder> predicate)

withBackendRefs

public A withBackendRefs(List<HTTPBackendRef> backendRefs)

withBackendRefs

public A withBackendRefs(HTTPBackendRef... backendRefs)

hasBackendRefs

public boolean hasBackendRefs()

addNewBackendRef

public HTTPRouteRuleFluent.BackendRefsNested<A> addNewBackendRef()

addNewBackendRefLike

public HTTPRouteRuleFluent.BackendRefsNested<A> addNewBackendRefLike(HTTPBackendRef item)

setNewBackendRefLike

public HTTPRouteRuleFluent.BackendRefsNested<A> setNewBackendRefLike(int index,
                                                                     HTTPBackendRef item)

editBackendRef

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

editFirstBackendRef

public HTTPRouteRuleFluent.BackendRefsNested<A> editFirstBackendRef()

editLastBackendRef

public HTTPRouteRuleFluent.BackendRefsNested<A> editLastBackendRef()

editMatchingBackendRef

public HTTPRouteRuleFluent.BackendRefsNested<A> editMatchingBackendRef(Predicate<HTTPBackendRefBuilder> predicate)

addToFilters

public A addToFilters(int index,
                      HTTPRouteFilter item)

setToFilters

public A setToFilters(int index,
                      HTTPRouteFilter item)

addToFilters

public A addToFilters(HTTPRouteFilter... items)

addAllToFilters

public A addAllToFilters(Collection<HTTPRouteFilter> items)

removeFromFilters

public A removeFromFilters(HTTPRouteFilter... items)

removeAllFromFilters

public A removeAllFromFilters(Collection<HTTPRouteFilter> items)

removeMatchingFromFilters

public A removeMatchingFromFilters(Predicate<HTTPRouteFilterBuilder> predicate)

buildFilters

public List<HTTPRouteFilter> buildFilters()

buildFilter

public HTTPRouteFilter buildFilter(int index)

buildFirstFilter

public HTTPRouteFilter buildFirstFilter()

buildLastFilter

public HTTPRouteFilter buildLastFilter()

buildMatchingFilter

public HTTPRouteFilter buildMatchingFilter(Predicate<HTTPRouteFilterBuilder> predicate)

hasMatchingFilter

public boolean hasMatchingFilter(Predicate<HTTPRouteFilterBuilder> predicate)

withFilters

public A withFilters(List<HTTPRouteFilter> filters)

withFilters

public A withFilters(HTTPRouteFilter... filters)

hasFilters

public boolean hasFilters()

addNewFilter

public HTTPRouteRuleFluent.FiltersNested<A> addNewFilter()

addNewFilterLike

public HTTPRouteRuleFluent.FiltersNested<A> addNewFilterLike(HTTPRouteFilter item)

setNewFilterLike

public HTTPRouteRuleFluent.FiltersNested<A> setNewFilterLike(int index,
                                                             HTTPRouteFilter item)

editFilter

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

editFirstFilter

public HTTPRouteRuleFluent.FiltersNested<A> editFirstFilter()

editLastFilter

public HTTPRouteRuleFluent.FiltersNested<A> editLastFilter()

editMatchingFilter

public HTTPRouteRuleFluent.FiltersNested<A> editMatchingFilter(Predicate<HTTPRouteFilterBuilder> predicate)

addToMatches

public A addToMatches(int index,
                      HTTPRouteMatch item)

setToMatches

public A setToMatches(int index,
                      HTTPRouteMatch item)

addToMatches

public A addToMatches(HTTPRouteMatch... items)

addAllToMatches

public A addAllToMatches(Collection<HTTPRouteMatch> items)

removeFromMatches

public A removeFromMatches(HTTPRouteMatch... items)

removeAllFromMatches

public A removeAllFromMatches(Collection<HTTPRouteMatch> items)

removeMatchingFromMatches

public A removeMatchingFromMatches(Predicate<HTTPRouteMatchBuilder> predicate)

buildMatches

public List<HTTPRouteMatch> buildMatches()

buildMatch

public HTTPRouteMatch buildMatch(int index)

buildFirstMatch

public HTTPRouteMatch buildFirstMatch()

buildLastMatch

public HTTPRouteMatch buildLastMatch()

buildMatchingMatch

public HTTPRouteMatch buildMatchingMatch(Predicate<HTTPRouteMatchBuilder> predicate)

hasMatchingMatch

public boolean hasMatchingMatch(Predicate<HTTPRouteMatchBuilder> predicate)

withMatches

public A withMatches(List<HTTPRouteMatch> matches)

withMatches

public A withMatches(HTTPRouteMatch... matches)

hasMatches

public boolean hasMatches()

addNewMatch

public HTTPRouteRuleFluent.MatchesNested<A> addNewMatch()

addNewMatchLike

public HTTPRouteRuleFluent.MatchesNested<A> addNewMatchLike(HTTPRouteMatch item)

setNewMatchLike

public HTTPRouteRuleFluent.MatchesNested<A> setNewMatchLike(int index,
                                                            HTTPRouteMatch item)

editMatch

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

editFirstMatch

public HTTPRouteRuleFluent.MatchesNested<A> editFirstMatch()

editLastMatch

public HTTPRouteRuleFluent.MatchesNested<A> editLastMatch()

editMatchingMatch

public HTTPRouteRuleFluent.MatchesNested<A> editMatchingMatch(Predicate<HTTPRouteMatchBuilder> predicate)

buildTimeouts

public HTTPRouteTimeouts buildTimeouts()

withTimeouts

public A withTimeouts(HTTPRouteTimeouts timeouts)

hasTimeouts

public boolean hasTimeouts()

withNewTimeouts

public A withNewTimeouts(String backendRequest,
                         String request)

withNewTimeouts

public HTTPRouteRuleFluent.TimeoutsNested<A> withNewTimeouts()

withNewTimeoutsLike

public HTTPRouteRuleFluent.TimeoutsNested<A> withNewTimeoutsLike(HTTPRouteTimeouts item)

editTimeouts

public HTTPRouteRuleFluent.TimeoutsNested<A> editTimeouts()

editOrNewTimeouts

public HTTPRouteRuleFluent.TimeoutsNested<A> editOrNewTimeouts()

editOrNewTimeoutsLike

public HTTPRouteRuleFluent.TimeoutsNested<A> editOrNewTimeoutsLike(HTTPRouteTimeouts item)

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 HTTPRouteRuleFluent<A>>

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object