Top Deprecated By Reference
Vert.x 4.5.13

Deprecated API

No API in this release is deprecated for removal.

Deprecated Item Summary

SinceDeprecated Item and Description

Returns:

if generated converters are enabled, buffers should default to the configured type.
io.vertx.codegen.annotations.DataObject.base64Type()

instead declare a io.vertx.codegen.json.annotations.JsonGen#base64Type()

Returns:

true if converter should be generated for the data object
io.vertx.codegen.annotations.DataObject.generateConverter()

instead declare a io.vertx.codegen.json.annotations.JsonGen annotation

Returns:

true if the converter should handle the state of the ancestors.
io.vertx.codegen.annotations.DataObject.inheritConverter()

instead declare a io.vertx.codegen.json.annotations.JsonGen#inheritConverter()

Returns:

the case class specifying how the data object converter properties will be translated to JSON element names.
io.vertx.codegen.annotations.DataObject.jsonPropertyNameFormatter()

instead declare a io.vertx.codegen.json.annotations.JsonGen#jsonPropertyNameFormatter()

Returns:

whether the generated converter should be public or package private
io.vertx.codegen.annotations.DataObject.publicConverter()

instead declare a io.vertx.codegen.json.annotations.JsonGen#publicConverter()

Returns:

if generated converters are enabled, buffers should default to the configured type.
io.vertx.codegen.json.annotations.JsonGen.base64Type()

avoid using this attribute which defaults to base64url which is the only type supported in Vert.x 5

Returns:

the composite future
io.vertx.core.CompositeFuture.all(Future<T1>
future
f1, Future<T2>
future
f2)

instead use Future#all(Future, Future)

io.vertx.core.CompositeFuture.all(Future<T1> f1, Future<T2> f2, Future<T3> f3)

instead use Future#all(Future, Future, Future)

io.vertx.core.CompositeFuture.all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)

instead use Future#all(Future, Future, Future, Future)

io.vertx.core.CompositeFuture.all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)

instead use Future#all(Future, Future, Future, Future, Future)

io.vertx.core.CompositeFuture.all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)

instead use Future#all(Future, Future, Future, Future, Future, Future)

io.vertx.core.CompositeFuture.all(List<Future<T>> futures)

instead use Future#all(List)

Returns:

the composite future
io.vertx.core.CompositeFuture.any(Future<T1>
future
f1, Future<T2>
future
f2)

instead use Future#any(Future, Future)

io.vertx.core.CompositeFuture.any(Future<T1> f1, Future<T2> f2, Future<T3> f3)

instead use Future#any(Future, Future, Future)

io.vertx.core.CompositeFuture.any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)

instead use Future#any(Future, Future, Future, Future)

io.vertx.core.CompositeFuture.any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)

instead use Future#any(Future, Future, Future, Future, Future)

io.vertx.core.CompositeFuture.any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)

instead use Future#any(Future, Future, Future, Future, Future, Future)

io.vertx.core.CompositeFuture.any(List<Future<T>> futures)

instead use Future#any(List)

Returns:

the composite future
io.vertx.core.CompositeFuture.join(Future<T1>
future
f1, Future<T2>
future
f2)

instead use Future#join(Future, Future)

io.vertx.core.CompositeFuture.join(Future<T1> f1, Future<T2> f2, Future<T3> f3)

instead use Future#join(Future, Future, Future)

io.vertx.core.CompositeFuture.join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)

instead use Future#join(Future, Future, Future, Future)

io.vertx.core.CompositeFuture.join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)

instead use Future#join(Future, Future, Future, Future, Future)

io.vertx.core.CompositeFuture.join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)

instead use Future#join(Future, Future, Future, Future, Future, Future)

io.vertx.core.CompositeFuture.join(List<Future<T>> futures)

instead use Future#join(List)

io.vertx.core.Context.executeBlocking(Handler<Promise<T>>
handler representing the blocking code to run
blockingCodeHandler, boolean
if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
ordered, Handler<AsyncResult<@Nullable T>>
handler that will be called when the blocking code is complete
resultHandler)

instead use executeBlocking(Callable, boolean)

io.vertx.core.Context.executeBlocking(Handler<Promise<T>>
handler representing the blocking code to run
blockingCodeHandler, Handler<AsyncResult<@Nullable T>>
handler that will be called when the blocking code is complete
resultHandler)

instead use executeBlocking(Callable)

io.vertx.core.Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)

instead use executeBlocking(Callable, boolean)

io.vertx.core.Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler)

instead use executeBlocking(Callable)

Returns:

any extra classpath
io.vertx.core.DeploymentOptions.getExtraClasspath()

Returns:

the list of isolated classes
io.vertx.core.DeploymentOptions.getIsolatedClasses()

Returns:

the isolation group
io.vertx.core.DeploymentOptions.getIsolationGroup()

Returns:

true if will be deployed as worker, false otherwise
io.vertx.core.DeploymentOptions.isWorker()

instead use getThreadingModel()

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.DeploymentOptions.setExtraClasspath(List<String> extraClasspath)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.DeploymentOptions.setIsolatedClasses(List<String>
the list of isolated class names
isolatedClasses)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.DeploymentOptions.setIsolationGroup(String
- the isolation group
isolationGroup)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.DeploymentOptions.setWorker(boolean
true for worker, false force event-loop
worker)

instead use setThreadingModel(ThreadingModel)

Returns:

the composed future
io.vertx.core.Future.eventually(Function<Void, Future<U>>
the function returning the future.
function)

instead use eventually(Supplier), this method will be removed in Vert.x 5

io.vertx.core.ServiceHelper

this utility class is for internal usage of Vert.x and will be moved to an internal vertx package in Vert.x 5

io.vertx.core.TimeoutStream

use Vertx#setTimer/Vertx#setPeriodic instead. RxJava like integrations should use the Vert.x scheduler integration.

io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>>
handler representing the blocking code to run
blockingCodeHandler, boolean
if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
ordered, Handler<AsyncResult<@Nullable T>>
handler that will be called when the blocking code is complete
resultHandler)

use instead executeBlocking(Callable, boolean)

io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<@Nullable T>> resultHandler)

instead use executeBlocking(Callable)

io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)

instead use executeBlocking(Callable, boolean)

io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler)

instead use executeBlocking(Callable)

Returns:

the EventLoopGroup
io.vertx.core.Vertx.nettyEventLoopGroup()

removed from public API in Vert.x 5

Returns:

the periodic stream
io.vertx.core.Vertx.periodicStream(long
the delay in milliseconds, after which the timer will fire
delay)

use Vertx#setPeriodic instead. RxJava like integrations should use the Vert.x scheduler integration.

Returns:

the periodic stream
io.vertx.core.Vertx.periodicStream(long
the initial delay in milliseconds
initialDelay, long
the delay in milliseconds, after which the timer will fire
delay)

use Vertx#setPeriodic instead. RxJava like integrations should use the Vert.x scheduler integration.

Returns:

the timer stream
io.vertx.core.Vertx.timerStream(long
the delay in milliseconds, after which the timer will fire
delay)

use Vertx#setTimer instead. RxJava like integrations should use the Vert.x scheduler integration.

io.vertx.core.VertxOptions.DISABLE_TCCL_PROP_NAME

instead use VertxOptions#setDisableTCCL(boolean), removed in vertx 5

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.VertxOptions.setClusterManager(ClusterManager
the cluster manager
clusterManager)

instead use io.vertx.core.VertxBuilder#withClusterManager(ClusterManager)

io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>
handler representing the blocking code to run
blockingCodeHandler, boolean
if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
ordered, Handler<AsyncResult<@Nullable T>>
handler that will be called when the blocking code is complete
resultHandler)

instead use executeBlocking(Callable, boolean)

io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<@Nullable T>> resultHandler)

instead use executeBlocking(Callable)

io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)

instead use executeBlocking(Callable, boolean)

io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler)

instead use executeBlocking(Callable)

Returns:

the buffer
io.vertx.core.buffer.Buffer.buffer(ByteBuf
the Netty ByteBuf
byteBuf)

removed from public API in Vert.x 5

io.vertx.core.buffer.Buffer.getByteBuf()

removed from public API in Vert.x 5

io.vertx.core.buffer.Buffer.toJson()

instead use toJsonValue()

Returns:

the list of values, empty if none
io.vertx.core.cli.CommandLine.getRawValues(Option
the option
option)

use getRawValuesForOption(Option)

io.vertx.core.datagram.DatagramSocket.endHandler(Handler<Void> endHandler)

removed in Vert.x 5

io.vertx.core.datagram.DatagramSocket.fetch(long amount)

no replacement for back-pressure, instead ignore the packet or buffer it somewhere

io.vertx.core.datagram.DatagramSocket.pause()

no replacement for back-pressure, instead ignore the packet or buffer it somewhere

io.vertx.core.datagram.DatagramSocket.resume()

no replacement for back-pressure, instead ignore the packet or buffer it somewhere

io.vertx.core.dns.AddressResolverOptions.DEFAULT_SEACH_DOMAINS

instead use DEFAULT_SEARCH_DOMAINS

io.vertx.core.eventbus.EventBusOptions.setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)

io.vertx.core.eventbus.EventBusOptions.setKeyStoreOptions(JksOptions
the key store in jks format
options)

io.vertx.core.eventbus.EventBusOptions.setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)

io.vertx.core.eventbus.EventBusOptions.setPemKeyCertOptions(PemKeyCertOptions
the options in pem format
options)

io.vertx.core.eventbus.EventBusOptions.setPemTrustOptions(PemTrustOptions
the trust options in pem format
options)

io.vertx.core.eventbus.EventBusOptions.setPfxKeyCertOptions(PfxOptions
the key cert options in pfx format
options)

io.vertx.core.eventbus.EventBusOptions.setPfxTrustOptions(PfxOptions
the trust options in pfx format
options)

io.vertx.core.eventbus.EventBusOptions.setTrustStoreOptions(JksOptions
the trust options in jks format
options)

Returns:

this registration
io.vertx.core.eventbus.MessageConsumer.setMaxBufferedMessages(int
the maximum number of messages that can be buffered
maxBufferedMessages)

for removal, instead use MessageConsumerOptions#setMaxBufferedMessages(int)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.http.HttpClient.connectionHandler(Handler<HttpConnection> handler)

instead use HttpClientBuilder#withConnectHandler(Handler)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.http.HttpClient.redirectHandler(Function<HttpClientResponse, Future<RequestOptions>>
the new redirect handler
handler)

instead use HttpClientBuilder#withRedirectHandler(Function)

Returns:

the current redirect handler.
io.vertx.core.http.HttpClient.redirectHandler()

io.vertx.core.http.HttpClient.webSocket(int
the port
port, String
the host
host, String
the relative URI
requestURI, Handler<AsyncResult<WebSocket>>
handler that will be called with the WebSocket when connected
handler)

instead use WebSocketClient#connect(int, String, String, Handler)

io.vertx.core.http.HttpClient.webSocket(int port, String host, String requestURI)

instead use WebSocketClient#connect(int, String, String)

io.vertx.core.http.HttpClient.webSocket(String
the host
host, String
the relative URI
requestURI, Handler<AsyncResult<WebSocket>>
handler that will be called with the WebSocket when connected
handler)

instead use WebSocketClient#connect(int, String, String, Handler)

io.vertx.core.http.HttpClient.webSocket(String host, String requestURI)

instead use WebSocketClient#connect(int, String, String)

io.vertx.core.http.HttpClient.webSocket(String
the relative URI
requestURI, Handler<AsyncResult<WebSocket>>
handler that will be called with the WebSocket when connected
handler)

instead use WebSocketClient#connect(int, String, String, Handler)

io.vertx.core.http.HttpClient.webSocket(String requestURI)

instead use WebSocketClient#connect(int, String, String)

io.vertx.core.http.HttpClient.webSocket(WebSocketConnectOptions
the request options
options, Handler<AsyncResult<WebSocket>> handler)

instead use WebSocketClient#connect(WebSocketConnectOptions, Handler)

io.vertx.core.http.HttpClient.webSocket(WebSocketConnectOptions options)

instead use WebSocketClient#connect(WebSocketConnectOptions)

io.vertx.core.http.HttpClient.webSocketAbs(String
the absolute url
url, MultiMap
the headers
headers, WebsocketVersion
the WebSocket version
version, List<String>
the subprotocols to use
subProtocols, Handler<AsyncResult<WebSocket>>
handler that will be called if WebSocket connection fails
handler)

instead use WebSocketClient#connect(WebSocketConnectOptions, Handler)

io.vertx.core.http.HttpClient.webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols)

instead use WebSocketClient#connect(WebSocketConnectOptions)

io.vertx.core.http.HttpClientOptions.DEFAULT_TRY_USE_COMPRESSION

as of 4.5, use DEFAULT_DECOMPRESSION_SUPPORTED

Returns:

true when the WebSocket per-frame deflate compression extension will be offered
io.vertx.core.http.HttpClientOptions.getTryWebSocketDeflateFrameCompression()

instead use tryUsePerFrameWebSocketCompression

io.vertx.core.http.HttpClientOptions.isTryUseCompression()

as of 4.5, use isDecompressionSupported instead

io.vertx.core.http.HttpClientOptions.setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)

io.vertx.core.http.HttpClientOptions.setKeyStoreOptions(JksOptions
the key store in jks format
options)

io.vertx.core.http.HttpClientOptions.setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)

io.vertx.core.http.HttpClientOptions.setPemKeyCertOptions(PemKeyCertOptions
the options in pem format
options)

io.vertx.core.http.HttpClientOptions.setPemTrustOptions(PemTrustOptions
the trust options in pem format
options)

io.vertx.core.http.HttpClientOptions.setPfxKeyCertOptions(PfxOptions
the key cert options in pfx format
options)

io.vertx.core.http.HttpClientOptions.setPfxTrustOptions(PfxOptions
the trust options in pfx format
options)

io.vertx.core.http.HttpClientOptions.setTrustStoreOptions(JksOptions
the trust options in jks format
options)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.http.HttpClientOptions.setTryUseCompression(boolean
true if enabled
tryUseCompression)

as of 4.5, use setDecompressionSupported(boolean) instead

Returns:

the host value of the HTTP/1.1 host header or HTTP/2 authority pseudo header
io.vertx.core.http.HttpClientRequest.getHost()

Returns:

the port value of the HTTP/1.1 host header or HTTP/2 authority pseudo header
io.vertx.core.http.HttpClientRequest.getPort()

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.http.HttpClientRequest.setHost(String
the host part of the HTTP/1.1 host header or HTTP/2 authority pseudo header
host)

instead use authority(HostAndPort)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.http.HttpClientRequest.setPort(int
the port part of the HTTP/1.1 host header or HTTP/2 authority pseudo header
port)

instead use authority(HostAndPort)

io.vertx.core.http.HttpClientRequest.setTimeout(long timeout)

instead use idleTimeout(long)

Returns:

an ordered array of the peer certificates. Returns null if connection is not SSL.
io.vertx.core.http.HttpConnection.peerCertificateChain()

instead use peerCertificates() or sslSession()

io.vertx.core.http.HttpConnection.shutdown(long timeout, Handler<AsyncResult<Void>> handler)

instead use shutdown(long, TimeUnit, Handler)

io.vertx.core.http.HttpConnection.shutdown(long timeoutMs)

instead use shutdown(long, TimeUnit)

io.vertx.core.http.HttpHeaders.DISABLE_HTTP_HEADERS_VALIDATION_PROP_NAME

Returns:

the request stream
io.vertx.core.http.HttpServer.requestStream()

instead use requestHandler(Handler)

Returns:

the WebSocket stream
io.vertx.core.http.HttpServer.webSocketStream()

instead use webSocketHandler(Handler)

io.vertx.core.http.HttpServerOptions.setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)

io.vertx.core.http.HttpServerOptions.setKeyStoreOptions(JksOptions
the key store in jks format
options)

io.vertx.core.http.HttpServerOptions.setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)

io.vertx.core.http.HttpServerOptions.setPemKeyCertOptions(PemKeyCertOptions
the options in pem format
options)

io.vertx.core.http.HttpServerOptions.setPemTrustOptions(PemTrustOptions
the trust options in pem format
options)

io.vertx.core.http.HttpServerOptions.setPfxKeyCertOptions(PfxOptions
the key cert options in pfx format
options)

io.vertx.core.http.HttpServerOptions.setPfxTrustOptions(PfxOptions
the trust options in pfx format
options)

io.vertx.core.http.HttpServerOptions.setTrustStoreOptions(JksOptions
the trust options in jks format
options)

Returns:

a map of all the cookies.
io.vertx.core.http.HttpServerRequest.cookieMap()

the implementation made a wrong assumption that cookies could be identified only by their name. The RFC states that the tuple of <name, domain, path> is the unique identifier. When more than one cookie has the same name, the map will hold that lost one to be parsed and any previously parsed value will be silently overwritten.

Returns:

the request host. For HTTP2 it returns the :authority pseudo header otherwise it returns the Host header
io.vertx.core.http.HttpServerRequest.host()

instead use authority()

io.vertx.core.http.HttpServerResponse.close()

instead use HttpConnection#close() or reset(long), this method is removed in Vert.x 5

io.vertx.core.http.HttpServerResponse.push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler)

instead use push(HttpMethod, HostAndPort, String, Handler)

io.vertx.core.http.HttpServerResponse.push(HttpMethod method, String host, String path)

instead use push(HttpMethod, HostAndPort, String)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.http.HttpServerResponse.push(HttpMethod
the method of the promised request
method, String
the authority of the promised request
host, String
the path of the promised request
path, MultiMap
the headers of the promised request
headers, Handler<AsyncResult<HttpServerResponse>>
the handler notified when the response can be written
handler)

Returns:

a future notified when the response can be written
io.vertx.core.http.HttpServerResponse.push(HttpMethod
the method of the promised request
method, String
the host of the promised request
host, String
the path of the promised request
path, MultiMap
the headers of the promised request
headers)

instead use push(HttpMethod, HostAndPort, String, MultiMap)

io.vertx.core.http.ServerWebSocket.accept()

instead use ServerWebSocketHandshake#accept()

Returns:

the WebSocket handshake host
io.vertx.core.http.ServerWebSocket.host()

use authority() instead

io.vertx.core.http.ServerWebSocket.reject()

instead use ServerWebSocketHandshake#reject()

io.vertx.core.http.ServerWebSocket.reject(int status)

instead use ServerWebSocketHandshake#reject(int)

io.vertx.core.http.ServerWebSocket.setHandshake(Future<Integer>
the future to complete with
future, Handler<AsyncResult<Integer>>
the completion handler
handler)

instead use ServerWebSocketHandshake

io.vertx.core.http.ServerWebSocket.setHandshake(Future<Integer> future)

instead use ServerWebSocketHandshake

Returns:

an ordered array of the peer certificates. Returns null if connection is not SSL.
io.vertx.core.http.WebSocketBase.peerCertificateChain()

instead use peerCertificates() or sslSession()

io.vertx.core.http.WebSocketClientOptions.setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)

io.vertx.core.http.WebSocketClientOptions.setKeyStoreOptions(JksOptions
the key store in jks format
options)

io.vertx.core.http.WebSocketClientOptions.setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)

io.vertx.core.http.WebSocketClientOptions.setPemKeyCertOptions(PemKeyCertOptions
the options in pem format
options)

io.vertx.core.http.WebSocketClientOptions.setPemTrustOptions(PemTrustOptions
the trust options in pem format
options)

io.vertx.core.http.WebSocketClientOptions.setPfxKeyCertOptions(PfxOptions
the key cert options in pfx format
options)

io.vertx.core.http.WebSocketClientOptions.setPfxTrustOptions(PfxOptions
the trust options in pfx format
options)

io.vertx.core.http.WebSocketClientOptions.setTrustStoreOptions(JksOptions
the trust options in jks format
options)

io.vertx.core.impl.ContextInternal.executeBlocking(Handler<Promise<T>> blockingCodeHandler, TaskQueue queue, Handler<AsyncResult<T>> resultHandler)

instead use executeBlocking(Callable, TaskQueue)

io.vertx.core.impl.ContextInternal.executeBlocking(Handler<Promise<T>> blockingCodeHandler, TaskQueue queue)

io.vertx.core.impl.ContextInternal.executeBlockingInternal(Handler<Promise<T>> action, Handler<AsyncResult<T>> resultHandler)

io.vertx.core.impl.ContextInternal.executeBlockingInternal(Handler<Promise<T>> action, boolean ordered, Handler<AsyncResult<T>> resultHandler)

io.vertx.core.impl.ContextInternal.getLocal(Object
the key of the data
key)

io.vertx.core.impl.ContextInternal.putLocal(Object
the key of the data
key, Object
the data
value)

io.vertx.core.impl.ContextInternal.removeLocal(Object
the key to remove
key)

io.vertx.core.impl.VertxInternal.executeBlockingInternal(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)

io.vertx.core.impl.VertxInternal.executeBlockingInternal(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)

io.vertx.core.impl.launcher.VertxCommandLauncher.register(Class<? extends Command> clazz)

Returns:

Get default interface to use since the user hasn't specified one.
io.vertx.core.impl.launcher.commands.BareCommand.getDefaultAddress()

as of 4.0, this method is no longer used.

io.vertx.core.impl.launcher.commands.RunCommand.setOnRedeployCommandOld(String
the on redeploy command
command)

Use 'on-redeploy' instead. It will be removed in vert.x 3.3

Returns:

the ObjectMapper used for data binding configured for indenting output.
io.vertx.core.json.jackson.DatabindCodec.prettyMapper()

as of 4.5.2, use ObjectMapper#writerWithDefaultPrettyPrinter() instead

io.vertx.core.logging.Logger

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger(final LogDelegate delegate)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.debug(final Object message)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.debug(final Object message, final Throwable t)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.debug(final Object message, final Object... objects)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.debug(final Object message, final Throwable t, final Object... objects)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.error(final Object message)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.error(final Object message, final Throwable t)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.error(final Object message, final Object... objects)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.error(final Object message, final Throwable t, final Object... objects)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.fatal(final Object message)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.fatal(final Object message, final Throwable t)

see https://github.com/eclipse-vertx/vert.x/issues/2774

Returns:

the delegate instance sending operations to the underlying logging framework
io.vertx.core.logging.Logger.getDelegate()

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.info(final Object message)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.info(final Object message, final Throwable t)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.info(final Object message, final Object... objects)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.info(final Object message, final Throwable t, final Object... objects)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.isDebugEnabled()

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.isInfoEnabled()

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.isTraceEnabled()

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.isWarnEnabled()

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.trace(final Object message)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.trace(final Object message, final Throwable t)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.trace(final Object message, final Object... objects)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.trace(final Object message, final Throwable t, final Object... objects)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.warn(final Object message)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.warn(final Object message, final Throwable t)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.warn(final Object message, final Object... objects)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.Logger.warn(final Object message, final Throwable t, final Object... objects)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.LoggerFactory

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.LoggerFactory.getLogger(final Class<?> clazz)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.LoggerFactory.getLogger(final String name)

see https://github.com/eclipse-vertx/vert.x/issues/2774

io.vertx.core.logging.LoggerFactory.removeLogger(String name)

see https://github.com/eclipse-vertx/vert.x/issues/2774

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.metrics.MetricsOptions.setFactory(VertxMetricsFactory
the metrics factory
factory)

instead use io.vertx.core.VertxBuilder#withMetrics(VertxMetricsFactory)

io.vertx.core.net.ClientOptionsBase.setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)

io.vertx.core.net.ClientOptionsBase.setKeyStoreOptions(JksOptions
the key store in jks format
options)

io.vertx.core.net.ClientOptionsBase.setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)

io.vertx.core.net.ClientOptionsBase.setPemKeyCertOptions(PemKeyCertOptions
the options in pem format
options)

io.vertx.core.net.ClientOptionsBase.setPemTrustOptions(PemTrustOptions
the trust options in pem format
options)

io.vertx.core.net.ClientOptionsBase.setPfxKeyCertOptions(PfxOptions
the key cert options in pfx format
options)

io.vertx.core.net.ClientOptionsBase.setPfxTrustOptions(PfxOptions
the trust options in pfx format
options)

io.vertx.core.net.ClientOptionsBase.setTrustStoreOptions(JksOptions
the trust options in jks format
options)

io.vertx.core.net.KeyCertOptions.keyManagerMapper(Vertx vertx)

instead use keyManagerFactoryMapper(Vertx)

io.vertx.core.net.NetClientOptions.setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)

io.vertx.core.net.NetClientOptions.setKeyStoreOptions(JksOptions
the key store in jks format
options)

io.vertx.core.net.NetClientOptions.setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)

io.vertx.core.net.NetClientOptions.setPemKeyCertOptions(PemKeyCertOptions
the options in pem format
options)

io.vertx.core.net.NetClientOptions.setPemTrustOptions(PemTrustOptions
the trust options in pem format
options)

io.vertx.core.net.NetClientOptions.setPfxKeyCertOptions(PfxOptions
the key cert options in pfx format
options)

io.vertx.core.net.NetClientOptions.setPfxTrustOptions(PfxOptions
the trust options in pfx format
options)

io.vertx.core.net.NetClientOptions.setTrustStoreOptions(JksOptions
the trust options in jks format
options)

Returns:

the connect stream
io.vertx.core.net.NetServer.connectStream()

instead use connectHandler(Handler)

io.vertx.core.net.NetServerOptions.setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)

io.vertx.core.net.NetServerOptions.setKeyStoreOptions(JksOptions
the key store in jks format
options)

io.vertx.core.net.NetServerOptions.setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)

io.vertx.core.net.NetServerOptions.setPemKeyCertOptions(PemKeyCertOptions
the options in pem format
options)

io.vertx.core.net.NetServerOptions.setPemTrustOptions(PemTrustOptions
the trust options in pem format
options)

io.vertx.core.net.NetServerOptions.setPfxKeyCertOptions(PfxOptions
the key cert options in pfx format
options)

io.vertx.core.net.NetServerOptions.setPfxTrustOptions(PfxOptions
the trust options in pfx format
options)

io.vertx.core.net.NetServerOptions.setTrustStoreOptions(JksOptions
the trust options in jks format
options)

Returns:

an ordered array of the peer certificates. Returns null if connection is not SSL.
io.vertx.core.net.NetSocket.peerCertificateChain()

instead use peerCertificates() or sslSession()

io.vertx.core.net.TCPSSLOptions.getJdkSslEngineOptions()

instead use getSslEngineOptions()

Returns:

the key/cert options in jks format, aka Java keystore.
io.vertx.core.net.TCPSSLOptions.getKeyStoreOptions()

instead use getKeyCertOptions()

io.vertx.core.net.TCPSSLOptions.getOpenSslEngineOptions()

instead use getSslEngineOptions()

Returns:

the key/cert store options in pem format.
io.vertx.core.net.TCPSSLOptions.getPemKeyCertOptions()

instead use getKeyCertOptions()

Returns:

the trust options in pem format
io.vertx.core.net.TCPSSLOptions.getPemTrustOptions()

instead use getTrustOptions()

Returns:

the key/cert options in pfx format.
io.vertx.core.net.TCPSSLOptions.getPfxKeyCertOptions()

instead use getKeyCertOptions()

Returns:

the trust options in pfx format
io.vertx.core.net.TCPSSLOptions.getPfxTrustOptions()

instead use getTrustOptions()

Returns:

the trust options in jks format, aka Java truststore
io.vertx.core.net.TCPSSLOptions.getTrustStoreOptions()

instead use getTrustOptions()

io.vertx.core.net.TCPSSLOptions.setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)

instead use setSslEngineOptions(SSLEngineOptions)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.net.TCPSSLOptions.setKeyStoreOptions(JksOptions
the key store in jks format
options)

instead use setKeyCertOptions(KeyCertOptions)

io.vertx.core.net.TCPSSLOptions.setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)

instead use setSslEngineOptions(SSLEngineOptions)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.net.TCPSSLOptions.setPemKeyCertOptions(PemKeyCertOptions
the options in pem format
options)

instead use setKeyCertOptions(KeyCertOptions)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.net.TCPSSLOptions.setPemTrustOptions(PemTrustOptions
the trust options in pem format
options)

instead use setTrustOptions(TrustOptions)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.net.TCPSSLOptions.setPfxKeyCertOptions(PfxOptions
the key cert options in pfx format
options)

instead use setKeyCertOptions(KeyCertOptions)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.net.TCPSSLOptions.setPfxTrustOptions(PfxOptions
the trust options in pfx format
options)

instead use setTrustOptions(TrustOptions)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.net.TCPSSLOptions.setTrustStoreOptions(JksOptions
the trust options in jks format
options)

instead use setTrustOptions(TrustOptions)

io.vertx.core.shareddata.impl.ClusterSerializable

as of 4.3, use io.vertx.core.shareddata.ClusterSerializable instead

io.vertx.core.spi.launcher.DefaultCommandFactory(Class<C>
the Command implementation
clazz)

Please use DefaultCommandFactory(Class, Supplier)

io.vertx.core.streams.Pump

instead use ReadStream#pipe() or ReadStream#pipeTo(WriteStream)

Returns:

a reference to this, so the API can be used fluently
io.vertx.core.tracing.TracingOptions.setFactory(VertxTracerFactory
the tracer factory
factory)

instead use io.vertx.core.VertxBuilder#withTracer(VertxTracerFactory)