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

All Superinterfaces:

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

All Known Subinterfaces:

IstioSchemaFluent.IstioIoApiSecurityV1beta1OperationNested<N>, RuleToFluent.OperationNested<N>

All Known Implementing Classes:

IstioSchemaFluentImpl.IstioIoApiSecurityV1beta1OperationNestedImpl, OperationBuilder, OperationFluentImpl, RuleToFluentImpl.OperationNestedImpl
```
public interface OperationFluent<A extends OperationFluent<A>>
extends io.fabric8.kubernetes.api.builder.Fluent<A>
```
Generated

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`A`	`addAllToHosts(Collection<String> items)`
`A`	`addAllToMethods(Collection<String> items)`
`A`	`addAllToNotHosts(Collection<String> items)`
`A`	`addAllToNotMethods(Collection<String> items)`
`A`	`addAllToNotPaths(Collection<String> items)`
`A`	`addAllToNotPorts(Collection<String> items)`
`A`	`addAllToPaths(Collection<String> items)`
`A`	`addAllToPorts(Collection<String> items)`
`A`	`addNewHost(String arg0)`
`A`	`addNewMethod(String arg0)`
`A`	`addNewNotHost(String arg0)`
`A`	`addNewNotMethod(String arg0)`
`A`	`addNewNotPath(String arg0)`
`A`	`addNewNotPort(String arg0)`
`A`	`addNewPath(String arg0)`
`A`	`addNewPort(String arg0)`
`A`	`addToHosts(Integer index, String item)`
`A`	`addToHosts(String... items)`
`A`	`addToMethods(Integer index, String item)`
`A`	`addToMethods(String... items)`
`A`	`addToNotHosts(Integer index, String item)`
`A`	`addToNotHosts(String... items)`
`A`	`addToNotMethods(Integer index, String item)`
`A`	`addToNotMethods(String... items)`
`A`	`addToNotPaths(Integer index, String item)`
`A`	`addToNotPaths(String... items)`
`A`	`addToNotPorts(Integer index, String item)`
`A`	`addToNotPorts(String... items)`
`A`	`addToPaths(Integer index, String item)`
`A`	`addToPaths(String... items)`
`A`	`addToPorts(Integer index, String item)`
`A`	`addToPorts(String... items)`
`String`	`getFirstHost()`
`String`	`getFirstMethod()`
`String`	`getFirstNotHost()`
`String`	`getFirstNotMethod()`
`String`	`getFirstNotPath()`
`String`	`getFirstNotPort()`
`String`	`getFirstPath()`
`String`	`getFirstPort()`
`String`	`getHost(Integer index)`
`List<String>`	`getHosts()`
`String`	`getLastHost()`
`String`	`getLastMethod()`
`String`	`getLastNotHost()`
`String`	`getLastNotMethod()`
`String`	`getLastNotPath()`
`String`	`getLastNotPort()`
`String`	`getLastPath()`
`String`	`getLastPort()`
`String`	`getMatchingHost(Predicate<String> predicate)`
`String`	`getMatchingMethod(Predicate<String> predicate)`
`String`	`getMatchingNotHost(Predicate<String> predicate)`
`String`	`getMatchingNotMethod(Predicate<String> predicate)`
`String`	`getMatchingNotPath(Predicate<String> predicate)`
`String`	`getMatchingNotPort(Predicate<String> predicate)`
`String`	`getMatchingPath(Predicate<String> predicate)`
`String`	`getMatchingPort(Predicate<String> predicate)`
`String`	`getMethod(Integer index)`
`List<String>`	`getMethods()`
`String`	`getNotHost(Integer index)`
`List<String>`	`getNotHosts()`
`String`	`getNotMethod(Integer index)`
`List<String>`	`getNotMethods()`
`String`	`getNotPath(Integer index)`
`List<String>`	`getNotPaths()`
`String`	`getNotPort(Integer index)`
`List<String>`	`getNotPorts()`
`String`	`getPath(Integer index)`
`List<String>`	`getPaths()`
`String`	`getPort(Integer index)`
`List<String>`	`getPorts()`
`Boolean`	`hasHosts()`
`Boolean`	`hasMatchingHost(Predicate<String> predicate)`
`Boolean`	`hasMatchingMethod(Predicate<String> predicate)`
`Boolean`	`hasMatchingNotHost(Predicate<String> predicate)`
`Boolean`	`hasMatchingNotMethod(Predicate<String> predicate)`
`Boolean`	`hasMatchingNotPath(Predicate<String> predicate)`
`Boolean`	`hasMatchingNotPort(Predicate<String> predicate)`
`Boolean`	`hasMatchingPath(Predicate<String> predicate)`
`Boolean`	`hasMatchingPort(Predicate<String> predicate)`
`Boolean`	`hasMethods()`
`Boolean`	`hasNotHosts()`
`Boolean`	`hasNotMethods()`
`Boolean`	`hasNotPaths()`
`Boolean`	`hasNotPorts()`
`Boolean`	`hasPaths()`
`Boolean`	`hasPorts()`
`A`	`removeAllFromHosts(Collection<String> items)`
`A`	`removeAllFromMethods(Collection<String> items)`
`A`	`removeAllFromNotHosts(Collection<String> items)`
`A`	`removeAllFromNotMethods(Collection<String> items)`
`A`	`removeAllFromNotPaths(Collection<String> items)`
`A`	`removeAllFromNotPorts(Collection<String> items)`
`A`	`removeAllFromPaths(Collection<String> items)`
`A`	`removeAllFromPorts(Collection<String> items)`
`A`	`removeFromHosts(String... items)`
`A`	`removeFromMethods(String... items)`
`A`	`removeFromNotHosts(String... items)`
`A`	`removeFromNotMethods(String... items)`
`A`	`removeFromNotPaths(String... items)`
`A`	`removeFromNotPorts(String... items)`
`A`	`removeFromPaths(String... items)`
`A`	`removeFromPorts(String... items)`
`A`	`setToHosts(Integer index, String item)`
`A`	`setToMethods(Integer index, String item)`
`A`	`setToNotHosts(Integer index, String item)`
`A`	`setToNotMethods(Integer index, String item)`
`A`	`setToNotPaths(Integer index, String item)`
`A`	`setToNotPorts(Integer index, String item)`
`A`	`setToPaths(Integer index, String item)`
`A`	`setToPorts(Integer index, String item)`
`A`	`withHosts(List<String> hosts)`
`A`	`withHosts(String... hosts)`
`A`	`withMethods(List<String> methods)`
`A`	`withMethods(String... methods)`
`A`	`withNotHosts(List<String> notHosts)`
`A`	`withNotHosts(String... notHosts)`
`A`	`withNotMethods(List<String> notMethods)`
`A`	`withNotMethods(String... notMethods)`
`A`	`withNotPaths(List<String> notPaths)`
`A`	`withNotPaths(String... notPaths)`
`A`	`withNotPorts(List<String> notPorts)`
`A`	`withNotPorts(String... notPorts)`
`A`	`withPaths(List<String> paths)`
`A`	`withPaths(String... paths)`
`A`	`withPorts(List<String> ports)`
`A`	`withPorts(String... ports)`

Method Detail

addToHosts

A addToHosts(Integer index,
             String item)

setToHosts

A setToHosts(Integer index,
             String item)

addToHosts
```
A addToHosts(String... items)
```

addAllToHosts

A addAllToHosts(Collection<String> items)

removeFromHosts
```
A removeFromHosts(String... items)
```

removeAllFromHosts

A removeAllFromHosts(Collection<String> items)

getHosts
```
List<String> getHosts()
```

getHost
```
String getHost(Integer index)
```

getFirstHost
```
String getFirstHost()
```

getLastHost
```
String getLastHost()
```

getMatchingHost

String getMatchingHost(Predicate<String> predicate)

hasMatchingHost

Boolean hasMatchingHost(Predicate<String> predicate)

withHosts
```
A withHosts(List<String> hosts)
```

withHosts
```
A withHosts(String... hosts)
```

hasHosts
```
Boolean hasHosts()
```

addNewHost
```
A addNewHost(String arg0)
```

addToMethods

A addToMethods(Integer index,
               String item)

setToMethods

A setToMethods(Integer index,
               String item)

addToMethods
```
A addToMethods(String... items)
```

addAllToMethods

A addAllToMethods(Collection<String> items)

removeFromMethods
```
A removeFromMethods(String... items)
```

removeAllFromMethods

A removeAllFromMethods(Collection<String> items)

getMethods
```
List<String> getMethods()
```

getMethod
```
String getMethod(Integer index)
```

getFirstMethod
```
String getFirstMethod()
```

getLastMethod
```
String getLastMethod()
```

getMatchingMethod

String getMatchingMethod(Predicate<String> predicate)

hasMatchingMethod

Boolean hasMatchingMethod(Predicate<String> predicate)

withMethods
```
A withMethods(List<String> methods)
```

withMethods
```
A withMethods(String... methods)
```

hasMethods
```
Boolean hasMethods()
```

addNewMethod
```
A addNewMethod(String arg0)
```

addToNotHosts

A addToNotHosts(Integer index,
                String item)

setToNotHosts

A setToNotHosts(Integer index,
                String item)

addToNotHosts
```
A addToNotHosts(String... items)
```

addAllToNotHosts

A addAllToNotHosts(Collection<String> items)

removeFromNotHosts
```
A removeFromNotHosts(String... items)
```

removeAllFromNotHosts

A removeAllFromNotHosts(Collection<String> items)

getNotHosts
```
List<String> getNotHosts()
```

getNotHost
```
String getNotHost(Integer index)
```

getFirstNotHost
```
String getFirstNotHost()
```

getLastNotHost
```
String getLastNotHost()
```

getMatchingNotHost

String getMatchingNotHost(Predicate<String> predicate)

hasMatchingNotHost

Boolean hasMatchingNotHost(Predicate<String> predicate)

withNotHosts
```
A withNotHosts(List<String> notHosts)
```

withNotHosts
```
A withNotHosts(String... notHosts)
```

hasNotHosts
```
Boolean hasNotHosts()
```

addNewNotHost
```
A addNewNotHost(String arg0)
```

addToNotMethods

A addToNotMethods(Integer index,
                  String item)

setToNotMethods

A setToNotMethods(Integer index,
                  String item)

addToNotMethods
```
A addToNotMethods(String... items)
```

addAllToNotMethods

A addAllToNotMethods(Collection<String> items)

removeFromNotMethods

A removeFromNotMethods(String... items)

removeAllFromNotMethods

A removeAllFromNotMethods(Collection<String> items)

getNotMethods
```
List<String> getNotMethods()
```

getNotMethod
```
String getNotMethod(Integer index)
```

getFirstNotMethod
```
String getFirstNotMethod()
```

getLastNotMethod
```
String getLastNotMethod()
```

getMatchingNotMethod

String getMatchingNotMethod(Predicate<String> predicate)

hasMatchingNotMethod

Boolean hasMatchingNotMethod(Predicate<String> predicate)

withNotMethods

A withNotMethods(List<String> notMethods)

withNotMethods

A withNotMethods(String... notMethods)

hasNotMethods
```
Boolean hasNotMethods()
```

addNewNotMethod
```
A addNewNotMethod(String arg0)
```

addToNotPaths

A addToNotPaths(Integer index,
                String item)

setToNotPaths

A setToNotPaths(Integer index,
                String item)

addToNotPaths
```
A addToNotPaths(String... items)
```

addAllToNotPaths

A addAllToNotPaths(Collection<String> items)

removeFromNotPaths
```
A removeFromNotPaths(String... items)
```

removeAllFromNotPaths

A removeAllFromNotPaths(Collection<String> items)

getNotPaths
```
List<String> getNotPaths()
```

getNotPath
```
String getNotPath(Integer index)
```

getFirstNotPath
```
String getFirstNotPath()
```

getLastNotPath
```
String getLastNotPath()
```

getMatchingNotPath

String getMatchingNotPath(Predicate<String> predicate)

hasMatchingNotPath

Boolean hasMatchingNotPath(Predicate<String> predicate)

withNotPaths
```
A withNotPaths(List<String> notPaths)
```

withNotPaths
```
A withNotPaths(String... notPaths)
```

hasNotPaths
```
Boolean hasNotPaths()
```

addNewNotPath
```
A addNewNotPath(String arg0)
```

addToNotPorts

A addToNotPorts(Integer index,
                String item)

setToNotPorts

A setToNotPorts(Integer index,
                String item)

addToNotPorts
```
A addToNotPorts(String... items)
```

addAllToNotPorts

A addAllToNotPorts(Collection<String> items)

removeFromNotPorts
```
A removeFromNotPorts(String... items)
```

removeAllFromNotPorts

A removeAllFromNotPorts(Collection<String> items)

getNotPorts
```
List<String> getNotPorts()
```

getNotPort
```
String getNotPort(Integer index)
```

getFirstNotPort
```
String getFirstNotPort()
```

getLastNotPort
```
String getLastNotPort()
```

getMatchingNotPort

String getMatchingNotPort(Predicate<String> predicate)

hasMatchingNotPort

Boolean hasMatchingNotPort(Predicate<String> predicate)

withNotPorts
```
A withNotPorts(List<String> notPorts)
```

withNotPorts
```
A withNotPorts(String... notPorts)
```

hasNotPorts
```
Boolean hasNotPorts()
```

addNewNotPort
```
A addNewNotPort(String arg0)
```

addToPaths

A addToPaths(Integer index,
             String item)

setToPaths

A setToPaths(Integer index,
             String item)

addToPaths
```
A addToPaths(String... items)
```

addAllToPaths

A addAllToPaths(Collection<String> items)

removeFromPaths
```
A removeFromPaths(String... items)
```

removeAllFromPaths

A removeAllFromPaths(Collection<String> items)

getPaths
```
List<String> getPaths()
```

getPath
```
String getPath(Integer index)
```

getFirstPath
```
String getFirstPath()
```

getLastPath
```
String getLastPath()
```

getMatchingPath

String getMatchingPath(Predicate<String> predicate)

hasMatchingPath

Boolean hasMatchingPath(Predicate<String> predicate)

withPaths
```
A withPaths(List<String> paths)
```

withPaths
```
A withPaths(String... paths)
```

hasPaths
```
Boolean hasPaths()
```

addNewPath
```
A addNewPath(String arg0)
```

addToPorts

A addToPorts(Integer index,
             String item)

setToPorts

A setToPorts(Integer index,
             String item)

addToPorts
```
A addToPorts(String... items)
```

addAllToPorts

A addAllToPorts(Collection<String> items)

removeFromPorts
```
A removeFromPorts(String... items)
```

removeAllFromPorts

A removeAllFromPorts(Collection<String> items)

getPorts
```
List<String> getPorts()
```

getPort
```
String getPort(Integer index)
```

getFirstPort
```
String getFirstPort()
```

getLastPort
```
String getLastPort()
```

getMatchingPort

String getMatchingPort(Predicate<String> predicate)

hasMatchingPort

Boolean hasMatchingPort(Predicate<String> predicate)

withPorts
```
A withPorts(List<String> ports)
```

withPorts
```
A withPorts(String... ports)
```

hasPorts
```
Boolean hasPorts()
```

addNewPort
```
A addNewPort(String arg0)
```

Interface OperationFluent<A extends OperationFluent<A>>

Method Summary

Method Detail

addToHosts

setToHosts

addToHosts

addAllToHosts

removeFromHosts

removeAllFromHosts

getHosts

getHost

getFirstHost

getLastHost

getMatchingHost

hasMatchingHost

withHosts

withHosts

hasHosts

addNewHost

addToMethods

setToMethods

addToMethods

addAllToMethods

removeFromMethods

removeAllFromMethods

getMethods

getMethod

getFirstMethod

getLastMethod

getMatchingMethod

hasMatchingMethod

withMethods

withMethods

hasMethods

addNewMethod

addToNotHosts

setToNotHosts

addToNotHosts

addAllToNotHosts

removeFromNotHosts

removeAllFromNotHosts

getNotHosts

getNotHost

getFirstNotHost

getLastNotHost

getMatchingNotHost

hasMatchingNotHost

withNotHosts

withNotHosts

hasNotHosts

addNewNotHost

addToNotMethods

setToNotMethods

addToNotMethods

addAllToNotMethods

removeFromNotMethods

removeAllFromNotMethods

getNotMethods

getNotMethod

getFirstNotMethod

getLastNotMethod

getMatchingNotMethod

hasMatchingNotMethod

withNotMethods

withNotMethods

hasNotMethods

addNewNotMethod

addToNotPaths

setToNotPaths

addToNotPaths

addAllToNotPaths

removeFromNotPaths

removeAllFromNotPaths

getNotPaths

getNotPath

getFirstNotPath

getLastNotPath

getMatchingNotPath

hasMatchingNotPath

withNotPaths