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

All Superinterfaces:

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

All Known Subinterfaces:

AuthorizationPolicySpecFluent.RulesNested<N>, IstioSchemaFluent.IstioIoApiSecurityV1beta1RuleNested<N>

All Known Implementing Classes:

AuthorizationPolicySpecFluentImpl.RulesNestedImpl, IstioSchemaFluentImpl.IstioIoApiSecurityV1beta1RuleNestedImpl, RuleBuilder, RuleFluentImpl
```
public interface RuleFluent<A extends RuleFluent<A>>
extends io.fabric8.kubernetes.api.builder.Fluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`RuleFluent.FromNested<N>`
`static interface`	`RuleFluent.ToNested<N>`
`static interface`	`RuleFluent.WhenNested<N>`

Method Summary

All Methods Instance Methods Abstract 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)`
`List<RuleFrom>`	`getFrom()` Deprecated.
`List<RuleTo>`	`getTo()` Deprecated.
`List<Condition>`	`getWhen()` Deprecated.
`Boolean`	`hasFrom()`
`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)`
`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)`

Method Detail

addToFrom

A addToFrom(Integer index,
            RuleFrom item)

setToFrom

A setToFrom(Integer index,
            RuleFrom item)

addToFrom
```
A addToFrom(RuleFrom... items)
```

addAllToFrom

A addAllToFrom(Collection<RuleFrom> items)

removeFromFrom
```
A removeFromFrom(RuleFrom... items)
```

removeAllFromFrom

A removeAllFromFrom(Collection<RuleFrom> items)

removeMatchingFromFrom

A removeMatchingFromFrom(Predicate<RuleFromBuilder> predicate)

getFrom
```
@Deprecated
List<RuleFrom> getFrom()
```
Deprecated.

This method has been deprecated, please use method buildFrom instead.

Returns:

The buildable object.

buildFrom
```
List<RuleFrom> buildFrom()
```

buildFrom
```
RuleFrom buildFrom(Integer index)
```

buildFirstFrom
```
RuleFrom buildFirstFrom()
```

buildLastFrom
```
RuleFrom buildLastFrom()
```

buildMatchingFrom

RuleFrom buildMatchingFrom(Predicate<RuleFromBuilder> predicate)

hasMatchingFrom

Boolean hasMatchingFrom(Predicate<RuleFromBuilder> predicate)

withFrom
```
A withFrom(List<RuleFrom> from)
```

withFrom
```
A withFrom(RuleFrom... from)
```

hasFrom
```
Boolean hasFrom()
```

addNewFrom
```
RuleFluent.FromNested<A> addNewFrom()
```

addNewFromLike

RuleFluent.FromNested<A> addNewFromLike(RuleFrom item)

setNewFromLike

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

editFrom

RuleFluent.FromNested<A> editFrom(Integer index)

editFirstFrom

RuleFluent.FromNested<A> editFirstFrom()

editLastFrom

RuleFluent.FromNested<A> editLastFrom()

editMatchingFrom

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

addToTo

A addToTo(Integer index,
          RuleTo item)

setToTo

A setToTo(Integer index,
          RuleTo item)

addToTo
```
A addToTo(RuleTo... items)
```

addAllToTo

A addAllToTo(Collection<RuleTo> items)

removeFromTo
```
A removeFromTo(RuleTo... items)
```

removeAllFromTo

A removeAllFromTo(Collection<RuleTo> items)

removeMatchingFromTo

A removeMatchingFromTo(Predicate<RuleToBuilder> predicate)

getTo
```
@Deprecated
List<RuleTo> getTo()
```
Deprecated.

This method has been deprecated, please use method buildTo instead.

Returns:

The buildable object.

buildTo
```
List<RuleTo> buildTo()
```

buildTo
```
RuleTo buildTo(Integer index)
```

buildFirstTo
```
RuleTo buildFirstTo()
```

buildLastTo
```
RuleTo buildLastTo()
```

buildMatchingTo

RuleTo buildMatchingTo(Predicate<RuleToBuilder> predicate)

hasMatchingTo

Boolean hasMatchingTo(Predicate<RuleToBuilder> predicate)

withTo
```
A withTo(List<RuleTo> to)
```

withTo
```
A withTo(RuleTo... to)
```

hasTo
```
Boolean hasTo()
```

addNewTo
```
RuleFluent.ToNested<A> addNewTo()
```

addNewToLike

RuleFluent.ToNested<A> addNewToLike(RuleTo item)

setNewToLike

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

editTo

RuleFluent.ToNested<A> editTo(Integer index)

editFirstTo
```
RuleFluent.ToNested<A> editFirstTo()
```

editLastTo
```
RuleFluent.ToNested<A> editLastTo()
```

editMatchingTo

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

addToWhen

A addToWhen(Integer index,
            Condition item)

setToWhen

A setToWhen(Integer index,
            Condition item)

addToWhen
```
A addToWhen(Condition... items)
```

addAllToWhen

A addAllToWhen(Collection<Condition> items)

removeFromWhen
```
A removeFromWhen(Condition... items)
```

removeAllFromWhen

A removeAllFromWhen(Collection<Condition> items)

removeMatchingFromWhen

A removeMatchingFromWhen(Predicate<ConditionBuilder> predicate)

getWhen
```
@Deprecated
List<Condition> getWhen()
```
Deprecated.

This method has been deprecated, please use method buildWhen instead.

Returns:

The buildable object.

buildWhen
```
List<Condition> buildWhen()
```

buildWhen
```
Condition buildWhen(Integer index)
```

buildFirstWhen
```
Condition buildFirstWhen()
```

buildLastWhen
```
Condition buildLastWhen()
```

buildMatchingWhen

Condition buildMatchingWhen(Predicate<ConditionBuilder> predicate)

hasMatchingWhen

Boolean hasMatchingWhen(Predicate<ConditionBuilder> predicate)

withWhen
```
A withWhen(List<Condition> when)
```

withWhen
```
A withWhen(Condition... when)
```

hasWhen
```
Boolean hasWhen()
```

addNewWhen
```
RuleFluent.WhenNested<A> addNewWhen()
```

addNewWhenLike

RuleFluent.WhenNested<A> addNewWhenLike(Condition item)

setNewWhenLike

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

editWhen

RuleFluent.WhenNested<A> editWhen(Integer index)

editFirstWhen

RuleFluent.WhenNested<A> editFirstWhen()

editLastWhen

RuleFluent.WhenNested<A> editLastWhen()

editMatchingWhen

RuleFluent.WhenNested<A> editMatchingWhen(Predicate<ConditionBuilder> predicate)

Interface RuleFluent<A extends RuleFluent<A>>

Nested Class Summary

Method Summary

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

addNewWhenLike

setNewWhenLike

editWhen

editFirstWhen

editLastWhen

editMatchingWhen