RuleFluent (Fabric8 :: Istio :: Model v1beta1 6.8.1 API)

java.lang.Object
- io.fabric8.kubernetes.api.builder.BaseFluent<A>
- - io.fabric8.istio.api.security.v1beta1.RuleFluent<A>

All Implemented Interfaces:

io.fabric8.kubernetes.api.builder.Fluent<A>, io.fabric8.kubernetes.api.builder.Visitable<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>

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)

Constructors
Constructor and Description
`RuleFluent()`
`RuleFluent(Rule instance)`

Method Summary

All Methods Instance Methods Concrete Methods
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`	`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)`
`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)`
`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`	`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()`
`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
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

RuleFluent
```
public RuleFluent()
```

RuleFluent
```
public RuleFluent(Rule instance)
```

Method Detail

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)

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

Class RuleFluent<A extends RuleFluent<A>>

Nested Class Summary

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

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

Constructor Detail

RuleFluent

RuleFluent

Method Detail

addToFrom

setToFrom

addToFrom

addAllToFrom

removeFromFrom

removeAllFromFrom

removeMatchingFromFrom

buildFrom

buildFrom

buildFirstFrom

buildLastFrom

buildMatchingFrom

hasMatchingFrom

withFrom

withFrom

hasFrom

addNewFrom

addNewFromLike

setNewFromLike

editFrom

editFirstFrom

editLastFrom

editMatchingFrom

addToTo

setToTo

addToTo

addAllToTo

removeFromTo

removeAllFromTo

removeMatchingFromTo

buildTo

buildTo

buildFirstTo

buildLastTo

buildMatchingTo

hasMatchingTo

withTo

withTo

hasTo

addNewTo

addNewToLike

setNewToLike

editTo

editFirstTo

editLastTo

editMatchingTo

addToWhen

setToWhen

addToWhen

addAllToWhen

removeFromWhen

removeAllFromWhen

removeMatchingFromWhen

buildWhen

buildWhen

buildFirstWhen

buildLastWhen

buildMatchingWhen

hasMatchingWhen

withWhen

withWhen

hasWhen

addNewWhen

addNewWhenLike

setNewWhenLike

editWhen

editFirstWhen