io.fabric8.istio.api.security.v1beta1

Class RuleFluent<A extends RuleFluent<A>>

java.lang.Object

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

io.fabric8.istio.api.security.v1beta1.RuleFluent<A>

Direct Known Subclasses:

AuthorizationPolicySpecFluent.RulesNested, RuleBuilder

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

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	RuleFluent.FromNested<N>
class	RuleFluent.ToNested<N>
class	RuleFluent.WhenNested<N>

Field Summary

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

_visitables, VISIT

Constructor Summary

Constructors

Constructor and Description
RuleFluent()
RuleFluent(Rule instance)

Method Summary

Modifier and Type	Method and Description
A	addAllToFrom(Collection<RuleFrom> items)
A	addAllToTo(Collection<RuleTo> items)
A	addAllToWhen(Collection<Condition> items)
RuleFluent.FromNested<A>	addNewFrom()
RuleFluent.FromNested<A>	addNewFromLike(RuleFrom item)
RuleFluent.ToNested<A>	addNewTo()
RuleFluent.ToNested<A>	addNewToLike(RuleTo item)
RuleFluent.WhenNested<A>	addNewWhen()
RuleFluent.WhenNested<A>	addNewWhenLike(Condition item)
A	addToAdditionalProperties(Map<String,Object> map)
A	addToAdditionalProperties(String key, Object value)
A	addToFrom(int index, RuleFrom item)
A	addToFrom(RuleFrom... items)
A	addToTo(int index, RuleTo item)
A	addToTo(RuleTo... items)
A	addToWhen(Condition... items)
A	addToWhen(int index, Condition item)
RuleFrom	buildFirstFrom()
RuleTo	buildFirstTo()
Condition	buildFirstWhen()
List<RuleFrom>	buildFrom()
RuleFrom	buildFrom(int index)
RuleFrom	buildLastFrom()
RuleTo	buildLastTo()
Condition	buildLastWhen()
RuleFrom	buildMatchingFrom(Predicate<RuleFromBuilder> predicate)
RuleTo	buildMatchingTo(Predicate<RuleToBuilder> predicate)
Condition	buildMatchingWhen(Predicate<ConditionBuilder> predicate)
List<RuleTo>	buildTo()
RuleTo	buildTo(int index)
List<Condition>	buildWhen()
Condition	buildWhen(int index)
protected void	copyInstance(Rule instance)
RuleFluent.FromNested<A>	editFirstFrom()
RuleFluent.ToNested<A>	editFirstTo()
RuleFluent.WhenNested<A>	editFirstWhen()
RuleFluent.FromNested<A>	editFrom(int index)
RuleFluent.FromNested<A>	editLastFrom()
RuleFluent.ToNested<A>	editLastTo()
RuleFluent.WhenNested<A>	editLastWhen()
RuleFluent.FromNested<A>	editMatchingFrom(Predicate<RuleFromBuilder> predicate)
RuleFluent.ToNested<A>	editMatchingTo(Predicate<RuleToBuilder> predicate)
RuleFluent.WhenNested<A>	editMatchingWhen(Predicate<ConditionBuilder> predicate)
RuleFluent.ToNested<A>	editTo(int index)
RuleFluent.WhenNested<A>	editWhen(int index)
boolean	equals(Object o)
Map<String,Object>	getAdditionalProperties()
boolean	hasAdditionalProperties()
boolean	hasFrom()
int	hashCode()
boolean	hasMatchingFrom(Predicate<RuleFromBuilder> predicate)
boolean	hasMatchingTo(Predicate<RuleToBuilder> predicate)
boolean	hasMatchingWhen(Predicate<ConditionBuilder> predicate)
boolean	hasTo()
boolean	hasWhen()
A	removeAllFromFrom(Collection<RuleFrom> items)
A	removeAllFromTo(Collection<RuleTo> items)
A	removeAllFromWhen(Collection<Condition> items)
A	removeFromAdditionalProperties(Map<String,Object> map)
A	removeFromAdditionalProperties(String key)
A	removeFromFrom(RuleFrom... items)
A	removeFromTo(RuleTo... items)
A	removeFromWhen(Condition... items)
A	removeMatchingFromFrom(Predicate<RuleFromBuilder> predicate)
A	removeMatchingFromTo(Predicate<RuleToBuilder> predicate)
A	removeMatchingFromWhen(Predicate<ConditionBuilder> predicate)
RuleFluent.FromNested<A>	setNewFromLike(int index, RuleFrom item)
RuleFluent.ToNested<A>	setNewToLike(int index, RuleTo item)
RuleFluent.WhenNested<A>	setNewWhenLike(int index, Condition item)
A	setToFrom(int index, RuleFrom item)
A	setToTo(int index, RuleTo item)
A	setToWhen(int index, Condition item)
String	toString()
<K,V> A	withAdditionalProperties(Map<String,Object> additionalProperties)
A	withFrom(List<RuleFrom> from)
A	withFrom(RuleFrom... from)
A	withTo(List<RuleTo> to)
A	withTo(RuleTo... to)
A	withWhen(Condition... when)
A	withWhen(List<Condition> when)

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

RuleFluent

public RuleFluent()

RuleFluent

public RuleFluent(Rule instance)

Method Detail

copyInstance

protected void copyInstance(Rule instance)

addToFrom

public A addToFrom(int index,
                   RuleFrom item)

setToFrom

public A setToFrom(int index,
                   RuleFrom item)

addToFrom

public A addToFrom(RuleFrom... items)

addAllToFrom

public A addAllToFrom(Collection<RuleFrom> items)

removeFromFrom

public A removeFromFrom(RuleFrom... items)

removeAllFromFrom

public A removeAllFromFrom(Collection<RuleFrom> items)

removeMatchingFromFrom

public A removeMatchingFromFrom(Predicate<RuleFromBuilder> predicate)

buildFrom

public List<RuleFrom> buildFrom()

buildFrom

public RuleFrom buildFrom(int index)

buildFirstFrom

public RuleFrom buildFirstFrom()

buildLastFrom

public RuleFrom buildLastFrom()

buildMatchingFrom

public RuleFrom buildMatchingFrom(Predicate<RuleFromBuilder> predicate)

hasMatchingFrom

public boolean hasMatchingFrom(Predicate<RuleFromBuilder> predicate)

withFrom

public A withFrom(List<RuleFrom> from)

withFrom

public A withFrom(RuleFrom... from)

hasFrom

public boolean hasFrom()

addNewFrom

public RuleFluent.FromNested<A> addNewFrom()

addNewFromLike

public RuleFluent.FromNested<A> addNewFromLike(RuleFrom item)

setNewFromLike

public RuleFluent.FromNested<A> setNewFromLike(int index,
                                               RuleFrom item)

editFrom

public RuleFluent.FromNested<A> editFrom(int index)

editFirstFrom

public RuleFluent.FromNested<A> editFirstFrom()

editLastFrom

public RuleFluent.FromNested<A> editLastFrom()

editMatchingFrom

public RuleFluent.FromNested<A> editMatchingFrom(Predicate<RuleFromBuilder> predicate)

addToTo

public A addToTo(int index,
                 RuleTo item)

setToTo

public A setToTo(int index,
                 RuleTo item)

addToTo

public A addToTo(RuleTo... items)

addAllToTo

public A addAllToTo(Collection<RuleTo> items)

removeFromTo

public A removeFromTo(RuleTo... items)

removeAllFromTo

public A removeAllFromTo(Collection<RuleTo> items)

removeMatchingFromTo

public A removeMatchingFromTo(Predicate<RuleToBuilder> predicate)

buildTo

public List<RuleTo> buildTo()

buildTo

public RuleTo buildTo(int index)

buildFirstTo

public RuleTo buildFirstTo()

buildLastTo

public RuleTo buildLastTo()

buildMatchingTo

public RuleTo buildMatchingTo(Predicate<RuleToBuilder> predicate)

hasMatchingTo

public boolean hasMatchingTo(Predicate<RuleToBuilder> predicate)

withTo

public A withTo(List<RuleTo> to)

withTo

public A withTo(RuleTo... to)

hasTo

public boolean hasTo()

addNewTo

public RuleFluent.ToNested<A> addNewTo()

addNewToLike

public RuleFluent.ToNested<A> addNewToLike(RuleTo item)

setNewToLike

public RuleFluent.ToNested<A> setNewToLike(int index,
                                           RuleTo item)

editTo

public RuleFluent.ToNested<A> editTo(int index)

editFirstTo

public RuleFluent.ToNested<A> editFirstTo()

editLastTo

public RuleFluent.ToNested<A> editLastTo()

editMatchingTo

public RuleFluent.ToNested<A> editMatchingTo(Predicate<RuleToBuilder> predicate)

addToWhen

public A addToWhen(int index,
                   Condition item)

setToWhen

public A setToWhen(int index,
                   Condition item)

addToWhen

public A addToWhen(Condition... items)

addAllToWhen

public A addAllToWhen(Collection<Condition> items)

removeFromWhen

public A removeFromWhen(Condition... items)

removeAllFromWhen

public A removeAllFromWhen(Collection<Condition> items)

removeMatchingFromWhen

public A removeMatchingFromWhen(Predicate<ConditionBuilder> predicate)

buildWhen

public List<Condition> buildWhen()

buildWhen

public Condition buildWhen(int index)

buildFirstWhen

public Condition buildFirstWhen()

buildLastWhen

public Condition buildLastWhen()

buildMatchingWhen

public Condition buildMatchingWhen(Predicate<ConditionBuilder> predicate)

hasMatchingWhen

public boolean hasMatchingWhen(Predicate<ConditionBuilder> predicate)

withWhen

public A withWhen(List<Condition> when)

withWhen

public A withWhen(Condition... when)

hasWhen

public boolean hasWhen()

addNewWhen

public RuleFluent.WhenNested<A> addNewWhen()

addNewWhenLike

public RuleFluent.WhenNested<A> addNewWhenLike(Condition item)

setNewWhenLike

public RuleFluent.WhenNested<A> setNewWhenLike(int index,
                                               Condition item)

editWhen

public RuleFluent.WhenNested<A> editWhen(int index)

editFirstWhen

public RuleFluent.WhenNested<A> editFirstWhen()

editLastWhen

public RuleFluent.WhenNested<A> editLastWhen()

editMatchingWhen

public RuleFluent.WhenNested<A> editMatchingWhen(Predicate<ConditionBuilder> 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 RuleFluent<A>>

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object