Package 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	Description
class	HTTPRouteRuleFluent.BackendRefsNested<N>
class	HTTPRouteRuleFluent.FiltersNested<N>
class	HTTPRouteRuleFluent.MatchesNested<N>
class	HTTPRouteRuleFluent.RetryNested<N>
class	HTTPRouteRuleFluent.SessionPersistenceNested<N>
class	HTTPRouteRuleFluent.TimeoutsNested<N>

Field Summary

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

_visitables, VISIT

Constructor Summary

Constructors

Constructor	Description
HTTPRouteRuleFluent()
HTTPRouteRuleFluent(HTTPRouteRule instance)

Method Summary

Modifier and Type	Method	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(String key, Object value)
A	addToAdditionalProperties(Map<String,Object> map)
A	addToBackendRefs(int index, HTTPBackendRef item)
A	addToBackendRefs(HTTPBackendRef... items)
A	addToFilters(int index, HTTPRouteFilter item)
A	addToFilters(HTTPRouteFilter... items)
A	addToMatches(int index, HTTPRouteMatch item)
A	addToMatches(HTTPRouteMatch... items)
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)
HTTPRouteRetry	buildRetry()
SessionPersistence	buildSessionPersistence()
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.RetryNested<A>	editOrNewRetry()
HTTPRouteRuleFluent.RetryNested<A>	editOrNewRetryLike(HTTPRouteRetry item)
HTTPRouteRuleFluent.SessionPersistenceNested<A>	editOrNewSessionPersistence()
HTTPRouteRuleFluent.SessionPersistenceNested<A>	editOrNewSessionPersistenceLike(SessionPersistence item)
HTTPRouteRuleFluent.TimeoutsNested<A>	editOrNewTimeouts()
HTTPRouteRuleFluent.TimeoutsNested<A>	editOrNewTimeoutsLike(HTTPRouteTimeouts item)
HTTPRouteRuleFluent.RetryNested<A>	editRetry()
HTTPRouteRuleFluent.SessionPersistenceNested<A>	editSessionPersistence()
HTTPRouteRuleFluent.TimeoutsNested<A>	editTimeouts()
boolean	equals(Object o)
Map<String,Object>	getAdditionalProperties()
String	getName()
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	hasName()
boolean	hasRetry()
boolean	hasSessionPersistence()
boolean	hasTimeouts()
A	removeAllFromBackendRefs(Collection<HTTPBackendRef> items)
A	removeAllFromFilters(Collection<HTTPRouteFilter> items)
A	removeAllFromMatches(Collection<HTTPRouteMatch> items)
A	removeFromAdditionalProperties(String key)
A	removeFromAdditionalProperties(Map<String,Object> map)
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)
A	withName(String name)
HTTPRouteRuleFluent.RetryNested<A>	withNewRetry()
HTTPRouteRuleFluent.RetryNested<A>	withNewRetryLike(HTTPRouteRetry item)
HTTPRouteRuleFluent.SessionPersistenceNested<A>	withNewSessionPersistence()
HTTPRouteRuleFluent.SessionPersistenceNested<A>	withNewSessionPersistenceLike(SessionPersistence item)
HTTPRouteRuleFluent.TimeoutsNested<A>	withNewTimeouts()
A	withNewTimeouts(String backendRequest, String request)
HTTPRouteRuleFluent.TimeoutsNested<A>	withNewTimeoutsLike(HTTPRouteTimeouts item)
A	withRetry(HTTPRouteRetry retry)
A	withSessionPersistence(SessionPersistence sessionPersistence)
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)

getName

public String getName()

withName

public A withName(String name)

hasName

public boolean hasName()

buildRetry

public HTTPRouteRetry buildRetry()

withRetry

public A withRetry(HTTPRouteRetry retry)

hasRetry

public boolean hasRetry()

withNewRetry

public HTTPRouteRuleFluent.RetryNested<A> withNewRetry()

withNewRetryLike

public HTTPRouteRuleFluent.RetryNested<A> withNewRetryLike(HTTPRouteRetry item)

editRetry

public HTTPRouteRuleFluent.RetryNested<A> editRetry()

editOrNewRetry

public HTTPRouteRuleFluent.RetryNested<A> editOrNewRetry()

editOrNewRetryLike

public HTTPRouteRuleFluent.RetryNested<A> editOrNewRetryLike(HTTPRouteRetry item)

buildSessionPersistence

public SessionPersistence buildSessionPersistence()

withSessionPersistence

public A withSessionPersistence(SessionPersistence sessionPersistence)

hasSessionPersistence

public boolean hasSessionPersistence()

withNewSessionPersistence

public HTTPRouteRuleFluent.SessionPersistenceNested<A> withNewSessionPersistence()

withNewSessionPersistenceLike

public HTTPRouteRuleFluent.SessionPersistenceNested<A> withNewSessionPersistenceLike(SessionPersistence item)

editSessionPersistence

public HTTPRouteRuleFluent.SessionPersistenceNested<A> editSessionPersistence()

editOrNewSessionPersistence

public HTTPRouteRuleFluent.SessionPersistenceNested<A> editOrNewSessionPersistence()

editOrNewSessionPersistenceLike

public HTTPRouteRuleFluent.SessionPersistenceNested<A> editOrNewSessionPersistenceLike(SessionPersistence item)

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