PodStatusFluent (Fabric8 :: Kubernetes Model

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

All Implemented Interfaces:

Fluent<A>, Visitable<A>

Direct Known Subclasses:

NamedExtensionFluent.PodStatusExtensionNested, PodFluent.StatusNested, PodStatusBuilder, WatchEventFluent.PodStatusObjectNested
```
public class PodStatusFluent<A extends PodStatusFluent<A>>
extends BaseFluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`PodStatusFluent.ConditionsNested<N>`
`class`	`PodStatusFluent.ContainerStatusesNested<N>`
`class`	`PodStatusFluent.EphemeralContainerStatusesNested<N>`
`class`	`PodStatusFluent.InitContainerStatusesNested<N>`
`class`	`PodStatusFluent.PodIPsNested<N>`

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

Constructor Summary

Constructors
Constructor and Description

PodStatusFluent()

PodStatusFluent(PodStatus instance)

Constructors
Constructor and Description
`PodStatusFluent()`
`PodStatusFluent(PodStatus instance)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`A`	`addAllToConditions(Collection<PodCondition> items)`
`A`	`addAllToContainerStatuses(Collection<ContainerStatus> items)`
`A`	`addAllToEphemeralContainerStatuses(Collection<ContainerStatus> items)`
`A`	`addAllToInitContainerStatuses(Collection<ContainerStatus> items)`
`A`	`addAllToPodIPs(Collection<PodIP> items)`
`PodStatusFluent.ConditionsNested<A>`	`addNewCondition()`
`PodStatusFluent.ConditionsNested<A>`	`addNewConditionLike(PodCondition item)`
`PodStatusFluent.ContainerStatusesNested<A>`	`addNewContainerStatus()`
`PodStatusFluent.ContainerStatusesNested<A>`	`addNewContainerStatusLike(ContainerStatus item)`
`PodStatusFluent.EphemeralContainerStatusesNested<A>`	`addNewEphemeralContainerStatus()`
`PodStatusFluent.EphemeralContainerStatusesNested<A>`	`addNewEphemeralContainerStatusLike(ContainerStatus item)`
`PodStatusFluent.InitContainerStatusesNested<A>`	`addNewInitContainerStatus()`
`PodStatusFluent.InitContainerStatusesNested<A>`	`addNewInitContainerStatusLike(ContainerStatus item)`
`PodStatusFluent.PodIPsNested<A>`	`addNewPodIP()`
`A`	`addNewPodIP(String ip)`
`PodStatusFluent.PodIPsNested<A>`	`addNewPodIPLike(PodIP item)`
`A`	`addToAdditionalProperties(Map<String,Object> map)`
`A`	`addToAdditionalProperties(String key, Object value)`
`A`	`addToConditions(int index, PodCondition item)`
`A`	`addToConditions(PodCondition... items)`
`A`	`addToContainerStatuses(ContainerStatus... items)`
`A`	`addToContainerStatuses(int index, ContainerStatus item)`
`A`	`addToEphemeralContainerStatuses(ContainerStatus... items)`
`A`	`addToEphemeralContainerStatuses(int index, ContainerStatus item)`
`A`	`addToInitContainerStatuses(ContainerStatus... items)`
`A`	`addToInitContainerStatuses(int index, ContainerStatus item)`
`A`	`addToPodIPs(int index, PodIP item)`
`A`	`addToPodIPs(PodIP... items)`
`PodCondition`	`buildCondition(int index)`
`List<PodCondition>`	`buildConditions()`
`ContainerStatus`	`buildContainerStatus(int index)`
`List<ContainerStatus>`	`buildContainerStatuses()`
`ContainerStatus`	`buildEphemeralContainerStatus(int index)`
`List<ContainerStatus>`	`buildEphemeralContainerStatuses()`
`PodCondition`	`buildFirstCondition()`
`ContainerStatus`	`buildFirstContainerStatus()`
`ContainerStatus`	`buildFirstEphemeralContainerStatus()`
`ContainerStatus`	`buildFirstInitContainerStatus()`
`PodIP`	`buildFirstPodIP()`
`ContainerStatus`	`buildInitContainerStatus(int index)`
`List<ContainerStatus>`	`buildInitContainerStatuses()`
`PodCondition`	`buildLastCondition()`
`ContainerStatus`	`buildLastContainerStatus()`
`ContainerStatus`	`buildLastEphemeralContainerStatus()`
`ContainerStatus`	`buildLastInitContainerStatus()`
`PodIP`	`buildLastPodIP()`
`PodCondition`	`buildMatchingCondition(Predicate<PodConditionBuilder> predicate)`
`ContainerStatus`	`buildMatchingContainerStatus(Predicate<ContainerStatusBuilder> predicate)`
`ContainerStatus`	`buildMatchingEphemeralContainerStatus(Predicate<ContainerStatusBuilder> predicate)`
`ContainerStatus`	`buildMatchingInitContainerStatus(Predicate<ContainerStatusBuilder> predicate)`
`PodIP`	`buildMatchingPodIP(Predicate<PodIPBuilder> predicate)`
`PodIP`	`buildPodIP(int index)`
`List<PodIP>`	`buildPodIPs()`
`PodStatusFluent.ConditionsNested<A>`	`editCondition(int index)`
`PodStatusFluent.ContainerStatusesNested<A>`	`editContainerStatus(int index)`
`PodStatusFluent.EphemeralContainerStatusesNested<A>`	`editEphemeralContainerStatus(int index)`
`PodStatusFluent.ConditionsNested<A>`	`editFirstCondition()`
`PodStatusFluent.ContainerStatusesNested<A>`	`editFirstContainerStatus()`
`PodStatusFluent.EphemeralContainerStatusesNested<A>`	`editFirstEphemeralContainerStatus()`
`PodStatusFluent.InitContainerStatusesNested<A>`	`editFirstInitContainerStatus()`
`PodStatusFluent.PodIPsNested<A>`	`editFirstPodIP()`
`PodStatusFluent.InitContainerStatusesNested<A>`	`editInitContainerStatus(int index)`
`PodStatusFluent.ConditionsNested<A>`	`editLastCondition()`
`PodStatusFluent.ContainerStatusesNested<A>`	`editLastContainerStatus()`
`PodStatusFluent.EphemeralContainerStatusesNested<A>`	`editLastEphemeralContainerStatus()`
`PodStatusFluent.InitContainerStatusesNested<A>`	`editLastInitContainerStatus()`
`PodStatusFluent.PodIPsNested<A>`	`editLastPodIP()`
`PodStatusFluent.ConditionsNested<A>`	`editMatchingCondition(Predicate<PodConditionBuilder> predicate)`
`PodStatusFluent.ContainerStatusesNested<A>`	`editMatchingContainerStatus(Predicate<ContainerStatusBuilder> predicate)`
`PodStatusFluent.EphemeralContainerStatusesNested<A>`	`editMatchingEphemeralContainerStatus(Predicate<ContainerStatusBuilder> predicate)`
`PodStatusFluent.InitContainerStatusesNested<A>`	`editMatchingInitContainerStatus(Predicate<ContainerStatusBuilder> predicate)`
`PodStatusFluent.PodIPsNested<A>`	`editMatchingPodIP(Predicate<PodIPBuilder> predicate)`
`PodStatusFluent.PodIPsNested<A>`	`editPodIP(int index)`
`boolean`	`equals(Object o)`
`Map<String,Object>`	`getAdditionalProperties()`
`String`	`getHostIP()`
`String`	`getMessage()`
`String`	`getNominatedNodeName()`
`String`	`getPhase()`
`String`	`getPodIP()`
`String`	`getQosClass()`
`String`	`getReason()`
`String`	`getResize()`
`String`	`getStartTime()`
`boolean`	`hasAdditionalProperties()`
`boolean`	`hasConditions()`
`boolean`	`hasContainerStatuses()`
`boolean`	`hasEphemeralContainerStatuses()`
`int`	`hashCode()`
`boolean`	`hasHostIP()`
`boolean`	`hasInitContainerStatuses()`
`boolean`	`hasMatchingCondition(Predicate<PodConditionBuilder> predicate)`
`boolean`	`hasMatchingContainerStatus(Predicate<ContainerStatusBuilder> predicate)`
`boolean`	`hasMatchingEphemeralContainerStatus(Predicate<ContainerStatusBuilder> predicate)`
`boolean`	`hasMatchingInitContainerStatus(Predicate<ContainerStatusBuilder> predicate)`
`boolean`	`hasMatchingPodIP(Predicate<PodIPBuilder> predicate)`
`boolean`	`hasMessage()`
`boolean`	`hasNominatedNodeName()`
`boolean`	`hasPhase()`
`boolean`	`hasPodIP()`
`boolean`	`hasPodIPs()`
`boolean`	`hasQosClass()`
`boolean`	`hasReason()`
`boolean`	`hasResize()`
`boolean`	`hasStartTime()`
`A`	`removeAllFromConditions(Collection<PodCondition> items)`
`A`	`removeAllFromContainerStatuses(Collection<ContainerStatus> items)`
`A`	`removeAllFromEphemeralContainerStatuses(Collection<ContainerStatus> items)`
`A`	`removeAllFromInitContainerStatuses(Collection<ContainerStatus> items)`
`A`	`removeAllFromPodIPs(Collection<PodIP> items)`
`A`	`removeFromAdditionalProperties(Map<String,Object> map)`
`A`	`removeFromAdditionalProperties(String key)`
`A`	`removeFromConditions(PodCondition... items)`
`A`	`removeFromContainerStatuses(ContainerStatus... items)`
`A`	`removeFromEphemeralContainerStatuses(ContainerStatus... items)`
`A`	`removeFromInitContainerStatuses(ContainerStatus... items)`
`A`	`removeFromPodIPs(PodIP... items)`
`A`	`removeMatchingFromConditions(Predicate<PodConditionBuilder> predicate)`
`A`	`removeMatchingFromContainerStatuses(Predicate<ContainerStatusBuilder> predicate)`
`A`	`removeMatchingFromEphemeralContainerStatuses(Predicate<ContainerStatusBuilder> predicate)`
`A`	`removeMatchingFromInitContainerStatuses(Predicate<ContainerStatusBuilder> predicate)`
`A`	`removeMatchingFromPodIPs(Predicate<PodIPBuilder> predicate)`
`PodStatusFluent.ConditionsNested<A>`	`setNewConditionLike(int index, PodCondition item)`
`PodStatusFluent.ContainerStatusesNested<A>`	`setNewContainerStatusLike(int index, ContainerStatus item)`
`PodStatusFluent.EphemeralContainerStatusesNested<A>`	`setNewEphemeralContainerStatusLike(int index, ContainerStatus item)`
`PodStatusFluent.InitContainerStatusesNested<A>`	`setNewInitContainerStatusLike(int index, ContainerStatus item)`
`PodStatusFluent.PodIPsNested<A>`	`setNewPodIPLike(int index, PodIP item)`
`A`	`setToConditions(int index, PodCondition item)`
`A`	`setToContainerStatuses(int index, ContainerStatus item)`
`A`	`setToEphemeralContainerStatuses(int index, ContainerStatus item)`
`A`	`setToInitContainerStatuses(int index, ContainerStatus item)`
`A`	`setToPodIPs(int index, PodIP item)`
`String`	`toString()`
`<K,V> A`	`withAdditionalProperties(Map<String,Object> additionalProperties)`
`A`	`withConditions(List<PodCondition> conditions)`
`A`	`withConditions(PodCondition... conditions)`
`A`	`withContainerStatuses(ContainerStatus... containerStatuses)`
`A`	`withContainerStatuses(List<ContainerStatus> containerStatuses)`
`A`	`withEphemeralContainerStatuses(ContainerStatus... ephemeralContainerStatuses)`
`A`	`withEphemeralContainerStatuses(List<ContainerStatus> ephemeralContainerStatuses)`
`A`	`withHostIP(String hostIP)`
`A`	`withInitContainerStatuses(ContainerStatus... initContainerStatuses)`
`A`	`withInitContainerStatuses(List<ContainerStatus> initContainerStatuses)`
`A`	`withMessage(String message)`
`A`	`withNominatedNodeName(String nominatedNodeName)`
`A`	`withPhase(String phase)`
`A`	`withPodIP(String podIP)`
`A`	`withPodIPs(List<PodIP> podIPs)`
`A`	`withPodIPs(PodIP... podIPs)`
`A`	`withQosClass(String qosClass)`
`A`	`withReason(String reason)`
`A`	`withResize(String resize)`
`A`	`withStartTime(String startTime)`

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

PodStatusFluent
```
public PodStatusFluent()
```

PodStatusFluent

public PodStatusFluent(PodStatus instance)

Method Detail

addToConditions

public A addToConditions(int index,
                         PodCondition item)

setToConditions

public A setToConditions(int index,
                         PodCondition item)

addToConditions

public A addToConditions(PodCondition... items)

addAllToConditions

public A addAllToConditions(Collection<PodCondition> items)

removeFromConditions

public A removeFromConditions(PodCondition... items)

removeAllFromConditions

public A removeAllFromConditions(Collection<PodCondition> items)

removeMatchingFromConditions

public A removeMatchingFromConditions(Predicate<PodConditionBuilder> predicate)

buildConditions

public List<PodCondition> buildConditions()

buildCondition

public PodCondition buildCondition(int index)

buildFirstCondition

public PodCondition buildFirstCondition()

buildLastCondition

public PodCondition buildLastCondition()

buildMatchingCondition

public PodCondition buildMatchingCondition(Predicate<PodConditionBuilder> predicate)

hasMatchingCondition

public boolean hasMatchingCondition(Predicate<PodConditionBuilder> predicate)

withConditions

public A withConditions(List<PodCondition> conditions)

withConditions

public A withConditions(PodCondition... conditions)

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

addNewCondition

public PodStatusFluent.ConditionsNested<A> addNewCondition()

addNewConditionLike

public PodStatusFluent.ConditionsNested<A> addNewConditionLike(PodCondition item)

setNewConditionLike

public PodStatusFluent.ConditionsNested<A> setNewConditionLike(int index,
                                                               PodCondition item)

editCondition

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

editFirstCondition

public PodStatusFluent.ConditionsNested<A> editFirstCondition()

editLastCondition

public PodStatusFluent.ConditionsNested<A> editLastCondition()

editMatchingCondition

public PodStatusFluent.ConditionsNested<A> editMatchingCondition(Predicate<PodConditionBuilder> predicate)

addToContainerStatuses

public A addToContainerStatuses(int index,
                                ContainerStatus item)

setToContainerStatuses

public A setToContainerStatuses(int index,
                                ContainerStatus item)

addToContainerStatuses

public A addToContainerStatuses(ContainerStatus... items)

addAllToContainerStatuses

public A addAllToContainerStatuses(Collection<ContainerStatus> items)

removeFromContainerStatuses

public A removeFromContainerStatuses(ContainerStatus... items)

removeAllFromContainerStatuses

public A removeAllFromContainerStatuses(Collection<ContainerStatus> items)

removeMatchingFromContainerStatuses

public A removeMatchingFromContainerStatuses(Predicate<ContainerStatusBuilder> predicate)

buildContainerStatuses

public List<ContainerStatus> buildContainerStatuses()

buildContainerStatus

public ContainerStatus buildContainerStatus(int index)

buildFirstContainerStatus

public ContainerStatus buildFirstContainerStatus()

buildLastContainerStatus

public ContainerStatus buildLastContainerStatus()

buildMatchingContainerStatus

public ContainerStatus buildMatchingContainerStatus(Predicate<ContainerStatusBuilder> predicate)

hasMatchingContainerStatus

public boolean hasMatchingContainerStatus(Predicate<ContainerStatusBuilder> predicate)

withContainerStatuses

public A withContainerStatuses(List<ContainerStatus> containerStatuses)

withContainerStatuses

public A withContainerStatuses(ContainerStatus... containerStatuses)

hasContainerStatuses
```
public boolean hasContainerStatuses()
```

addNewContainerStatus

public PodStatusFluent.ContainerStatusesNested<A> addNewContainerStatus()

addNewContainerStatusLike

public PodStatusFluent.ContainerStatusesNested<A> addNewContainerStatusLike(ContainerStatus item)

setNewContainerStatusLike

public PodStatusFluent.ContainerStatusesNested<A> setNewContainerStatusLike(int index,
                                                                            ContainerStatus item)

editContainerStatus

public PodStatusFluent.ContainerStatusesNested<A> editContainerStatus(int index)

editFirstContainerStatus

public PodStatusFluent.ContainerStatusesNested<A> editFirstContainerStatus()

editLastContainerStatus

public PodStatusFluent.ContainerStatusesNested<A> editLastContainerStatus()

editMatchingContainerStatus

public PodStatusFluent.ContainerStatusesNested<A> editMatchingContainerStatus(Predicate<ContainerStatusBuilder> predicate)

addToEphemeralContainerStatuses

public A addToEphemeralContainerStatuses(int index,
                                         ContainerStatus item)

setToEphemeralContainerStatuses

public A setToEphemeralContainerStatuses(int index,
                                         ContainerStatus item)

addToEphemeralContainerStatuses

public A addToEphemeralContainerStatuses(ContainerStatus... items)

addAllToEphemeralContainerStatuses

public A addAllToEphemeralContainerStatuses(Collection<ContainerStatus> items)

removeFromEphemeralContainerStatuses

public A removeFromEphemeralContainerStatuses(ContainerStatus... items)

removeAllFromEphemeralContainerStatuses

public A removeAllFromEphemeralContainerStatuses(Collection<ContainerStatus> items)

removeMatchingFromEphemeralContainerStatuses

public A removeMatchingFromEphemeralContainerStatuses(Predicate<ContainerStatusBuilder> predicate)

buildEphemeralContainerStatuses

public List<ContainerStatus> buildEphemeralContainerStatuses()

buildEphemeralContainerStatus

public ContainerStatus buildEphemeralContainerStatus(int index)

buildFirstEphemeralContainerStatus

public ContainerStatus buildFirstEphemeralContainerStatus()

buildLastEphemeralContainerStatus

public ContainerStatus buildLastEphemeralContainerStatus()

buildMatchingEphemeralContainerStatus

public ContainerStatus buildMatchingEphemeralContainerStatus(Predicate<ContainerStatusBuilder> predicate)

hasMatchingEphemeralContainerStatus

public boolean hasMatchingEphemeralContainerStatus(Predicate<ContainerStatusBuilder> predicate)

withEphemeralContainerStatuses

public A withEphemeralContainerStatuses(List<ContainerStatus> ephemeralContainerStatuses)

withEphemeralContainerStatuses

public A withEphemeralContainerStatuses(ContainerStatus... ephemeralContainerStatuses)

hasEphemeralContainerStatuses

public boolean hasEphemeralContainerStatuses()

addNewEphemeralContainerStatus

public PodStatusFluent.EphemeralContainerStatusesNested<A> addNewEphemeralContainerStatus()

addNewEphemeralContainerStatusLike

public PodStatusFluent.EphemeralContainerStatusesNested<A> addNewEphemeralContainerStatusLike(ContainerStatus item)

setNewEphemeralContainerStatusLike

public PodStatusFluent.EphemeralContainerStatusesNested<A> setNewEphemeralContainerStatusLike(int index,
                                                                                              ContainerStatus item)

editEphemeralContainerStatus

public PodStatusFluent.EphemeralContainerStatusesNested<A> editEphemeralContainerStatus(int index)

editFirstEphemeralContainerStatus

public PodStatusFluent.EphemeralContainerStatusesNested<A> editFirstEphemeralContainerStatus()

editLastEphemeralContainerStatus

public PodStatusFluent.EphemeralContainerStatusesNested<A> editLastEphemeralContainerStatus()

editMatchingEphemeralContainerStatus

public PodStatusFluent.EphemeralContainerStatusesNested<A> editMatchingEphemeralContainerStatus(Predicate<ContainerStatusBuilder> predicate)

getHostIP
```
public String getHostIP()
```

withHostIP
```
public A withHostIP(String hostIP)
```

hasHostIP
```
public boolean hasHostIP()
```

addToInitContainerStatuses

public A addToInitContainerStatuses(int index,
                                    ContainerStatus item)

setToInitContainerStatuses

public A setToInitContainerStatuses(int index,
                                    ContainerStatus item)

addToInitContainerStatuses

public A addToInitContainerStatuses(ContainerStatus... items)

addAllToInitContainerStatuses

public A addAllToInitContainerStatuses(Collection<ContainerStatus> items)

removeFromInitContainerStatuses

public A removeFromInitContainerStatuses(ContainerStatus... items)

removeAllFromInitContainerStatuses

public A removeAllFromInitContainerStatuses(Collection<ContainerStatus> items)

removeMatchingFromInitContainerStatuses

public A removeMatchingFromInitContainerStatuses(Predicate<ContainerStatusBuilder> predicate)

buildInitContainerStatuses

public List<ContainerStatus> buildInitContainerStatuses()

buildInitContainerStatus

public ContainerStatus buildInitContainerStatus(int index)

buildFirstInitContainerStatus

public ContainerStatus buildFirstInitContainerStatus()

buildLastInitContainerStatus

public ContainerStatus buildLastInitContainerStatus()

buildMatchingInitContainerStatus

public ContainerStatus buildMatchingInitContainerStatus(Predicate<ContainerStatusBuilder> predicate)

hasMatchingInitContainerStatus

public boolean hasMatchingInitContainerStatus(Predicate<ContainerStatusBuilder> predicate)

withInitContainerStatuses

public A withInitContainerStatuses(List<ContainerStatus> initContainerStatuses)

withInitContainerStatuses

public A withInitContainerStatuses(ContainerStatus... initContainerStatuses)

hasInitContainerStatuses

public boolean hasInitContainerStatuses()

addNewInitContainerStatus

public PodStatusFluent.InitContainerStatusesNested<A> addNewInitContainerStatus()

addNewInitContainerStatusLike

public PodStatusFluent.InitContainerStatusesNested<A> addNewInitContainerStatusLike(ContainerStatus item)

setNewInitContainerStatusLike

public PodStatusFluent.InitContainerStatusesNested<A> setNewInitContainerStatusLike(int index,
                                                                                    ContainerStatus item)

editInitContainerStatus

public PodStatusFluent.InitContainerStatusesNested<A> editInitContainerStatus(int index)

editFirstInitContainerStatus

public PodStatusFluent.InitContainerStatusesNested<A> editFirstInitContainerStatus()

editLastInitContainerStatus

public PodStatusFluent.InitContainerStatusesNested<A> editLastInitContainerStatus()

editMatchingInitContainerStatus

public PodStatusFluent.InitContainerStatusesNested<A> editMatchingInitContainerStatus(Predicate<ContainerStatusBuilder> predicate)

getMessage
```
public String getMessage()
```

withMessage
```
public A withMessage(String message)
```

hasMessage
```
public boolean hasMessage()
```

getNominatedNodeName
```
public String getNominatedNodeName()
```

withNominatedNodeName

public A withNominatedNodeName(String nominatedNodeName)

hasNominatedNodeName
```
public boolean hasNominatedNodeName()
```

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

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

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

getPodIP
```
public String getPodIP()
```

withPodIP
```
public A withPodIP(String podIP)
```

hasPodIP
```
public boolean hasPodIP()
```

addToPodIPs

public A addToPodIPs(int index,
                     PodIP item)

setToPodIPs

public A setToPodIPs(int index,
                     PodIP item)

addToPodIPs
```
public A addToPodIPs(PodIP... items)
```

addAllToPodIPs

public A addAllToPodIPs(Collection<PodIP> items)

removeFromPodIPs

public A removeFromPodIPs(PodIP... items)

removeAllFromPodIPs

public A removeAllFromPodIPs(Collection<PodIP> items)

removeMatchingFromPodIPs

public A removeMatchingFromPodIPs(Predicate<PodIPBuilder> predicate)

buildPodIPs
```
public List<PodIP> buildPodIPs()
```

buildPodIP
```
public PodIP buildPodIP(int index)
```

buildFirstPodIP
```
public PodIP buildFirstPodIP()
```

buildLastPodIP
```
public PodIP buildLastPodIP()
```

buildMatchingPodIP

public PodIP buildMatchingPodIP(Predicate<PodIPBuilder> predicate)

hasMatchingPodIP

public boolean hasMatchingPodIP(Predicate<PodIPBuilder> predicate)

withPodIPs

public A withPodIPs(List<PodIP> podIPs)

withPodIPs
```
public A withPodIPs(PodIP... podIPs)
```

hasPodIPs
```
public boolean hasPodIPs()
```

addNewPodIP
```
public A addNewPodIP(String ip)
```

addNewPodIP

public PodStatusFluent.PodIPsNested<A> addNewPodIP()

addNewPodIPLike

public PodStatusFluent.PodIPsNested<A> addNewPodIPLike(PodIP item)

setNewPodIPLike

public PodStatusFluent.PodIPsNested<A> setNewPodIPLike(int index,
                                                       PodIP item)

editPodIP

public PodStatusFluent.PodIPsNested<A> editPodIP(int index)

editFirstPodIP

public PodStatusFluent.PodIPsNested<A> editFirstPodIP()

editLastPodIP

public PodStatusFluent.PodIPsNested<A> editLastPodIP()

editMatchingPodIP

public PodStatusFluent.PodIPsNested<A> editMatchingPodIP(Predicate<PodIPBuilder> predicate)

getQosClass
```
public String getQosClass()
```

withQosClass

public A withQosClass(String qosClass)

hasQosClass
```
public boolean hasQosClass()
```

getReason
```
public String getReason()
```

withReason
```
public A withReason(String reason)
```

hasReason
```
public boolean hasReason()
```

getResize
```
public String getResize()
```

withResize
```
public A withResize(String resize)
```

hasResize
```
public boolean hasResize()
```

getStartTime
```
public String getStartTime()
```

withStartTime

public A withStartTime(String startTime)

hasStartTime
```
public boolean hasStartTime()
```

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 BaseFluent<A extends PodStatusFluent<A>>

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

hashCode in class BaseFluent<A extends PodStatusFluent<A>>

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

toString in class Object

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

PodStatusFluent

PodStatusFluent

Method Detail

addToConditions

setToConditions

addToConditions

addAllToConditions

removeFromConditions

removeAllFromConditions

removeMatchingFromConditions

buildConditions

buildCondition

buildFirstCondition

buildLastCondition

buildMatchingCondition

hasMatchingCondition

withConditions

withConditions

hasConditions

addNewCondition

addNewConditionLike

setNewConditionLike

editCondition

editFirstCondition

editLastCondition

editMatchingCondition

addToContainerStatuses

setToContainerStatuses

addToContainerStatuses

addAllToContainerStatuses

removeFromContainerStatuses

removeAllFromContainerStatuses

removeMatchingFromContainerStatuses

buildContainerStatuses

buildContainerStatus

buildFirstContainerStatus

buildLastContainerStatus

buildMatchingContainerStatus

hasMatchingContainerStatus

withContainerStatuses

withContainerStatuses

hasContainerStatuses

addNewContainerStatus

addNewContainerStatusLike

setNewContainerStatusLike

editContainerStatus

editFirstContainerStatus

editLastContainerStatus

editMatchingContainerStatus

addToEphemeralContainerStatuses

setToEphemeralContainerStatuses

addToEphemeralContainerStatuses

addAllToEphemeralContainerStatuses

removeFromEphemeralContainerStatuses

removeAllFromEphemeralContainerStatuses

removeMatchingFromEphemeralContainerStatuses

buildEphemeralContainerStatuses

buildEphemeralContainerStatus

buildFirstEphemeralContainerStatus

buildLastEphemeralContainerStatus

buildMatchingEphemeralContainerStatus

hasMatchingEphemeralContainerStatus

withEphemeralContainerStatuses

withEphemeralContainerStatuses

hasEphemeralContainerStatuses

addNewEphemeralContainerStatus

addNewEphemeralContainerStatusLike

setNewEphemeralContainerStatusLike

editEphemeralContainerStatus

editFirstEphemeralContainerStatus