java.lang.Object
- io.fabric8.kubernetes.api.builder.BaseFluent<A>
- - io.fabric8.kubernetes.api.model.NodeStatusFluent<A>

Direct Known Subclasses:: NodeFluent.StatusNested, NodeStatusBuilder

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

Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`NodeStatusFluent.AddressesNested<N>`
`class`	`NodeStatusFluent.ConditionsNested<N>`
`class`	`NodeStatusFluent.ConfigNested<N>`
`class`	`NodeStatusFluent.DaemonEndpointsNested<N>`
`class`	`NodeStatusFluent.ImagesNested<N>`
`class`	`NodeStatusFluent.NodeInfoNested<N>`
`class`	`NodeStatusFluent.RuntimeHandlersNested<N>`
`class`	`NodeStatusFluent.VolumesAttachedNested<N>`

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

Constructor Summary

Constructors
Constructor Description

NodeStatusFluent()

NodeStatusFluent(NodeStatus instance)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`A`	`addAllToAddresses(Collection<NodeAddress> items)`
`A`	`addAllToConditions(Collection<NodeCondition> items)`
`A`	`addAllToImages(Collection<ContainerImage> items)`
`A`	`addAllToRuntimeHandlers(Collection<NodeRuntimeHandler> items)`
`A`	`addAllToVolumesAttached(Collection<AttachedVolume> items)`
`A`	`addAllToVolumesInUse(Collection<String> items)`
`NodeStatusFluent.AddressesNested<A>`	`addNewAddress()`
`A`	`addNewAddress(String address, String type)`
`NodeStatusFluent.AddressesNested<A>`	`addNewAddressLike(NodeAddress item)`
`NodeStatusFluent.ConditionsNested<A>`	`addNewCondition()`
`NodeStatusFluent.ConditionsNested<A>`	`addNewConditionLike(NodeCondition item)`
`NodeStatusFluent.ImagesNested<A>`	`addNewImage()`
`NodeStatusFluent.ImagesNested<A>`	`addNewImageLike(ContainerImage item)`
`NodeStatusFluent.RuntimeHandlersNested<A>`	`addNewRuntimeHandler()`
`NodeStatusFluent.RuntimeHandlersNested<A>`	`addNewRuntimeHandlerLike(NodeRuntimeHandler item)`
`NodeStatusFluent.VolumesAttachedNested<A>`	`addNewVolumesAttached()`
`A`	`addNewVolumesAttached(String devicePath, String name)`
`NodeStatusFluent.VolumesAttachedNested<A>`	`addNewVolumesAttachedLike(AttachedVolume item)`
`A`	`addToAdditionalProperties(String key, Object value)`
`A`	`addToAdditionalProperties(Map<String,Object> map)`
`A`	`addToAddresses(int index, NodeAddress item)`
`A`	`addToAddresses(NodeAddress... items)`
`A`	`addToAllocatable(String key, Quantity value)`
`A`	`addToAllocatable(Map<String,Quantity> map)`
`A`	`addToCapacity(String key, Quantity value)`
`A`	`addToCapacity(Map<String,Quantity> map)`
`A`	`addToConditions(int index, NodeCondition item)`
`A`	`addToConditions(NodeCondition... items)`
`A`	`addToImages(int index, ContainerImage item)`
`A`	`addToImages(ContainerImage... items)`
`A`	`addToRuntimeHandlers(int index, NodeRuntimeHandler item)`
`A`	`addToRuntimeHandlers(NodeRuntimeHandler... items)`
`A`	`addToVolumesAttached(int index, AttachedVolume item)`
`A`	`addToVolumesAttached(AttachedVolume... items)`
`A`	`addToVolumesInUse(int index, String item)`
`A`	`addToVolumesInUse(String... items)`
`NodeAddress`	`buildAddress(int index)`
`List<NodeAddress>`	`buildAddresses()`
`NodeCondition`	`buildCondition(int index)`
`List<NodeCondition>`	`buildConditions()`
`NodeConfigStatus`	`buildConfig()`
`NodeDaemonEndpoints`	`buildDaemonEndpoints()`
`NodeAddress`	`buildFirstAddress()`
`NodeCondition`	`buildFirstCondition()`
`ContainerImage`	`buildFirstImage()`
`NodeRuntimeHandler`	`buildFirstRuntimeHandler()`
`AttachedVolume`	`buildFirstVolumesAttached()`
`ContainerImage`	`buildImage(int index)`
`List<ContainerImage>`	`buildImages()`
`NodeAddress`	`buildLastAddress()`
`NodeCondition`	`buildLastCondition()`
`ContainerImage`	`buildLastImage()`
`NodeRuntimeHandler`	`buildLastRuntimeHandler()`
`AttachedVolume`	`buildLastVolumesAttached()`
`NodeAddress`	`buildMatchingAddress(Predicate<NodeAddressBuilder> predicate)`
`NodeCondition`	`buildMatchingCondition(Predicate<NodeConditionBuilder> predicate)`
`ContainerImage`	`buildMatchingImage(Predicate<ContainerImageBuilder> predicate)`
`NodeRuntimeHandler`	`buildMatchingRuntimeHandler(Predicate<NodeRuntimeHandlerBuilder> predicate)`
`AttachedVolume`	`buildMatchingVolumesAttached(Predicate<AttachedVolumeBuilder> predicate)`
`NodeSystemInfo`	`buildNodeInfo()`
`NodeRuntimeHandler`	`buildRuntimeHandler(int index)`
`List<NodeRuntimeHandler>`	`buildRuntimeHandlers()`
`List<AttachedVolume>`	`buildVolumesAttached()`
`AttachedVolume`	`buildVolumesAttached(int index)`
`protected void`	`copyInstance(NodeStatus instance)`
`NodeStatusFluent.AddressesNested<A>`	`editAddress(int index)`
`NodeStatusFluent.ConditionsNested<A>`	`editCondition(int index)`
`NodeStatusFluent.ConfigNested<A>`	`editConfig()`
`NodeStatusFluent.DaemonEndpointsNested<A>`	`editDaemonEndpoints()`
`NodeStatusFluent.AddressesNested<A>`	`editFirstAddress()`
`NodeStatusFluent.ConditionsNested<A>`	`editFirstCondition()`
`NodeStatusFluent.ImagesNested<A>`	`editFirstImage()`
`NodeStatusFluent.RuntimeHandlersNested<A>`	`editFirstRuntimeHandler()`
`NodeStatusFluent.VolumesAttachedNested<A>`	`editFirstVolumesAttached()`
`NodeStatusFluent.ImagesNested<A>`	`editImage(int index)`
`NodeStatusFluent.AddressesNested<A>`	`editLastAddress()`
`NodeStatusFluent.ConditionsNested<A>`	`editLastCondition()`
`NodeStatusFluent.ImagesNested<A>`	`editLastImage()`
`NodeStatusFluent.RuntimeHandlersNested<A>`	`editLastRuntimeHandler()`
`NodeStatusFluent.VolumesAttachedNested<A>`	`editLastVolumesAttached()`
`NodeStatusFluent.AddressesNested<A>`	`editMatchingAddress(Predicate<NodeAddressBuilder> predicate)`
`NodeStatusFluent.ConditionsNested<A>`	`editMatchingCondition(Predicate<NodeConditionBuilder> predicate)`
`NodeStatusFluent.ImagesNested<A>`	`editMatchingImage(Predicate<ContainerImageBuilder> predicate)`
`NodeStatusFluent.RuntimeHandlersNested<A>`	`editMatchingRuntimeHandler(Predicate<NodeRuntimeHandlerBuilder> predicate)`
`NodeStatusFluent.VolumesAttachedNested<A>`	`editMatchingVolumesAttached(Predicate<AttachedVolumeBuilder> predicate)`
`NodeStatusFluent.NodeInfoNested<A>`	`editNodeInfo()`
`NodeStatusFluent.ConfigNested<A>`	`editOrNewConfig()`
`NodeStatusFluent.ConfigNested<A>`	`editOrNewConfigLike(NodeConfigStatus item)`
`NodeStatusFluent.DaemonEndpointsNested<A>`	`editOrNewDaemonEndpoints()`
`NodeStatusFluent.DaemonEndpointsNested<A>`	`editOrNewDaemonEndpointsLike(NodeDaemonEndpoints item)`
`NodeStatusFluent.NodeInfoNested<A>`	`editOrNewNodeInfo()`
`NodeStatusFluent.NodeInfoNested<A>`	`editOrNewNodeInfoLike(NodeSystemInfo item)`
`NodeStatusFluent.RuntimeHandlersNested<A>`	`editRuntimeHandler(int index)`
`NodeStatusFluent.VolumesAttachedNested<A>`	`editVolumesAttached(int index)`
`boolean`	`equals(Object o)`
`Map<String,Object>`	`getAdditionalProperties()`
`Map<String,Quantity>`	`getAllocatable()`
`Map<String,Quantity>`	`getCapacity()`
`String`	`getFirstVolumesInUse()`
`String`	`getLastVolumesInUse()`
`String`	`getMatchingVolumesInUse(Predicate<String> predicate)`
`String`	`getPhase()`
`List<String>`	`getVolumesInUse()`
`String`	`getVolumesInUse(int index)`
`boolean`	`hasAdditionalProperties()`
`boolean`	`hasAddresses()`
`boolean`	`hasAllocatable()`
`boolean`	`hasCapacity()`
`boolean`	`hasConditions()`
`boolean`	`hasConfig()`
`boolean`	`hasDaemonEndpoints()`
`int`	`hashCode()`
`boolean`	`hasImages()`
`boolean`	`hasMatchingAddress(Predicate<NodeAddressBuilder> predicate)`
`boolean`	`hasMatchingCondition(Predicate<NodeConditionBuilder> predicate)`
`boolean`	`hasMatchingImage(Predicate<ContainerImageBuilder> predicate)`
`boolean`	`hasMatchingRuntimeHandler(Predicate<NodeRuntimeHandlerBuilder> predicate)`
`boolean`	`hasMatchingVolumesAttached(Predicate<AttachedVolumeBuilder> predicate)`
`boolean`	`hasMatchingVolumesInUse(Predicate<String> predicate)`
`boolean`	`hasNodeInfo()`
`boolean`	`hasPhase()`
`boolean`	`hasRuntimeHandlers()`
`boolean`	`hasVolumesAttached()`
`boolean`	`hasVolumesInUse()`
`A`	`removeAllFromAddresses(Collection<NodeAddress> items)`
`A`	`removeAllFromConditions(Collection<NodeCondition> items)`
`A`	`removeAllFromImages(Collection<ContainerImage> items)`
`A`	`removeAllFromRuntimeHandlers(Collection<NodeRuntimeHandler> items)`
`A`	`removeAllFromVolumesAttached(Collection<AttachedVolume> items)`
`A`	`removeAllFromVolumesInUse(Collection<String> items)`
`A`	`removeFromAdditionalProperties(String key)`
`A`	`removeFromAdditionalProperties(Map<String,Object> map)`
`A`	`removeFromAddresses(NodeAddress... items)`
`A`	`removeFromAllocatable(String key)`
`A`	`removeFromAllocatable(Map<String,Quantity> map)`
`A`	`removeFromCapacity(String key)`
`A`	`removeFromCapacity(Map<String,Quantity> map)`
`A`	`removeFromConditions(NodeCondition... items)`
`A`	`removeFromImages(ContainerImage... items)`
`A`	`removeFromRuntimeHandlers(NodeRuntimeHandler... items)`
`A`	`removeFromVolumesAttached(AttachedVolume... items)`
`A`	`removeFromVolumesInUse(String... items)`
`A`	`removeMatchingFromAddresses(Predicate<NodeAddressBuilder> predicate)`
`A`	`removeMatchingFromConditions(Predicate<NodeConditionBuilder> predicate)`
`A`	`removeMatchingFromImages(Predicate<ContainerImageBuilder> predicate)`
`A`	`removeMatchingFromRuntimeHandlers(Predicate<NodeRuntimeHandlerBuilder> predicate)`
`A`	`removeMatchingFromVolumesAttached(Predicate<AttachedVolumeBuilder> predicate)`
`NodeStatusFluent.AddressesNested<A>`	`setNewAddressLike(int index, NodeAddress item)`
`NodeStatusFluent.ConditionsNested<A>`	`setNewConditionLike(int index, NodeCondition item)`
`NodeStatusFluent.ImagesNested<A>`	`setNewImageLike(int index, ContainerImage item)`
`NodeStatusFluent.RuntimeHandlersNested<A>`	`setNewRuntimeHandlerLike(int index, NodeRuntimeHandler item)`
`NodeStatusFluent.VolumesAttachedNested<A>`	`setNewVolumesAttachedLike(int index, AttachedVolume item)`
`A`	`setToAddresses(int index, NodeAddress item)`
`A`	`setToConditions(int index, NodeCondition item)`
`A`	`setToImages(int index, ContainerImage item)`
`A`	`setToRuntimeHandlers(int index, NodeRuntimeHandler item)`
`A`	`setToVolumesAttached(int index, AttachedVolume item)`
`A`	`setToVolumesInUse(int index, String item)`
`String`	`toString()`
`<K,V> A`	`withAdditionalProperties(Map<String,Object> additionalProperties)`
`A`	`withAddresses(NodeAddress... addresses)`
`A`	`withAddresses(List<NodeAddress> addresses)`
`<K,V> A`	`withAllocatable(Map<String,Quantity> allocatable)`
`<K,V> A`	`withCapacity(Map<String,Quantity> capacity)`
`A`	`withConditions(NodeCondition... conditions)`
`A`	`withConditions(List<NodeCondition> conditions)`
`A`	`withConfig(NodeConfigStatus config)`
`A`	`withDaemonEndpoints(NodeDaemonEndpoints daemonEndpoints)`
`A`	`withImages(ContainerImage... images)`
`A`	`withImages(List<ContainerImage> images)`
`NodeStatusFluent.ConfigNested<A>`	`withNewConfig()`
`NodeStatusFluent.ConfigNested<A>`	`withNewConfigLike(NodeConfigStatus item)`
`NodeStatusFluent.DaemonEndpointsNested<A>`	`withNewDaemonEndpoints()`
`NodeStatusFluent.DaemonEndpointsNested<A>`	`withNewDaemonEndpointsLike(NodeDaemonEndpoints item)`
`NodeStatusFluent.NodeInfoNested<A>`	`withNewNodeInfo()`
`NodeStatusFluent.NodeInfoNested<A>`	`withNewNodeInfoLike(NodeSystemInfo item)`
`A`	`withNodeInfo(NodeSystemInfo nodeInfo)`
`A`	`withPhase(String phase)`
`A`	`withRuntimeHandlers(NodeRuntimeHandler... runtimeHandlers)`
`A`	`withRuntimeHandlers(List<NodeRuntimeHandler> runtimeHandlers)`
`A`	`withVolumesAttached(AttachedVolume... volumesAttached)`
`A`	`withVolumesAttached(List<AttachedVolume> volumesAttached)`
`A`	`withVolumesInUse(String... volumesInUse)`
`A`	`withVolumesInUse(List<String> volumesInUse)`

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

NodeStatusFluent
```
public NodeStatusFluent()
```

NodeStatusFluent

public NodeStatusFluent(NodeStatus instance)

Method Detail

copyInstance

protected void copyInstance(NodeStatus instance)

addToAddresses

public A addToAddresses(int index,
                        NodeAddress item)

setToAddresses

public A setToAddresses(int index,
                        NodeAddress item)

addToAddresses

public A addToAddresses(NodeAddress... items)

addAllToAddresses

public A addAllToAddresses(Collection<NodeAddress> items)

removeFromAddresses

public A removeFromAddresses(NodeAddress... items)

removeAllFromAddresses

public A removeAllFromAddresses(Collection<NodeAddress> items)

removeMatchingFromAddresses

public A removeMatchingFromAddresses(Predicate<NodeAddressBuilder> predicate)

buildAddresses

public List<NodeAddress> buildAddresses()

buildAddress

public NodeAddress buildAddress(int index)

buildFirstAddress

public NodeAddress buildFirstAddress()

buildLastAddress
```
public NodeAddress buildLastAddress()
```

buildMatchingAddress

public NodeAddress buildMatchingAddress(Predicate<NodeAddressBuilder> predicate)

hasMatchingAddress

public boolean hasMatchingAddress(Predicate<NodeAddressBuilder> predicate)

withAddresses

public A withAddresses(List<NodeAddress> addresses)

withAddresses

public A withAddresses(NodeAddress... addresses)

hasAddresses
```
public boolean hasAddresses()
```

addNewAddress

public A addNewAddress(String address,
                       String type)

addNewAddress

public NodeStatusFluent.AddressesNested<A> addNewAddress()

addNewAddressLike

public NodeStatusFluent.AddressesNested<A> addNewAddressLike(NodeAddress item)

setNewAddressLike

public NodeStatusFluent.AddressesNested<A> setNewAddressLike(int index,
                                                             NodeAddress item)

editAddress

public NodeStatusFluent.AddressesNested<A> editAddress(int index)

editFirstAddress

public NodeStatusFluent.AddressesNested<A> editFirstAddress()

editLastAddress

public NodeStatusFluent.AddressesNested<A> editLastAddress()

editMatchingAddress

public NodeStatusFluent.AddressesNested<A> editMatchingAddress(Predicate<NodeAddressBuilder> predicate)

addToAllocatable

public A addToAllocatable(String key,
                          Quantity value)

addToAllocatable

public A addToAllocatable(Map<String,Quantity> map)

removeFromAllocatable

public A removeFromAllocatable(String key)

removeFromAllocatable

public A removeFromAllocatable(Map<String,Quantity> map)

getAllocatable

public Map<String,Quantity> getAllocatable()

withAllocatable

public <K,V> A withAllocatable(Map<String,Quantity> allocatable)

hasAllocatable
```
public boolean hasAllocatable()
```

addToCapacity

public A addToCapacity(String key,
                       Quantity value)

addToCapacity

public A addToCapacity(Map<String,Quantity> map)

removeFromCapacity

public A removeFromCapacity(String key)

removeFromCapacity

public A removeFromCapacity(Map<String,Quantity> map)

getCapacity

public Map<String,Quantity> getCapacity()

withCapacity

public <K,V> A withCapacity(Map<String,Quantity> capacity)

hasCapacity
```
public boolean hasCapacity()
```

addToConditions

public A addToConditions(int index,
                         NodeCondition item)

setToConditions

public A setToConditions(int index,
                         NodeCondition item)

addToConditions

public A addToConditions(NodeCondition... items)

addAllToConditions

public A addAllToConditions(Collection<NodeCondition> items)

removeFromConditions

public A removeFromConditions(NodeCondition... items)

removeAllFromConditions

public A removeAllFromConditions(Collection<NodeCondition> items)

removeMatchingFromConditions

public A removeMatchingFromConditions(Predicate<NodeConditionBuilder> predicate)

buildConditions

public List<NodeCondition> buildConditions()

buildCondition

public NodeCondition buildCondition(int index)

buildFirstCondition

public NodeCondition buildFirstCondition()

buildLastCondition

public NodeCondition buildLastCondition()

buildMatchingCondition

public NodeCondition buildMatchingCondition(Predicate<NodeConditionBuilder> predicate)

hasMatchingCondition

public boolean hasMatchingCondition(Predicate<NodeConditionBuilder> predicate)

withConditions

public A withConditions(List<NodeCondition> conditions)

withConditions

public A withConditions(NodeCondition... conditions)

hasConditions
```
public boolean hasConditions()
```

addNewCondition

public NodeStatusFluent.ConditionsNested<A> addNewCondition()

addNewConditionLike

public NodeStatusFluent.ConditionsNested<A> addNewConditionLike(NodeCondition item)

setNewConditionLike

public NodeStatusFluent.ConditionsNested<A> setNewConditionLike(int index,
                                                                NodeCondition item)

editCondition

public NodeStatusFluent.ConditionsNested<A> editCondition(int index)

editFirstCondition

public NodeStatusFluent.ConditionsNested<A> editFirstCondition()

editLastCondition

public NodeStatusFluent.ConditionsNested<A> editLastCondition()

editMatchingCondition

public NodeStatusFluent.ConditionsNested<A> editMatchingCondition(Predicate<NodeConditionBuilder> predicate)

buildConfig
```
public NodeConfigStatus buildConfig()
```

withConfig

public A withConfig(NodeConfigStatus config)

hasConfig
```
public boolean hasConfig()
```

withNewConfig

public NodeStatusFluent.ConfigNested<A> withNewConfig()

withNewConfigLike

public NodeStatusFluent.ConfigNested<A> withNewConfigLike(NodeConfigStatus item)

editConfig

public NodeStatusFluent.ConfigNested<A> editConfig()

editOrNewConfig

public NodeStatusFluent.ConfigNested<A> editOrNewConfig()

editOrNewConfigLike

public NodeStatusFluent.ConfigNested<A> editOrNewConfigLike(NodeConfigStatus item)

buildDaemonEndpoints

public NodeDaemonEndpoints buildDaemonEndpoints()

withDaemonEndpoints

public A withDaemonEndpoints(NodeDaemonEndpoints daemonEndpoints)

hasDaemonEndpoints
```
public boolean hasDaemonEndpoints()
```

withNewDaemonEndpoints

public NodeStatusFluent.DaemonEndpointsNested<A> withNewDaemonEndpoints()

withNewDaemonEndpointsLike

public NodeStatusFluent.DaemonEndpointsNested<A> withNewDaemonEndpointsLike(NodeDaemonEndpoints item)

editDaemonEndpoints

public NodeStatusFluent.DaemonEndpointsNested<A> editDaemonEndpoints()

editOrNewDaemonEndpoints

public NodeStatusFluent.DaemonEndpointsNested<A> editOrNewDaemonEndpoints()

editOrNewDaemonEndpointsLike

public NodeStatusFluent.DaemonEndpointsNested<A> editOrNewDaemonEndpointsLike(NodeDaemonEndpoints item)

addToImages

public A addToImages(int index,
                     ContainerImage item)

setToImages

public A setToImages(int index,
                     ContainerImage item)

addToImages

public A addToImages(ContainerImage... items)

addAllToImages

public A addAllToImages(Collection<ContainerImage> items)

removeFromImages

public A removeFromImages(ContainerImage... items)

removeAllFromImages

public A removeAllFromImages(Collection<ContainerImage> items)

removeMatchingFromImages

public A removeMatchingFromImages(Predicate<ContainerImageBuilder> predicate)

buildImages

public List<ContainerImage> buildImages()

buildImage

public ContainerImage buildImage(int index)

buildFirstImage

public ContainerImage buildFirstImage()

buildLastImage

public ContainerImage buildLastImage()

buildMatchingImage

public ContainerImage buildMatchingImage(Predicate<ContainerImageBuilder> predicate)

hasMatchingImage

public boolean hasMatchingImage(Predicate<ContainerImageBuilder> predicate)

withImages

public A withImages(List<ContainerImage> images)

withImages

public A withImages(ContainerImage... images)

hasImages
```
public boolean hasImages()
```

addNewImage

public NodeStatusFluent.ImagesNested<A> addNewImage()

addNewImageLike

public NodeStatusFluent.ImagesNested<A> addNewImageLike(ContainerImage item)

setNewImageLike

public NodeStatusFluent.ImagesNested<A> setNewImageLike(int index,
                                                        ContainerImage item)

editImage

public NodeStatusFluent.ImagesNested<A> editImage(int index)

editFirstImage

public NodeStatusFluent.ImagesNested<A> editFirstImage()

editLastImage

public NodeStatusFluent.ImagesNested<A> editLastImage()

editMatchingImage

public NodeStatusFluent.ImagesNested<A> editMatchingImage(Predicate<ContainerImageBuilder> predicate)

buildNodeInfo
```
public NodeSystemInfo buildNodeInfo()
```

withNodeInfo

public A withNodeInfo(NodeSystemInfo nodeInfo)

hasNodeInfo
```
public boolean hasNodeInfo()
```

withNewNodeInfo

public NodeStatusFluent.NodeInfoNested<A> withNewNodeInfo()

withNewNodeInfoLike

public NodeStatusFluent.NodeInfoNested<A> withNewNodeInfoLike(NodeSystemInfo item)

editNodeInfo

public NodeStatusFluent.NodeInfoNested<A> editNodeInfo()

editOrNewNodeInfo

public NodeStatusFluent.NodeInfoNested<A> editOrNewNodeInfo()

editOrNewNodeInfoLike

public NodeStatusFluent.NodeInfoNested<A> editOrNewNodeInfoLike(NodeSystemInfo item)

getPhase
```
public String getPhase()
```

withPhase
```
public A withPhase(String phase)
```

hasPhase
```
public boolean hasPhase()
```

addToRuntimeHandlers

public A addToRuntimeHandlers(int index,
                              NodeRuntimeHandler item)

setToRuntimeHandlers

public A setToRuntimeHandlers(int index,
                              NodeRuntimeHandler item)

addToRuntimeHandlers

public A addToRuntimeHandlers(NodeRuntimeHandler... items)

addAllToRuntimeHandlers

public A addAllToRuntimeHandlers(Collection<NodeRuntimeHandler> items)

removeFromRuntimeHandlers

public A removeFromRuntimeHandlers(NodeRuntimeHandler... items)

removeAllFromRuntimeHandlers

public A removeAllFromRuntimeHandlers(Collection<NodeRuntimeHandler> items)

removeMatchingFromRuntimeHandlers

public A removeMatchingFromRuntimeHandlers(Predicate<NodeRuntimeHandlerBuilder> predicate)

buildRuntimeHandlers

public List<NodeRuntimeHandler> buildRuntimeHandlers()

buildRuntimeHandler

public NodeRuntimeHandler buildRuntimeHandler(int index)

buildFirstRuntimeHandler

public NodeRuntimeHandler buildFirstRuntimeHandler()

buildLastRuntimeHandler

public NodeRuntimeHandler buildLastRuntimeHandler()

buildMatchingRuntimeHandler

public NodeRuntimeHandler buildMatchingRuntimeHandler(Predicate<NodeRuntimeHandlerBuilder> predicate)

hasMatchingRuntimeHandler

public boolean hasMatchingRuntimeHandler(Predicate<NodeRuntimeHandlerBuilder> predicate)

withRuntimeHandlers

public A withRuntimeHandlers(List<NodeRuntimeHandler> runtimeHandlers)

withRuntimeHandlers

public A withRuntimeHandlers(NodeRuntimeHandler... runtimeHandlers)

hasRuntimeHandlers
```
public boolean hasRuntimeHandlers()
```

addNewRuntimeHandler

public NodeStatusFluent.RuntimeHandlersNested<A> addNewRuntimeHandler()

addNewRuntimeHandlerLike

public NodeStatusFluent.RuntimeHandlersNested<A> addNewRuntimeHandlerLike(NodeRuntimeHandler item)

setNewRuntimeHandlerLike

public NodeStatusFluent.RuntimeHandlersNested<A> setNewRuntimeHandlerLike(int index,
                                                                          NodeRuntimeHandler item)

editRuntimeHandler

public NodeStatusFluent.RuntimeHandlersNested<A> editRuntimeHandler(int index)

editFirstRuntimeHandler

public NodeStatusFluent.RuntimeHandlersNested<A> editFirstRuntimeHandler()

editLastRuntimeHandler

public NodeStatusFluent.RuntimeHandlersNested<A> editLastRuntimeHandler()

editMatchingRuntimeHandler

public NodeStatusFluent.RuntimeHandlersNested<A> editMatchingRuntimeHandler(Predicate<NodeRuntimeHandlerBuilder> predicate)

addToVolumesAttached

public A addToVolumesAttached(int index,
                              AttachedVolume item)

setToVolumesAttached

public A setToVolumesAttached(int index,
                              AttachedVolume item)

addToVolumesAttached

public A addToVolumesAttached(AttachedVolume... items)

addAllToVolumesAttached

public A addAllToVolumesAttached(Collection<AttachedVolume> items)

removeFromVolumesAttached

public A removeFromVolumesAttached(AttachedVolume... items)

removeAllFromVolumesAttached

public A removeAllFromVolumesAttached(Collection<AttachedVolume> items)

removeMatchingFromVolumesAttached

public A removeMatchingFromVolumesAttached(Predicate<AttachedVolumeBuilder> predicate)

buildVolumesAttached

public List<AttachedVolume> buildVolumesAttached()

buildVolumesAttached

public AttachedVolume buildVolumesAttached(int index)

buildFirstVolumesAttached

public AttachedVolume buildFirstVolumesAttached()

buildLastVolumesAttached

public AttachedVolume buildLastVolumesAttached()

buildMatchingVolumesAttached

public AttachedVolume buildMatchingVolumesAttached(Predicate<AttachedVolumeBuilder> predicate)

hasMatchingVolumesAttached

public boolean hasMatchingVolumesAttached(Predicate<AttachedVolumeBuilder> predicate)

withVolumesAttached

public A withVolumesAttached(List<AttachedVolume> volumesAttached)

withVolumesAttached

public A withVolumesAttached(AttachedVolume... volumesAttached)

hasVolumesAttached
```
public boolean hasVolumesAttached()
```

addNewVolumesAttached

public A addNewVolumesAttached(String devicePath,
                               String name)

addNewVolumesAttached

public NodeStatusFluent.VolumesAttachedNested<A> addNewVolumesAttached()

addNewVolumesAttachedLike

public NodeStatusFluent.VolumesAttachedNested<A> addNewVolumesAttachedLike(AttachedVolume item)

setNewVolumesAttachedLike

public NodeStatusFluent.VolumesAttachedNested<A> setNewVolumesAttachedLike(int index,
                                                                           AttachedVolume item)

editVolumesAttached

public NodeStatusFluent.VolumesAttachedNested<A> editVolumesAttached(int index)

editFirstVolumesAttached

public NodeStatusFluent.VolumesAttachedNested<A> editFirstVolumesAttached()

editLastVolumesAttached

public NodeStatusFluent.VolumesAttachedNested<A> editLastVolumesAttached()

editMatchingVolumesAttached

public NodeStatusFluent.VolumesAttachedNested<A> editMatchingVolumesAttached(Predicate<AttachedVolumeBuilder> predicate)

addToVolumesInUse

public A addToVolumesInUse(int index,
                           String item)

setToVolumesInUse

public A setToVolumesInUse(int index,
                           String item)

addToVolumesInUse

public A addToVolumesInUse(String... items)

addAllToVolumesInUse

public A addAllToVolumesInUse(Collection<String> items)

removeFromVolumesInUse

public A removeFromVolumesInUse(String... items)

removeAllFromVolumesInUse

public A removeAllFromVolumesInUse(Collection<String> items)

getVolumesInUse
```
public List<String> getVolumesInUse()
```

getVolumesInUse

public String getVolumesInUse(int index)

getFirstVolumesInUse
```
public String getFirstVolumesInUse()
```

getLastVolumesInUse
```
public String getLastVolumesInUse()
```

getMatchingVolumesInUse

public String getMatchingVolumesInUse(Predicate<String> predicate)

hasMatchingVolumesInUse

public boolean hasMatchingVolumesInUse(Predicate<String> predicate)

withVolumesInUse

public A withVolumesInUse(List<String> volumesInUse)

withVolumesInUse

public A withVolumesInUse(String... volumesInUse)

hasVolumesInUse
```
public boolean hasVolumesInUse()
```

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 NodeStatusFluent<A>>

hashCode
```
public int hashCode()
```
Overrides:

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

toString
```
public String toString()
```
Overrides:

toString in class Object

Class NodeStatusFluent<A extends NodeStatusFluent<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

Constructor Detail

NodeStatusFluent

NodeStatusFluent

Method Detail

copyInstance

addToAddresses

setToAddresses

addToAddresses

addAllToAddresses

removeFromAddresses

removeAllFromAddresses

removeMatchingFromAddresses

buildAddresses

buildAddress

buildFirstAddress

buildLastAddress

buildMatchingAddress

hasMatchingAddress

withAddresses

withAddresses

hasAddresses

addNewAddress

addNewAddress

addNewAddressLike

setNewAddressLike

editAddress

editFirstAddress

editLastAddress

editMatchingAddress

addToAllocatable

addToAllocatable

removeFromAllocatable

removeFromAllocatable

getAllocatable

withAllocatable

hasAllocatable

addToCapacity

addToCapacity

removeFromCapacity

removeFromCapacity

getCapacity

withCapacity

hasCapacity

addToConditions

setToConditions

addToConditions

addAllToConditions

removeFromConditions

removeAllFromConditions

removeMatchingFromConditions

buildConditions

buildCondition

buildFirstCondition

buildLastCondition

buildMatchingCondition

hasMatchingCondition

withConditions

withConditions

hasConditions

addNewCondition

addNewConditionLike

setNewConditionLike

editCondition

editFirstCondition

editLastCondition

editMatchingCondition

buildConfig

withConfig

hasConfig

withNewConfig

withNewConfigLike

editConfig