RuleFluentImpl (Fabric8 :: Istio :: Model v1beta1 6.2.0 API)

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

All Implemented Interfaces:

RuleFluent<A>, io.fabric8.kubernetes.api.builder.Fluent<A>, io.fabric8.kubernetes.api.builder.Visitable<A>

Direct Known Subclasses:

RuleBuilder
```
public class RuleFluentImpl<A extends RuleFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>
implements RuleFluent<A>
```
Generated

Nested Class Summary
- Nested classes/interfaces inherited from interface io.fabric8.istio.api.security.v1beta1.RuleFluent
  RuleFluent.FromNested<N>, RuleFluent.ToNested<N>, RuleFluent.WhenNested<N>

Field Summary
- Fields inherited from class io.fabric8.kubernetes.api.builder.BaseFluent
  _visitables, VISIT

Constructor Summary

Constructors
Constructor and Description

RuleFluentImpl()

RuleFluentImpl(Rule instance)

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

Method Summary

All Methods Instance Methods Concrete Methods Deprecated 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(Integer index, RuleFrom item)`
`A`	`addToFrom(RuleFrom... items)`
`A`	`addToTo(Integer index, RuleTo item)`
`A`	`addToTo(RuleTo... items)`
`A`	`addToWhen(Condition... items)`
`A`	`addToWhen(Integer index, Condition item)`
`RuleFrom`	`buildFirstFrom()`
`RuleTo`	`buildFirstTo()`
`Condition`	`buildFirstWhen()`
`List<RuleFrom>`	`buildFrom()`
`RuleFrom`	`buildFrom(Integer 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(Integer index)`
`List<Condition>`	`buildWhen()`
`Condition`	`buildWhen(Integer index)`
`RuleFluent.FromNested<A>`	`editFirstFrom()`
`RuleFluent.ToNested<A>`	`editFirstTo()`
`RuleFluent.WhenNested<A>`	`editFirstWhen()`
`RuleFluent.FromNested<A>`	`editFrom(Integer 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(Integer index)`
`RuleFluent.WhenNested<A>`	`editWhen(Integer index)`
`boolean`	`equals(Object o)`
`List<RuleFrom>`	`getFrom()` Deprecated.
`List<RuleTo>`	`getTo()` Deprecated.
`List<Condition>`	`getWhen()` Deprecated.
`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(Integer index, RuleFrom item)`
`RuleFluent.ToNested<A>`	`setNewToLike(Integer index, RuleTo item)`
`RuleFluent.WhenNested<A>`	`setNewWhenLike(Integer index, Condition item)`
`A`	`setToFrom(Integer index, RuleFrom item)`
`A`	`setToTo(Integer index, RuleTo item)`
`A`	`setToWhen(Integer 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
  - RuleFluentImpl
```
public RuleFluentImpl()
```
  - RuleFluentImpl
```
public RuleFluentImpl(Rule instance)
```
- Method Detail
  - addToFrom
```
public A addToFrom(Integer index,
                   RuleFrom item)
```
    Specified by:
    
    addToFrom in interface RuleFluent<A extends RuleFluent<A>>
  - setToFrom
```
public A setToFrom(Integer index,
                   RuleFrom item)
```
    Specified by:
    
    setToFrom in interface RuleFluent<A extends RuleFluent<A>>
  - addToFrom
```
public A addToFrom(RuleFrom... items)
```
    Specified by:
    
    addToFrom in interface RuleFluent<A extends RuleFluent<A>>
  - addAllToFrom
```
public A addAllToFrom(Collection<RuleFrom> items)
```
    Specified by:
    
    addAllToFrom in interface RuleFluent<A extends RuleFluent<A>>
  - removeFromFrom
```
public A removeFromFrom(RuleFrom... items)
```
    Specified by:
    
    removeFromFrom in interface RuleFluent<A extends RuleFluent<A>>
  - removeAllFromFrom
```
public A removeAllFromFrom(Collection<RuleFrom> items)
```
    Specified by:
    
    removeAllFromFrom in interface RuleFluent<A extends RuleFluent<A>>
  - removeMatchingFromFrom
```
public A removeMatchingFromFrom(Predicate<RuleFromBuilder> predicate)
```
    Specified by:
    
    removeMatchingFromFrom in interface RuleFluent<A extends RuleFluent<A>>
  - getFrom
```
@Deprecated
public List<RuleFrom> getFrom()
```
    Deprecated.
    
    This method has been deprecated, please use method buildFrom instead.
    
    Specified by:
    
    getFrom in interface RuleFluent<A extends RuleFluent<A>>
    
    Returns:
    
    The buildable object.
  - buildFrom
```
public List<RuleFrom> buildFrom()
```
    Specified by:
    
    buildFrom in interface RuleFluent<A extends RuleFluent<A>>
  - buildFrom
```
public RuleFrom buildFrom(Integer index)
```
    Specified by:
    
    buildFrom in interface RuleFluent<A extends RuleFluent<A>>
  - buildFirstFrom
```
public RuleFrom buildFirstFrom()
```
    Specified by:
    
    buildFirstFrom in interface RuleFluent<A extends RuleFluent<A>>
  - buildLastFrom
```
public RuleFrom buildLastFrom()
```
    Specified by:
    
    buildLastFrom in interface RuleFluent<A extends RuleFluent<A>>
  - buildMatchingFrom
```
public RuleFrom buildMatchingFrom(Predicate<RuleFromBuilder> predicate)
```
    Specified by:
    
    buildMatchingFrom in interface RuleFluent<A extends RuleFluent<A>>
  - hasMatchingFrom
```
public Boolean hasMatchingFrom(Predicate<RuleFromBuilder> predicate)
```
    Specified by:
    
    hasMatchingFrom in interface RuleFluent<A extends RuleFluent<A>>
  - withFrom
```
public A withFrom(List<RuleFrom> from)
```
    Specified by:
    
    withFrom in interface RuleFluent<A extends RuleFluent<A>>
  - withFrom
```
public A withFrom(RuleFrom... from)
```
    Specified by:
    
    withFrom in interface RuleFluent<A extends RuleFluent<A>>
  - hasFrom
```
public Boolean hasFrom()
```
    Specified by:
    
    hasFrom in interface RuleFluent<A extends RuleFluent<A>>
  - addNewFrom
```
public RuleFluent.FromNested<A> addNewFrom()
```
    Specified by:
    
    addNewFrom in interface RuleFluent<A extends RuleFluent<A>>
  - addNewFromLike
```
public RuleFluent.FromNested<A> addNewFromLike(RuleFrom item)
```
    Specified by:
    
    addNewFromLike in interface RuleFluent<A extends RuleFluent<A>>
  - setNewFromLike
```
public RuleFluent.FromNested<A> setNewFromLike(Integer index,
                                               RuleFrom item)
```
    Specified by:
    
    setNewFromLike in interface RuleFluent<A extends RuleFluent<A>>
  - editFrom
```
public RuleFluent.FromNested<A> editFrom(Integer index)
```
    Specified by:
    
    editFrom in interface RuleFluent<A extends RuleFluent<A>>
  - editFirstFrom
```
public RuleFluent.FromNested<A> editFirstFrom()
```
    Specified by:
    
    editFirstFrom in interface RuleFluent<A extends RuleFluent<A>>
  - editLastFrom
```
public RuleFluent.FromNested<A> editLastFrom()
```
    Specified by:
    
    editLastFrom in interface RuleFluent<A extends RuleFluent<A>>
  - editMatchingFrom
```
public RuleFluent.FromNested<A> editMatchingFrom(Predicate<RuleFromBuilder> predicate)
```
    Specified by:
    
    editMatchingFrom in interface RuleFluent<A extends RuleFluent<A>>
  - addToTo
```
public A addToTo(Integer index,
                 RuleTo item)
```
    Specified by:
    
    addToTo in interface RuleFluent<A extends RuleFluent<A>>
  - setToTo
```
public A setToTo(Integer index,
                 RuleTo item)
```
    Specified by:
    
    setToTo in interface RuleFluent<A extends RuleFluent<A>>
  - addToTo
```
public A addToTo(RuleTo... items)
```
    Specified by:
    
    addToTo in interface RuleFluent<A extends RuleFluent<A>>
  - addAllToTo
```
public A addAllToTo(Collection<RuleTo> items)
```
    Specified by:
    
    addAllToTo in interface RuleFluent<A extends RuleFluent<A>>
  - removeFromTo
```
public A removeFromTo(RuleTo... items)
```
    Specified by:
    
    removeFromTo in interface RuleFluent<A extends RuleFluent<A>>
  - removeAllFromTo
```
public A removeAllFromTo(Collection<RuleTo> items)
```
    Specified by:
    
    removeAllFromTo in interface RuleFluent<A extends RuleFluent<A>>
  - removeMatchingFromTo
```
public A removeMatchingFromTo(Predicate<RuleToBuilder> predicate)
```
    Specified by:
    
    removeMatchingFromTo in interface RuleFluent<A extends RuleFluent<A>>
  - getTo
```
@Deprecated
public List<RuleTo> getTo()
```
    Deprecated.
    
    This method has been deprecated, please use method buildTo instead.
    
    Specified by:
    
    getTo in interface RuleFluent<A extends RuleFluent<A>>
    
    Returns:
    
    The buildable object.
  - buildTo
```
public List<RuleTo> buildTo()
```
    Specified by:
    
    buildTo in interface RuleFluent<A extends RuleFluent<A>>
  - buildTo
```
public RuleTo buildTo(Integer index)
```
    Specified by:
    
    buildTo in interface RuleFluent<A extends RuleFluent<A>>
  - buildFirstTo
```
public RuleTo buildFirstTo()
```
    Specified by:
    
    buildFirstTo in interface RuleFluent<A extends RuleFluent<A>>
  - buildLastTo
```
public RuleTo buildLastTo()
```
    Specified by:
    
    buildLastTo in interface RuleFluent<A extends RuleFluent<A>>
  - buildMatchingTo
```
public RuleTo buildMatchingTo(Predicate<RuleToBuilder> predicate)
```
    Specified by:
    
    buildMatchingTo in interface RuleFluent<A extends RuleFluent<A>>
  - hasMatchingTo
```
public Boolean hasMatchingTo(Predicate<RuleToBuilder> predicate)
```
    Specified by:
    
    hasMatchingTo in interface RuleFluent<A extends RuleFluent<A>>
  - withTo
```
public A withTo(List<RuleTo> to)
```
    Specified by:
    
    withTo in interface RuleFluent<A extends RuleFluent<A>>
  - withTo
```
public A withTo(RuleTo... to)
```
    Specified by:
    
    withTo in interface RuleFluent<A extends RuleFluent<A>>
  - hasTo
```
public Boolean hasTo()
```
    Specified by:
    
    hasTo in interface RuleFluent<A extends RuleFluent<A>>
  - addNewTo
```
public RuleFluent.ToNested<A> addNewTo()
```
    Specified by:
    
    addNewTo in interface RuleFluent<A extends RuleFluent<A>>
  - addNewToLike
```
public RuleFluent.ToNested<A> addNewToLike(RuleTo item)
```
    Specified by:
    
    addNewToLike in interface RuleFluent<A extends RuleFluent<A>>
  - setNewToLike
```
public RuleFluent.ToNested<A> setNewToLike(Integer index,
                                           RuleTo item)
```
    Specified by:
    
    setNewToLike in interface RuleFluent<A extends RuleFluent<A>>
  - editTo
```
public RuleFluent.ToNested<A> editTo(Integer index)
```
    Specified by:
    
    editTo in interface RuleFluent<A extends RuleFluent<A>>
  - editFirstTo
```
public RuleFluent.ToNested<A> editFirstTo()
```
    Specified by:
    
    editFirstTo in interface RuleFluent<A extends RuleFluent<A>>
  - editLastTo
```
public RuleFluent.ToNested<A> editLastTo()
```
    Specified by:
    
    editLastTo in interface RuleFluent<A extends RuleFluent<A>>
  - editMatchingTo
```
public RuleFluent.ToNested<A> editMatchingTo(Predicate<RuleToBuilder> predicate)
```
    Specified by:
    
    editMatchingTo in interface RuleFluent<A extends RuleFluent<A>>
  - addToWhen
```
public A addToWhen(Integer index,
                   Condition item)
```
    Specified by:
    
    addToWhen in interface RuleFluent<A extends RuleFluent<A>>
  - setToWhen
```
public A setToWhen(Integer index,
                   Condition item)
```
    Specified by:
    
    setToWhen in interface RuleFluent<A extends RuleFluent<A>>
  - addToWhen
```
public A addToWhen(Condition... items)
```
    Specified by:
    
    addToWhen in interface RuleFluent<A extends RuleFluent<A>>
  - addAllToWhen
```
public A addAllToWhen(Collection<Condition> items)
```
    Specified by:
    
    addAllToWhen in interface RuleFluent<A extends RuleFluent<A>>
  - removeFromWhen
```
public A removeFromWhen(Condition... items)
```
    Specified by:
    
    removeFromWhen in interface RuleFluent<A extends RuleFluent<A>>
  - removeAllFromWhen
```
public A removeAllFromWhen(Collection<Condition> items)
```
    Specified by:
    
    removeAllFromWhen in interface RuleFluent<A extends RuleFluent<A>>
  - removeMatchingFromWhen
```
public A removeMatchingFromWhen(Predicate<ConditionBuilder> predicate)
```
    Specified by:
    
    removeMatchingFromWhen in interface RuleFluent<A extends RuleFluent<A>>
  - getWhen
```
@Deprecated
public List<Condition> getWhen()
```
    Deprecated.
    
    This method has been deprecated, please use method buildWhen instead.
    
    Specified by:
    
    getWhen in interface RuleFluent<A extends RuleFluent<A>>
    
    Returns:
    
    The buildable object.
  - buildWhen
```
public List<Condition> buildWhen()
```
    Specified by:
    
    buildWhen in interface RuleFluent<A extends RuleFluent<A>>
  - buildWhen
```
public Condition buildWhen(Integer index)
```
    Specified by:
    
    buildWhen in interface RuleFluent<A extends RuleFluent<A>>
  - buildFirstWhen
```
public Condition buildFirstWhen()
```
    Specified by:
    
    buildFirstWhen in interface RuleFluent<A extends RuleFluent<A>>
  - buildLastWhen
```
public Condition buildLastWhen()
```
    Specified by:
    
    buildLastWhen in interface RuleFluent<A extends RuleFluent<A>>
  - buildMatchingWhen
```
public Condition buildMatchingWhen(Predicate<ConditionBuilder> predicate)
```
    Specified by:
    
    buildMatchingWhen in interface RuleFluent<A extends RuleFluent<A>>
  - hasMatchingWhen
```
public Boolean hasMatchingWhen(Predicate<ConditionBuilder> predicate)
```
    Specified by:
    
    hasMatchingWhen in interface RuleFluent<A extends RuleFluent<A>>
  - withWhen
```
public A withWhen(List<Condition> when)
```
    Specified by:
    
    withWhen in interface RuleFluent<A extends RuleFluent<A>>
  - withWhen
```
public A withWhen(Condition... when)
```
    Specified by:
    
    withWhen in interface RuleFluent<A extends RuleFluent<A>>
  - hasWhen
```
public Boolean hasWhen()
```
    Specified by:
    
    hasWhen in interface RuleFluent<A extends RuleFluent<A>>
  - addNewWhen
```
public RuleFluent.WhenNested<A> addNewWhen()
```
    Specified by:
    
    addNewWhen in interface RuleFluent<A extends RuleFluent<A>>
  - addNewWhenLike
```
public RuleFluent.WhenNested<A> addNewWhenLike(Condition item)
```
    Specified by:
    
    addNewWhenLike in interface RuleFluent<A extends RuleFluent<A>>
  - setNewWhenLike
```
public RuleFluent.WhenNested<A> setNewWhenLike(Integer index,
                                               Condition item)
```
    Specified by:
    
    setNewWhenLike in interface RuleFluent<A extends RuleFluent<A>>
  - editWhen
```
public RuleFluent.WhenNested<A> editWhen(Integer index)
```
    Specified by:
    
    editWhen in interface RuleFluent<A extends RuleFluent<A>>
  - editFirstWhen
```
public RuleFluent.WhenNested<A> editFirstWhen()
```
    Specified by:
    
    editFirstWhen in interface RuleFluent<A extends RuleFluent<A>>
  - editLastWhen
```
public RuleFluent.WhenNested<A> editLastWhen()
```
    Specified by:
    
    editLastWhen in interface RuleFluent<A extends RuleFluent<A>>
  - editMatchingWhen
```
public RuleFluent.WhenNested<A> editMatchingWhen(Predicate<ConditionBuilder> predicate)
```
    Specified by:
    
    editMatchingWhen in interface RuleFluent<A extends RuleFluent<A>>
  - 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 RuleFluentImpl<A extends RuleFluent<A>>

Nested Class Summary

Nested classes/interfaces inherited from interface io.fabric8.istio.api.security.v1beta1.RuleFluent

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

RuleFluentImpl

RuleFluentImpl

Method Detail

addToFrom

setToFrom

addToFrom

addAllToFrom

removeFromFrom

removeAllFromFrom

removeMatchingFromFrom

getFrom

buildFrom

buildFrom

buildFirstFrom

buildLastFrom

buildMatchingFrom

hasMatchingFrom

withFrom

withFrom

hasFrom

addNewFrom

addNewFromLike

setNewFromLike

editFrom

editFirstFrom

editLastFrom

editMatchingFrom

addToTo

setToTo

addToTo

addAllToTo

removeFromTo

removeAllFromTo

removeMatchingFromTo

getTo

buildTo

buildTo

buildFirstTo

buildLastTo

buildMatchingTo

hasMatchingTo

withTo

withTo

hasTo

addNewTo

addNewToLike

setNewToLike

editTo

editFirstTo

editLastTo

editMatchingTo

addToWhen

setToWhen

addToWhen

addAllToWhen

removeFromWhen

removeAllFromWhen

removeMatchingFromWhen

getWhen

buildWhen

buildWhen

buildFirstWhen

buildLastWhen

buildMatchingWhen

hasMatchingWhen

withWhen

withWhen

hasWhen

addNewWhen