io.fabric8.openshift.api.model.operator.v1

Interface DNSSpecFluent<A extends DNSSpecFluent<A>>

All Superinterfaces:

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

All Known Subinterfaces:

DNSFluent.SpecNested<N>

All Known Implementing Classes:

DNSFluentImpl.SpecNestedImpl, DNSSpecBuilder, DNSSpecFluentImpl

public interface DNSSpecFluent<A extends DNSSpecFluent<A>>
extends io.fabric8.kubernetes.api.builder.Fluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	DNSSpecFluent.NodePlacementNested<N>
static interface	DNSSpecFluent.ServersNested<N>

Method Summary

Modifier and Type	Method and Description
A	addAllToServers(Collection<Server> items)
DNSSpecFluent.ServersNested<A>	addNewServer()
DNSSpecFluent.ServersNested<A>	addNewServerLike(Server item)
A	addToServers(Integer index, Server item)
A	addToServers(Server... items)
Server	buildFirstServer()
Server	buildLastServer()
Server	buildMatchingServer(Predicate<ServerBuilder> predicate)
DNSNodePlacement	buildNodePlacement()
Server	buildServer(Integer index)
List<Server>	buildServers()
DNSSpecFluent.ServersNested<A>	editFirstServer()
DNSSpecFluent.ServersNested<A>	editLastServer()
DNSSpecFluent.ServersNested<A>	editMatchingServer(Predicate<ServerBuilder> predicate)
DNSSpecFluent.NodePlacementNested<A>	editNodePlacement()
DNSSpecFluent.NodePlacementNested<A>	editOrNewNodePlacement()
DNSSpecFluent.NodePlacementNested<A>	editOrNewNodePlacementLike(DNSNodePlacement item)
DNSSpecFluent.ServersNested<A>	editServer(Integer index)
DNSNodePlacement	getNodePlacement() Deprecated.
List<Server>	getServers() Deprecated.
Boolean	hasMatchingServer(Predicate<ServerBuilder> predicate)
Boolean	hasNodePlacement()
Boolean	hasServers()
A	removeAllFromServers(Collection<Server> items)
A	removeFromServers(Server... items)
A	removeMatchingFromServers(Predicate<ServerBuilder> predicate)
DNSSpecFluent.ServersNested<A>	setNewServerLike(Integer index, Server item)
A	setToServers(Integer index, Server item)
DNSSpecFluent.NodePlacementNested<A>	withNewNodePlacement()
DNSSpecFluent.NodePlacementNested<A>	withNewNodePlacementLike(DNSNodePlacement item)
A	withNodePlacement(DNSNodePlacement nodePlacement)
A	withServers(List<Server> servers)
A	withServers(Server... servers)

Method Detail

getNodePlacement

@Deprecated
DNSNodePlacement getNodePlacement()

Deprecated.

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

Returns:

The buildable object.

buildNodePlacement

DNSNodePlacement buildNodePlacement()

withNodePlacement

A withNodePlacement(DNSNodePlacement nodePlacement)

hasNodePlacement

Boolean hasNodePlacement()

withNewNodePlacement

DNSSpecFluent.NodePlacementNested<A> withNewNodePlacement()

withNewNodePlacementLike

DNSSpecFluent.NodePlacementNested<A> withNewNodePlacementLike(DNSNodePlacement item)

editNodePlacement

DNSSpecFluent.NodePlacementNested<A> editNodePlacement()

editOrNewNodePlacement

DNSSpecFluent.NodePlacementNested<A> editOrNewNodePlacement()

editOrNewNodePlacementLike

DNSSpecFluent.NodePlacementNested<A> editOrNewNodePlacementLike(DNSNodePlacement item)

addToServers

A addToServers(Integer index,
               Server item)

setToServers

A setToServers(Integer index,
               Server item)

addToServers

A addToServers(Server... items)

addAllToServers

A addAllToServers(Collection<Server> items)

removeFromServers

A removeFromServers(Server... items)

removeAllFromServers

A removeAllFromServers(Collection<Server> items)

removeMatchingFromServers

A removeMatchingFromServers(Predicate<ServerBuilder> predicate)

getServers

@Deprecated
List<Server> getServers()

Deprecated.

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

Returns:

The buildable object.

buildServers

List<Server> buildServers()

buildServer

Server buildServer(Integer index)

buildFirstServer

Server buildFirstServer()

buildLastServer

Server buildLastServer()

buildMatchingServer

Server buildMatchingServer(Predicate<ServerBuilder> predicate)

hasMatchingServer

Boolean hasMatchingServer(Predicate<ServerBuilder> predicate)

withServers

A withServers(List<Server> servers)

withServers

A withServers(Server... servers)

hasServers

Boolean hasServers()

addNewServer

DNSSpecFluent.ServersNested<A> addNewServer()

addNewServerLike

DNSSpecFluent.ServersNested<A> addNewServerLike(Server item)

setNewServerLike

DNSSpecFluent.ServersNested<A> setNewServerLike(Integer index,
                                                Server item)

editServer

DNSSpecFluent.ServersNested<A> editServer(Integer index)

editFirstServer

DNSSpecFluent.ServersNested<A> editFirstServer()

editLastServer

DNSSpecFluent.ServersNested<A> editLastServer()

editMatchingServer

DNSSpecFluent.ServersNested<A> editMatchingServer(Predicate<ServerBuilder> predicate)