Package io.fabric8.openshift.api.model.monitoring.v1alpha1

Class InhibitRuleFluent<A extends InhibitRuleFluent<A>>

java.lang.Object

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

io.fabric8.openshift.api.model.monitoring.v1alpha1.InhibitRuleFluent<A>

Direct Known Subclasses:

AlertmanagerConfigSpecFluent.InhibitRulesNested, InhibitRuleBuilder

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

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	InhibitRuleFluent.SourceMatchNested<N>
class	InhibitRuleFluent.TargetMatchNested<N>

Field Summary

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

_visitables, VISIT

Constructor Summary

Constructors

Constructor	Description
InhibitRuleFluent()
InhibitRuleFluent(InhibitRule instance)

Method Summary

Modifier and Type	Method	Description
A	addAllToEqual(Collection<String> items)
A	addAllToSourceMatch(Collection<Matcher> items)
A	addAllToTargetMatch(Collection<Matcher> items)
InhibitRuleFluent.SourceMatchNested<A>	addNewSourceMatch()
A	addNewSourceMatch(String matchType, String name, Boolean regex, String value)
InhibitRuleFluent.SourceMatchNested<A>	addNewSourceMatchLike(Matcher item)
InhibitRuleFluent.TargetMatchNested<A>	addNewTargetMatch()
A	addNewTargetMatch(String matchType, String name, Boolean regex, String value)
InhibitRuleFluent.TargetMatchNested<A>	addNewTargetMatchLike(Matcher item)
A	addToAdditionalProperties(String key, Object value)
A	addToAdditionalProperties(Map<String,Object> map)
A	addToEqual(int index, String item)
A	addToEqual(String... items)
A	addToSourceMatch(int index, Matcher item)
A	addToSourceMatch(Matcher... items)
A	addToTargetMatch(int index, Matcher item)
A	addToTargetMatch(Matcher... items)
Matcher	buildFirstSourceMatch()
Matcher	buildFirstTargetMatch()
Matcher	buildLastSourceMatch()
Matcher	buildLastTargetMatch()
Matcher	buildMatchingSourceMatch(Predicate<MatcherBuilder> predicate)
Matcher	buildMatchingTargetMatch(Predicate<MatcherBuilder> predicate)
List<Matcher>	buildSourceMatch()
Matcher	buildSourceMatch(int index)
List<Matcher>	buildTargetMatch()
Matcher	buildTargetMatch(int index)
protected void	copyInstance(InhibitRule instance)
InhibitRuleFluent.SourceMatchNested<A>	editFirstSourceMatch()
InhibitRuleFluent.TargetMatchNested<A>	editFirstTargetMatch()
InhibitRuleFluent.SourceMatchNested<A>	editLastSourceMatch()
InhibitRuleFluent.TargetMatchNested<A>	editLastTargetMatch()
InhibitRuleFluent.SourceMatchNested<A>	editMatchingSourceMatch(Predicate<MatcherBuilder> predicate)
InhibitRuleFluent.TargetMatchNested<A>	editMatchingTargetMatch(Predicate<MatcherBuilder> predicate)
InhibitRuleFluent.SourceMatchNested<A>	editSourceMatch(int index)
InhibitRuleFluent.TargetMatchNested<A>	editTargetMatch(int index)
boolean	equals(Object o)
Map<String,Object>	getAdditionalProperties()
List<String>	getEqual()
String	getEqual(int index)
String	getFirstEqual()
String	getLastEqual()
String	getMatchingEqual(Predicate<String> predicate)
boolean	hasAdditionalProperties()
boolean	hasEqual()
int	hashCode()
boolean	hasMatchingEqual(Predicate<String> predicate)
boolean	hasMatchingSourceMatch(Predicate<MatcherBuilder> predicate)
boolean	hasMatchingTargetMatch(Predicate<MatcherBuilder> predicate)
boolean	hasSourceMatch()
boolean	hasTargetMatch()
A	removeAllFromEqual(Collection<String> items)
A	removeAllFromSourceMatch(Collection<Matcher> items)
A	removeAllFromTargetMatch(Collection<Matcher> items)
A	removeFromAdditionalProperties(String key)
A	removeFromAdditionalProperties(Map<String,Object> map)
A	removeFromEqual(String... items)
A	removeFromSourceMatch(Matcher... items)
A	removeFromTargetMatch(Matcher... items)
A	removeMatchingFromSourceMatch(Predicate<MatcherBuilder> predicate)
A	removeMatchingFromTargetMatch(Predicate<MatcherBuilder> predicate)
InhibitRuleFluent.SourceMatchNested<A>	setNewSourceMatchLike(int index, Matcher item)
InhibitRuleFluent.TargetMatchNested<A>	setNewTargetMatchLike(int index, Matcher item)
A	setToEqual(int index, String item)
A	setToSourceMatch(int index, Matcher item)
A	setToTargetMatch(int index, Matcher item)
String	toString()
<K,V> A	withAdditionalProperties(Map<String,Object> additionalProperties)
A	withEqual(String... equal)
A	withEqual(List<String> equal)
A	withSourceMatch(Matcher... sourceMatch)
A	withSourceMatch(List<Matcher> sourceMatch)
A	withTargetMatch(Matcher... targetMatch)
A	withTargetMatch(List<Matcher> targetMatch)

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

InhibitRuleFluent

public InhibitRuleFluent()

InhibitRuleFluent

public InhibitRuleFluent(InhibitRule instance)

Method Detail

copyInstance

protected void copyInstance(InhibitRule instance)

addToEqual

public A addToEqual(int index,
                    String item)

setToEqual

public A setToEqual(int index,
                    String item)

addToEqual

public A addToEqual(String... items)

addAllToEqual

public A addAllToEqual(Collection<String> items)

removeFromEqual

public A removeFromEqual(String... items)

removeAllFromEqual

public A removeAllFromEqual(Collection<String> items)

getEqual

public List<String> getEqual()

getEqual

public String getEqual(int index)

getFirstEqual

public String getFirstEqual()

getLastEqual

public String getLastEqual()

getMatchingEqual

public String getMatchingEqual(Predicate<String> predicate)

hasMatchingEqual

public boolean hasMatchingEqual(Predicate<String> predicate)

withEqual

public A withEqual(List<String> equal)

withEqual

public A withEqual(String... equal)

hasEqual

public boolean hasEqual()

addToSourceMatch

public A addToSourceMatch(int index,
                          Matcher item)

setToSourceMatch

public A setToSourceMatch(int index,
                          Matcher item)

addToSourceMatch

public A addToSourceMatch(Matcher... items)

addAllToSourceMatch

public A addAllToSourceMatch(Collection<Matcher> items)

removeFromSourceMatch

public A removeFromSourceMatch(Matcher... items)

removeAllFromSourceMatch

public A removeAllFromSourceMatch(Collection<Matcher> items)

removeMatchingFromSourceMatch

public A removeMatchingFromSourceMatch(Predicate<MatcherBuilder> predicate)

buildSourceMatch

public List<Matcher> buildSourceMatch()

buildSourceMatch

public Matcher buildSourceMatch(int index)

buildFirstSourceMatch

public Matcher buildFirstSourceMatch()

buildLastSourceMatch

public Matcher buildLastSourceMatch()

buildMatchingSourceMatch

public Matcher buildMatchingSourceMatch(Predicate<MatcherBuilder> predicate)

hasMatchingSourceMatch

public boolean hasMatchingSourceMatch(Predicate<MatcherBuilder> predicate)

withSourceMatch

public A withSourceMatch(List<Matcher> sourceMatch)

withSourceMatch

public A withSourceMatch(Matcher... sourceMatch)

hasSourceMatch

public boolean hasSourceMatch()

addNewSourceMatch

public A addNewSourceMatch(String matchType,
                           String name,
                           Boolean regex,
                           String value)

addNewSourceMatch

public InhibitRuleFluent.SourceMatchNested<A> addNewSourceMatch()

addNewSourceMatchLike

public InhibitRuleFluent.SourceMatchNested<A> addNewSourceMatchLike(Matcher item)

setNewSourceMatchLike

public InhibitRuleFluent.SourceMatchNested<A> setNewSourceMatchLike(int index,
                                                                    Matcher item)

editSourceMatch

public InhibitRuleFluent.SourceMatchNested<A> editSourceMatch(int index)

editFirstSourceMatch

public InhibitRuleFluent.SourceMatchNested<A> editFirstSourceMatch()

editLastSourceMatch

public InhibitRuleFluent.SourceMatchNested<A> editLastSourceMatch()

editMatchingSourceMatch

public InhibitRuleFluent.SourceMatchNested<A> editMatchingSourceMatch(Predicate<MatcherBuilder> predicate)

addToTargetMatch

public A addToTargetMatch(int index,
                          Matcher item)

setToTargetMatch

public A setToTargetMatch(int index,
                          Matcher item)

addToTargetMatch

public A addToTargetMatch(Matcher... items)

addAllToTargetMatch

public A addAllToTargetMatch(Collection<Matcher> items)

removeFromTargetMatch

public A removeFromTargetMatch(Matcher... items)

removeAllFromTargetMatch

public A removeAllFromTargetMatch(Collection<Matcher> items)

removeMatchingFromTargetMatch

public A removeMatchingFromTargetMatch(Predicate<MatcherBuilder> predicate)

buildTargetMatch

public List<Matcher> buildTargetMatch()

buildTargetMatch

public Matcher buildTargetMatch(int index)

buildFirstTargetMatch

public Matcher buildFirstTargetMatch()

buildLastTargetMatch

public Matcher buildLastTargetMatch()

buildMatchingTargetMatch

public Matcher buildMatchingTargetMatch(Predicate<MatcherBuilder> predicate)

hasMatchingTargetMatch

public boolean hasMatchingTargetMatch(Predicate<MatcherBuilder> predicate)

withTargetMatch

public A withTargetMatch(List<Matcher> targetMatch)

withTargetMatch

public A withTargetMatch(Matcher... targetMatch)

hasTargetMatch

public boolean hasTargetMatch()

addNewTargetMatch

public A addNewTargetMatch(String matchType,
                           String name,
                           Boolean regex,
                           String value)

addNewTargetMatch

public InhibitRuleFluent.TargetMatchNested<A> addNewTargetMatch()

addNewTargetMatchLike

public InhibitRuleFluent.TargetMatchNested<A> addNewTargetMatchLike(Matcher item)

setNewTargetMatchLike

public InhibitRuleFluent.TargetMatchNested<A> setNewTargetMatchLike(int index,
                                                                    Matcher item)

editTargetMatch

public InhibitRuleFluent.TargetMatchNested<A> editTargetMatch(int index)

editFirstTargetMatch

public InhibitRuleFluent.TargetMatchNested<A> editFirstTargetMatch()

editLastTargetMatch

public InhibitRuleFluent.TargetMatchNested<A> editLastTargetMatch()

editMatchingTargetMatch

public InhibitRuleFluent.TargetMatchNested<A> editMatchingTargetMatch(Predicate<MatcherBuilder> 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 InhibitRuleFluent<A>>

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object