Deprecated API

Contents

• Deprecated Interfaces
• Deprecated Classes
• Deprecated Enums
• Deprecated Exceptions
• Deprecated Fields
• Deprecated Methods
• Deprecated Constructors

Deprecated Interfaces

Interface and Description
io.vertx.ext.auth.oauth2.AccessToken
io.vertx.ext.auth.AuthOptions do not use this interface to create a provider, use the provider specific factory.
io.vertx.ext.web.Cookie use instead Cookie, this class will be removed in Vert.x 4
io.vertx.ext.web.handler.CookieHandler cookies are enabled by default and this handler is not required anymore
io.vertx.ext.web.templ.FreeMarkerTemplateEngine please use FreeMarkerTemplateEngine instead.
io.vertx.ext.web.templ.HandlebarsTemplateEngine please use HandlebarsTemplateEngine instead.
io.vertx.ext.web.templ.JadeTemplateEngine please use JadeTemplateEngine instead.
io.vertx.ext.auth.jdbc.JDBCHashStrategy
io.vertx.ext.auth.oauth2.KeycloakHelper
io.vertx.ext.web.Locale Use LanguageHeader instead
io.vertx.ext.web.templ.MVELTemplateEngine Please use MVELTemplateEngine instead.
io.vertx.ext.web.templ.PebbleTemplateEngine please use PebbleTemplateEngine instead.
io.vertx.redis.RedisClient
io.vertx.redis.sentinel.RedisSentinel
io.vertx.redis.RedisTransaction
io.vertx.ext.web.templ.RockerTemplateEngine please use RockerTemplateEngine instead.
io.vertx.redis.Script
io.vertx.ext.auth.shiro.ShiroAuth
io.vertx.ext.web.templ.TemplateEngine
io.vertx.ext.web.templ.ThymeleafTemplateEngine please use ThymeleafTemplateEngine instead.
io.vertx.ext.web.handler.UserSessionHandler the Session Handler also manages the user session.

Deprecated Classes

Class and Description
io.vertx.ext.auth.AbstractUser in 4.0 this class will not be used
io.vertx.redis.op.BitFieldGetCommand Use Redis
io.vertx.redis.op.BitFieldIncrbyCommand Use Redis
io.vertx.redis.op.BitFieldOptions Use Redis
io.vertx.redis.op.BitFieldSetCommand Use Redis
io.vertx.ext.web.handler.sockjs.BridgeOptions
io.vertx.core.http.CaseInsensitiveHeaders instead use MultiMap.caseInsensitiveMultiMap()
io.vertx.redis.op.GeoMember Use Redis
io.vertx.redis.op.GeoRadiusOptions Use Redis
io.vertx.ext.auth.jdbc.JDBCAuthOptions
io.vertx.ext.auth.jwt.JWTKeyStoreOptions Keystores are very opinionated and do not properly represent a correct key, please use PEM files or JWKs
io.vertx.ext.auth.jwt.JWTOptions In 4.0.0 this module will be merged with vertx-auth-common, for this reason this class should be found in the common module, instead of here. Changing the import should fix any deprecations.
io.vertx.ext.auth.KeyStoreOptions Keystores are very opinionated and do not properly represent a correct key, please use PEM files or JWKs
io.vertx.redis.op.KillFilter Use Redis
io.vertx.redis.op.LimitOptions Use Redis
io.vertx.redis.op.MigrateOptions Use Redis
io.vertx.ext.web.handler.sockjs.PermittedOptions
io.vertx.serviceproxy.ProxyHelper for a more robust proxy creation see: ServiceBinder and ServiceProxyBuilder
io.vertx.redis.op.RangeLimitOptions Use Redis
io.vertx.redis.RedisOptions Use RedisOptions with the new client API. This object controls the connection setting to the Redis Server. There is no need to specify most of the settings since it has built the following sensible defaults: * `encoding`: `UTF-8` * `host`: `localhost` * `port`: 6379 * `tcpKeepAlive`: true * `tcpNoDelay`: true * `binary`: false However there are two extra properties that have no defaults since they are optional: * `auth` * `select` The usage of this two extra properties is to setup required authentication and optionally the selection of the active database at connection time. If you define this extra properties on every connection to Redis server this client will perform the authentication handshake and database selection, however if you don't do this and call RedisClient.auth(String, Handler) yourself in case of connection failure the client will not be able to perform the correct authentication handshake.
io.vertx.redis.op.ScanOptions Use Redis
io.vertx.ext.auth.SecretOptions
io.vertx.serviceproxy.generator.ServiceProxyProcessor use the CodeGenProcessor instead
io.vertx.redis.op.SetOptions Use Redis
io.vertx.redis.op.SortOptions Use Redis
io.vertx.core.Starter Use Launcher instead

Deprecated Enums

Enum and Description
io.vertx.redis.op.AggregateOptions Use Redis
io.vertx.redis.op.BitFieldOverflowOptions Use Redis
io.vertx.redis.op.BitOperation Use Redis
io.vertx.redis.op.ClientReplyOptions Use Redis
io.vertx.redis.op.FailoverOptions Use Redis
io.vertx.redis.op.GeoUnit Use Redis
io.vertx.redis.op.InsertOptions Use Redis
io.vertx.redis.op.ObjectCmd Use Redis
io.vertx.redis.op.RangeOptions Use Redis
io.vertx.redis.op.ResetOptions Use Redis
io.vertx.redis.op.ScriptDebugOptions Use Redis
io.vertx.redis.op.ShutdownOptions Use Redis
io.vertx.redis.op.SlotCmd Use Redis

Deprecated Exceptions

Exceptions and Description
io.vertx.redis.client.RedisException
io.vertx.core.http.WebsocketRejectedException instead use UpgradeRejectedException

Deprecated Fields

Field and Description
io.vertx.core.VertxOptions.DEFAULT_CLUSTER_HOST as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_HOST instead
io.vertx.core.VertxOptions.DEFAULT_CLUSTER_PING_INTERVAL as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_PING_INTERVAL instead
io.vertx.core.VertxOptions.DEFAULT_CLUSTER_PING_REPLY_INTERVAL as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_PING_REPLY_INTERVAL instead
io.vertx.core.VertxOptions.DEFAULT_CLUSTER_PORT as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_PORT instead
io.vertx.core.VertxOptions.DEFAULT_CLUSTER_PUBLIC_HOST as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_PUBLIC_HOST instead
io.vertx.core.VertxOptions.DEFAULT_CLUSTER_PUBLIC_PORT as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_PUBLIC_PORT instead
io.vertx.core.VertxOptions.DEFAULT_CLUSTERED as of 3.7, use EventBusOptions.DEFAULT_CLUSTERED instead
io.vertx.mqtt.MqttClientOptions.DEFAULT_KEEP_ALIVE_TIME_SECONDS use MqttClientOptions.DEFAULT_KEEP_ALIVE_INTERVAL
io.vertx.ext.web.api.contract.RouterFactoryOptions.DEFAULT_MOUNT_VALIDATION_FAILURE_HANDLER Router Factory won't manage the validation errors anymore. You must use Router.errorHandler(int, Handler) with 400 error
io.vertx.ext.web.templ.mvel.MVELTemplateEngine.DEFAULT_TEMPLATE_EXTENSION
io.vertx.ext.web.templ.pebble.PebbleTemplateEngine.DEFAULT_TEMPLATE_EXTENSION
io.vertx.ext.web.templ.freemarker.FreeMarkerTemplateEngine.DEFAULT_TEMPLATE_EXTENSION
io.vertx.ext.web.templ.handlebars.HandlebarsTemplateEngine.DEFAULT_TEMPLATE_EXTENSION
io.vertx.ext.web.templ.jade.JadeTemplateEngine.DEFAULT_TEMPLATE_EXTENSION
io.vertx.ext.web.templ.rocker.RockerTemplateEngine.DEFAULT_TEMPLATE_EXTENSION
io.vertx.ext.web.common.template.CachingTemplateEngine.extension
io.vertx.core.json.Json.mapper instead use DatabindCodec.mapper()
io.vertx.core.json.Json.prettyMapper instead use DatabindCodec.prettyMapper()
io.vertx.maven.resolver.ResolverImpl.REMOTE_SNAPSHOT_POLICY_SYS_PROP use ResolverOptions.REMOTE_SNAPSHOT_POLICY_SYS_PROP instead.

Deprecated Methods

Method and Description
io.vertx.ext.web.Router.accept(HttpServerRequest)
io.vertx.rxjava.ext.web.Router.accept(HttpServerRequest)
io.vertx.reactivex.ext.web.Router.accept(HttpServerRequest)
io.vertx.ext.web.RoutingContext.acceptableLocales() Use RoutingContext.acceptableLanguages() or RoutingContext.parsedHeaders().ParsedHeaderValues.acceptLanguage()
io.vertx.rxjava.ext.web.RoutingContext.acceptableLocales()
io.vertx.reactivex.ext.web.RoutingContext.acceptableLocales()
io.vertx.rxjava.core.shareddata.Counter.addAndGetObservable(long) use Counter.rxAddAndGet(long) instead
io.vertx.sqlclient.Tuple.addBigDecimalArray(BigDecimal[]) instead use Tuple.addArrayOfBigDecimal(BigDecimal[])
io.vertx.rxjava.sqlclient.Tuple.addBigDecimalArray(BigDecimal[])
io.vertx.reactivex.sqlclient.Tuple.addBigDecimalArray(BigDecimal[])
io.vertx.sqlclient.Tuple.addBooleanArray(Boolean[]) instead use Tuple.addArrayOfBoolean(Boolean[])
io.vertx.rxjava.sqlclient.Tuple.addBooleanArray(Boolean[])
io.vertx.reactivex.sqlclient.Tuple.addBooleanArray(Boolean[])
io.vertx.sqlclient.Tuple.addBufferArray(Buffer[]) instead use Tuple.addArrayOfBuffer(Buffer[])
io.vertx.ext.web.RoutingContext.addCookie(Cookie) instead use RoutingContext.addCookie(io.vertx.core.http.Cookie)
io.vertx.sqlclient.Tuple.addDoubleArray(Double[]) instead use Tuple.addArrayOfDouble(Double[])
io.vertx.rxjava.sqlclient.Tuple.addDoubleArray(Double[])
io.vertx.reactivex.sqlclient.Tuple.addDoubleArray(Double[])
io.vertx.redis.client.RedisOptions.addEndpoint(String) see RedisOptions.setConnectionString(String connectionString) for a better naming
io.vertx.sqlclient.Tuple.addFloatArray(Float[]) instead use Tuple.addArrayOfFloat(Float[])
io.vertx.rxjava.sqlclient.Tuple.addFloatArray(Float[])
io.vertx.reactivex.sqlclient.Tuple.addFloatArray(Float[])
io.vertx.sqlclient.Tuple.addIntegerArray(Integer[]) instead use Tuple.addArrayOfInteger(Integer[])
io.vertx.rxjava.sqlclient.Tuple.addIntegerArray(Integer[])
io.vertx.reactivex.sqlclient.Tuple.addIntegerArray(Integer[])
io.vertx.sqlclient.Tuple.addLocalDateArray(LocalDate[]) instead use Tuple.addArrayOfLocalDate(LocalDate[])
io.vertx.rxjava.sqlclient.Tuple.addLocalDateArray(LocalDate[])
io.vertx.reactivex.sqlclient.Tuple.addLocalDateArray(LocalDate[])
io.vertx.sqlclient.Tuple.addLocalDateTimeArray(LocalDateTime[]) instead use Tuple.addArrayOfLocalDateTime(LocalDateTime[])
io.vertx.rxjava.sqlclient.Tuple.addLocalDateTimeArray(LocalDateTime[])
io.vertx.reactivex.sqlclient.Tuple.addLocalDateTimeArray(LocalDateTime[])
io.vertx.sqlclient.Tuple.addLocalTimeArray(LocalTime[]) instead use Tuple.addArrayOfLocalTime(LocalTime[])
io.vertx.rxjava.sqlclient.Tuple.addLocalTimeArray(LocalTime[])
io.vertx.reactivex.sqlclient.Tuple.addLocalTimeArray(LocalTime[])
io.vertx.sqlclient.Tuple.addLongArray(Long[]) instead use Tuple.addArrayOfLong(Long[])
io.vertx.rxjava.sqlclient.Tuple.addLongArray(Long[])
io.vertx.reactivex.sqlclient.Tuple.addLongArray(Long[])
io.vertx.sqlclient.Tuple.addOffsetDateTimeArray(OffsetDateTime[]) instead use Tuple.addArrayOfOffsetDateTime(OffsetDateTime[])
io.vertx.rxjava.sqlclient.Tuple.addOffsetDateTimeArray(OffsetDateTime[])
io.vertx.reactivex.sqlclient.Tuple.addOffsetDateTimeArray(OffsetDateTime[])
io.vertx.sqlclient.Tuple.addOffsetTimeArray(OffsetTime[]) instead use Tuple.addArrayOfOffsetTime(OffsetTime[])
io.vertx.rxjava.sqlclient.Tuple.addOffsetTimeArray(OffsetTime[])
io.vertx.reactivex.sqlclient.Tuple.addOffsetTimeArray(OffsetTime[])
io.vertx.ext.auth.jwt.JWTAuthOptions.addSecret(SecretOptions)
io.vertx.sqlclient.Tuple.addShortArray(Short[]) instead use Tuple.addArrayOfShort(Short[])
io.vertx.rxjava.sqlclient.Tuple.addShortArray(Short[])
io.vertx.reactivex.sqlclient.Tuple.addShortArray(Short[])
io.vertx.sqlclient.Tuple.addStringArray(String[]) instead use Tuple.addArrayOfString(String[])
io.vertx.rxjava.sqlclient.Tuple.addStringArray(String[])
io.vertx.reactivex.sqlclient.Tuple.addStringArray(String[])
io.vertx.sqlclient.Tuple.addTemporalArray(Temporal[]) instead use Tuple.addArrayOfTemporal(Temporal[])
io.vertx.rxjava.sqlclient.Tuple.addTemporalArray(Temporal[])
io.vertx.reactivex.sqlclient.Tuple.addTemporalArray(Temporal[])
io.vertx.sqlclient.Tuple.addUUIDArray(UUID[]) instead use Tuple.addArrayOfUUID(UUID[])
io.vertx.rxjava.sqlclient.Tuple.addUUIDArray(UUID[])
io.vertx.reactivex.sqlclient.Tuple.addUUIDArray(UUID[])
io.vertx.ext.web.common.template.CachingTemplateEngine.adjustLocation(String)
io.vertx.rxjava.redis.RedisTransaction.appendObservable(String, String) use RedisTransaction.rxAppend(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.appendObservable(String, String) use RedisClient.rxAppend(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.appendObservable(String, String) use RedisAPI.rxAppend(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.askingObservable() use RedisAPI.rxAsking() instead
io.vertx.rxjava.ext.auth.AuthProvider.authenticateObservable(JsonObject) use AuthProvider.rxAuthenticate(io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.redis.RedisTransaction.authObservable(String) use RedisTransaction.rxAuth(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.authObservable(String) use RedisClient.rxAuth(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.authObservable(String) use RedisAPI.rxAuth(java.lang.String) instead
io.vertx.rxjava.ext.web.handler.BasicAuthHandler.authorizeObservable(User) use BasicAuthHandler.rxAuthorize(io.vertx.rxjava.ext.auth.User) instead
io.vertx.rxjava.ext.web.handler.DigestAuthHandler.authorizeObservable(User) use DigestAuthHandler.rxAuthorize(io.vertx.rxjava.ext.auth.User) instead
io.vertx.rxjava.ext.web.handler.JWTAuthHandler.authorizeObservable(User) use JWTAuthHandler.rxAuthorize(io.vertx.rxjava.ext.auth.User) instead
io.vertx.rxjava.ext.web.handler.RedirectAuthHandler.authorizeObservable(User) use RedirectAuthHandler.rxAuthorize(io.vertx.rxjava.ext.auth.User) instead
io.vertx.rxjava.ext.web.handler.ChainAuthHandler.authorizeObservable(User) use ChainAuthHandler.rxAuthorize(io.vertx.rxjava.ext.auth.User) instead
io.vertx.rxjava.ext.web.handler.OAuth2AuthHandler.authorizeObservable(User) use OAuth2AuthHandler.rxAuthorize(io.vertx.rxjava.ext.auth.User) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicAckObservable(long, boolean) use RabbitMQClient.rxBasicAck(long, boolean) instead
io.vertx.rabbitmq.RabbitMQClient.basicCancel(String)
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicCancel(String)
io.vertx.reactivex.rabbitmq.RabbitMQClient.basicCancel(String)
io.vertx.rabbitmq.RabbitMQClient.basicCancel(String, Handler<AsyncResult<Void>>)
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicCancel(String, Handler<AsyncResult<Void>>)
io.vertx.reactivex.rabbitmq.RabbitMQClient.basicCancel(String, Handler<AsyncResult<Void>>)
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicCancelObservable(String) use RabbitMQClient.rxBasicCancel(java.lang.String) instead
io.vertx.rabbitmq.RabbitMQClient.basicConsume(String, String, boolean, Handler<AsyncResult<String>>)
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicConsume(String, String, boolean, Handler<AsyncResult<String>>)
io.vertx.reactivex.rabbitmq.RabbitMQClient.basicConsume(String, String, boolean, Handler<AsyncResult<String>>)
io.vertx.rabbitmq.RabbitMQClient.basicConsume(String, String, boolean, Handler<AsyncResult<String>>, Handler<Throwable>)
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicConsume(String, String, boolean, Handler<AsyncResult<String>>, Handler<Throwable>)
io.vertx.reactivex.rabbitmq.RabbitMQClient.basicConsume(String, String, boolean, Handler<AsyncResult<String>>, Handler<Throwable>)
io.vertx.rabbitmq.RabbitMQClient.basicConsume(String, String, Handler<AsyncResult<String>>)
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicConsume(String, String, Handler<AsyncResult<String>>)
io.vertx.reactivex.rabbitmq.RabbitMQClient.basicConsume(String, String, Handler<AsyncResult<String>>)
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicConsumeObservable(String, String) use RabbitMQClient.rxBasicConsume(java.lang.String, java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicConsumeObservable(String, String, boolean) use RabbitMQClient.rxBasicConsume(java.lang.String, java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicConsumerObservable(String) use RabbitMQClient.rxBasicConsumer(java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicConsumerObservable(String, QueueOptions) use RabbitMQClient.rxBasicConsumer(java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicGetObservable(String, boolean) use RabbitMQClient.rxBasicGet(java.lang.String, boolean) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicNackObservable(long, boolean, boolean) use RabbitMQClient.rxBasicNack(long, boolean, boolean) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicPublishObservable(String, String, JsonObject) use RabbitMQClient.rxBasicPublish(java.lang.String, java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicQosObservable(int) use RabbitMQClient.rxBasicQos(int) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicQosObservable(int, boolean) use RabbitMQClient.rxBasicQos(int) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.basicQosObservable(int, int, boolean) use RabbitMQClient.rxBasicQos(int) instead
io.vertx.rxjava.ext.sql.SQLConnection.batchCallableWithParamsObservable(String, List<JsonArray>, List<JsonArray>) use SQLConnection.rxBatchCallableWithParams(java.lang.String, java.util.List<io.vertx.core.json.JsonArray>, java.util.List<io.vertx.core.json.JsonArray>) instead
io.vertx.rxjava.redis.client.Redis.batchObservable(List<Request>) use Redis.rxBatch(java.util.List<io.vertx.rxjava.redis.client.Request>) instead
io.vertx.rxjava.redis.client.RedisConnection.batchObservable(List<Request>) use RedisConnection.rxBatch(java.util.List<io.vertx.rxjava.redis.client.Request>) instead
io.vertx.rxjava.ext.sql.SQLConnection.batchObservable(List<String>) use SQLConnection.rxBatch(java.util.List<java.lang.String>) instead
io.vertx.rxjava.ext.sql.SQLConnection.batchWithParamsObservable(String, List<JsonArray>) use SQLConnection.rxBatchWithParams(java.lang.String, java.util.List<io.vertx.core.json.JsonArray>) instead
io.vertx.rxjava.redis.RedisTransaction.bgrewriteaofObservable() use RedisTransaction.rxBgrewriteaof() instead
io.vertx.rxjava.redis.RedisClient.bgrewriteaofObservable() use RedisClient.rxBgrewriteaof() instead
io.vertx.rxjava.redis.client.RedisAPI.bgrewriteaofObservable() use RedisAPI.rxBgrewriteaof() instead
io.vertx.rxjava.redis.RedisTransaction.bgsaveObservable() use RedisTransaction.rxBgsave() instead
io.vertx.rxjava.redis.RedisClient.bgsaveObservable() use RedisClient.rxBgsave() instead
io.vertx.rxjava.redis.client.RedisAPI.bgsaveObservable(List<String>) use RedisAPI.rxBgsave(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.bitcountObservable(List<String>) use RedisAPI.rxBitcount(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.bitcountObservable(String) use RedisTransaction.rxBitcount(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.bitcountObservable(String) use RedisClient.rxBitcount(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.bitcountRangeObservable(String, long, long) use RedisTransaction.rxBitcountRange(java.lang.String, long, long) instead
io.vertx.rxjava.redis.RedisClient.bitcountRangeObservable(String, long, long) use RedisClient.rxBitcountRange(java.lang.String, long, long) instead
io.vertx.rxjava.redis.client.RedisAPI.bitfieldObservable(List<String>) use RedisAPI.rxBitfield(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.bitfieldObservable(String, BitFieldOptions) use RedisClient.rxBitfield(java.lang.String, io.vertx.redis.op.BitFieldOptions) instead
io.vertx.rxjava.redis.RedisClient.bitfieldWithOverflowObservable(String, BitFieldOptions, BitFieldOverflowOptions) use RedisClient.rxBitfieldWithOverflow(java.lang.String, io.vertx.redis.op.BitFieldOptions, io.vertx.redis.op.BitFieldOverflowOptions) instead
io.vertx.rxjava.redis.RedisTransaction.bitopObservable(BitOperation, String, List<String>) use RedisTransaction.rxBitop(io.vertx.redis.op.BitOperation, java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.bitopObservable(BitOperation, String, List<String>) use RedisClient.rxBitop(io.vertx.redis.op.BitOperation, java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.bitopObservable(List<String>) use RedisAPI.rxBitop(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.bitposFromObservable(String, int, int) use RedisTransaction.rxBitposFrom(java.lang.String, int, int) instead
io.vertx.rxjava.redis.RedisClient.bitposFromObservable(String, int, int) use RedisClient.rxBitposFrom(java.lang.String, int, int) instead
io.vertx.rxjava.redis.client.RedisAPI.bitposObservable(List<String>) use RedisAPI.rxBitpos(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.bitposObservable(String, int) use RedisTransaction.rxBitpos(java.lang.String, int) instead
io.vertx.rxjava.redis.RedisClient.bitposObservable(String, int) use RedisClient.rxBitpos(java.lang.String, int) instead
io.vertx.rxjava.redis.RedisTransaction.bitposRangeObservable(String, int, int, int) use RedisTransaction.rxBitposRange(java.lang.String, int, int, int) instead
io.vertx.rxjava.redis.RedisClient.bitposRangeObservable(String, int, int, int) use RedisClient.rxBitposRange(java.lang.String, int, int, int) instead
io.vertx.rxjava.core.datagram.DatagramSocket.blockMulticastGroupObservable(String, String) use DatagramSocket.rxBlockMulticastGroup(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.datagram.DatagramSocket.blockMulticastGroupObservable(String, String, String) use DatagramSocket.rxBlockMulticastGroup(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.blpopManyObservable(List<String>, int) use RedisTransaction.rxBlpopMany(java.util.List<java.lang.String>, int) instead
io.vertx.rxjava.redis.RedisClient.blpopManyObservable(List<String>, int) use RedisClient.rxBlpopMany(java.util.List<java.lang.String>, int) instead
io.vertx.rxjava.redis.client.RedisAPI.blpopObservable(List<String>) use RedisAPI.rxBlpop(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.blpopObservable(String, int) use RedisTransaction.rxBlpop(java.lang.String, int) instead
io.vertx.rxjava.redis.RedisClient.blpopObservable(String, int) use RedisClient.rxBlpop(java.lang.String, int) instead
io.vertx.ext.web.handler.sockjs.SockJSHandler.bridge(BridgeOptions)
io.vertx.ext.web.handler.sockjs.SockJSHandler.bridge(BridgeOptions, Handler<BridgeEvent>)
io.vertx.rxjava.redis.RedisTransaction.brpoplpushObservable(String, String, int) use RedisTransaction.rxBrpoplpush(java.lang.String, java.lang.String, int) instead
io.vertx.rxjava.redis.RedisClient.brpoplpushObservable(String, String, int) use RedisClient.rxBrpoplpush(java.lang.String, java.lang.String, int) instead
io.vertx.rxjava.redis.client.RedisAPI.brpoplpushObservable(String, String, String) use RedisAPI.rxBrpoplpush(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.brpopManyObservable(List<String>, int) use RedisTransaction.rxBrpopMany(java.util.List<java.lang.String>, int) instead
io.vertx.rxjava.redis.RedisClient.brpopManyObservable(List<String>, int) use RedisClient.rxBrpopMany(java.util.List<java.lang.String>, int) instead
io.vertx.rxjava.redis.client.RedisAPI.brpopObservable(List<String>) use RedisAPI.rxBrpop(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.brpopObservable(String, int) use RedisTransaction.rxBrpop(java.lang.String, int) instead
io.vertx.rxjava.redis.RedisClient.brpopObservable(String, int) use RedisClient.rxBrpop(java.lang.String, int) instead
io.vertx.rxjava.ext.mongo.MongoClient.bulkWriteObservable(String, List<BulkOperation>) use MongoClient.rxBulkWrite(java.lang.String, java.util.List<io.vertx.ext.mongo.BulkOperation>) instead
io.vertx.rxjava.ext.mongo.MongoService.bulkWriteObservable(String, List<BulkOperation>)
io.vertx.rxjava.ext.mongo.MongoClient.bulkWriteWithOptionsObservable(String, List<BulkOperation>, BulkWriteOptions) use MongoClient.rxBulkWriteWithOptions(java.lang.String, java.util.List<io.vertx.ext.mongo.BulkOperation>, io.vertx.ext.mongo.BulkWriteOptions) instead
io.vertx.rxjava.ext.mongo.MongoService.bulkWriteWithOptionsObservable(String, List<BulkOperation>, BulkWriteOptions)
io.vertx.rxjava.redis.client.RedisAPI.bzpopmaxObservable(List<String>) use RedisAPI.rxBzpopmax(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.bzpopminObservable(List<String>) use RedisAPI.rxBzpopmin(java.util.List<java.lang.String>) instead
io.vertx.rxjava.ext.sql.SQLConnection.callObservable(String) use SQLConnection.rxCall(java.lang.String) instead
io.vertx.rxjava.ext.sql.SQLClient.callObservable(String) use SQLClient.rxCall(java.lang.String) instead
io.vertx.rxjava.ext.sql.SQLConnection.callWithParamsObservable(String, JsonArray, JsonArray) use SQLConnection.rxCallWithParams(java.lang.String, io.vertx.core.json.JsonArray, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.sql.SQLClient.callWithParamsObservable(String, JsonArray, JsonArray) use SQLClient.rxCallWithParams(java.lang.String, io.vertx.core.json.JsonArray, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.rabbitmq.RabbitMQConsumer.cancelObservable() use RabbitMQConsumer.rxCancel() instead
io.vertx.kafka.client.producer.RecordMetadata.checksum() As of Kafka 0.11.0. Because of the potential for message format conversion on the broker, the checksum returned by the broker may not match what was computed by the producer. It is therefore unsafe to depend on this checksum for end-to-end delivery guarantees. Additionally, message format v2 does not include a record-level checksum (for performance, the record checksum was replaced with a batch checksum). To maintain compatibility, a partial checksum computed from the record timestamp, serialized key size, and serialized value size is returned instead, but this should not be depended on for end-to-end reliability.
io.vertx.kafka.client.consumer.KafkaConsumerRecord.checksum() As of Kafka 0.11.0. Because of the potential for message format conversion on the broker, the checksum returned by the broker may not match what was computed by the producer. It is therefore unsafe to depend on this checksum for end-to-end delivery guarantees. Additionally, message format v2 does not include a record-level checksum (for performance, the record checksum was replaced with a batch checksum). To maintain compatibility, a partial checksum computed from the record timestamp, serialized key size, and serialized value size is returned instead, but this should not be depended on for end-to-end reliability.
io.vertx.rxjava.kafka.client.consumer.KafkaConsumerRecord.checksum()
io.vertx.reactivex.kafka.client.consumer.KafkaConsumerRecord.checksum()
io.vertx.rxjava.core.file.FileSystem.chmodObservable(String, String) use FileSystem.rxChmod(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.chmodRecursiveObservable(String, String, String) use FileSystem.rxChmodRecursive(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.chownObservable(String, String, String) use FileSystem.rxChown(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.sentinel.RedisSentinel.ckquorumObservable(String) use RedisSentinel.rxCkquorum(java.lang.String) instead
io.vertx.ext.auth.User.clearCache()
io.vertx.rxjava.ext.auth.User.clearCache()
io.vertx.reactivex.ext.auth.User.clearCache()
io.vertx.rxjava.core.shareddata.AsyncMap.clearObservable() use AsyncMap.rxClear() instead
io.vertx.rxjava.ext.web.sstore.SessionStore.clearObservable() use SessionStore.rxClear() instead
io.vertx.rxjava.redis.RedisTransaction.clientGetnameObservable() use RedisTransaction.rxClientGetname() instead
io.vertx.rxjava.redis.RedisClient.clientGetnameObservable() use RedisClient.rxClientGetname() instead
io.vertx.rxjava.redis.RedisTransaction.clientKillObservable(KillFilter) use RedisTransaction.rxClientKill(io.vertx.redis.op.KillFilter) instead
io.vertx.rxjava.redis.RedisClient.clientKillObservable(KillFilter) use RedisClient.rxClientKill(io.vertx.redis.op.KillFilter) instead
io.vertx.rxjava.redis.RedisTransaction.clientListObservable() use RedisTransaction.rxClientList() instead
io.vertx.rxjava.redis.RedisClient.clientListObservable() use RedisClient.rxClientList() instead
io.vertx.rxjava.redis.client.RedisAPI.clientObservable(List<String>) use RedisAPI.rxClient(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.clientPauseObservable(long) use RedisTransaction.rxClientPause(long) instead
io.vertx.rxjava.redis.RedisClient.clientPauseObservable(long) use RedisClient.rxClientPause(long) instead
io.vertx.rxjava.redis.RedisClient.clientReplyObservable(ClientReplyOptions) use RedisClient.rxClientReply(io.vertx.redis.op.ClientReplyOptions) instead
io.vertx.rxjava.redis.RedisTransaction.clientSetnameObservable(String) use RedisTransaction.rxClientSetname(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.clientSetnameObservable(String) use RedisClient.rxClientSetname(java.lang.String) instead
io.vertx.core.net.KeyCertOptions.clone() use KeyCertOptions.copy() instead
io.vertx.core.net.TrustOptions.clone() use TrustOptions.copy() instead
io.vertx.core.net.SSLEngineOptions.clone() use SSLEngineOptions.copy() instead
io.vertx.rxjava.amqpbridge.AmqpBridge.closeObservable() use AmqpBridge.rxClose() instead
io.vertx.rxjava.core.eventbus.MessageProducer.closeObservable() use MessageProducer.rxClose() instead
io.vertx.rxjava.core.net.NetSocket.closeObservable() use NetSocket.rxClose() instead
io.vertx.rxjava.core.net.NetServer.closeObservable() use NetServer.rxClose() instead
io.vertx.rxjava.core.file.AsyncFile.closeObservable() use AsyncFile.rxClose() instead
io.vertx.rxjava.core.Vertx.closeObservable() use Vertx.rxClose() instead
io.vertx.rxjava.core.http.ServerWebSocket.closeObservable() use ServerWebSocket.rxClose() instead
io.vertx.rxjava.core.http.HttpServer.closeObservable() use HttpServer.rxClose() instead
io.vertx.rxjava.core.http.WebSocket.closeObservable() use WebSocket.rxClose() instead
io.vertx.rxjava.core.datagram.DatagramSocket.closeObservable() use DatagramSocket.rxClose() instead
io.vertx.rxjava.redis.RedisTransaction.closeObservable() use RedisTransaction.rxClose() instead
io.vertx.rxjava.redis.sentinel.RedisSentinel.closeObservable() use RedisSentinel.rxClose() instead
io.vertx.rxjava.redis.RedisClient.closeObservable() use RedisClient.rxClose() instead
io.vertx.rxjava.ext.shell.term.TermServer.closeObservable() use TermServer.rxClose() instead
io.vertx.rxjava.ext.shell.ShellServer.closeObservable() use ShellServer.rxClose() instead
io.vertx.rxjava.ext.stomp.StompServer.closeObservable() use StompServer.rxClose() instead
io.vertx.rxjava.ext.sql.SQLRowStream.closeObservable() use SQLRowStream.rxClose() instead
io.vertx.rxjava.ext.sql.SQLConnection.closeObservable() use SQLConnection.rxClose() instead
io.vertx.rxjava.ext.sql.SQLClient.closeObservable() use SQLClient.rxClose() instead
io.vertx.rxjava.core.http.ServerWebSocket.closeObservable(short) use ServerWebSocket.rxClose() instead
io.vertx.rxjava.core.http.WebSocket.closeObservable(short) use WebSocket.rxClose() instead
io.vertx.rxjava.core.http.ServerWebSocket.closeObservable(short, String) use ServerWebSocket.rxClose() instead
io.vertx.rxjava.core.http.WebSocket.closeObservable(short, String) use WebSocket.rxClose() instead
io.vertx.rxjava.redis.RedisClient.clusterAddslotsObservable(List<Long>) use RedisClient.rxClusterAddslots(java.util.List<java.lang.Long>) instead
io.vertx.rxjava.redis.RedisTransaction.clusterAddslotsObservable(List<String>) use RedisTransaction.rxClusterAddslots(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.clusterCountFailureReportsObservable(String) use RedisTransaction.rxClusterCountFailureReports(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.clusterCountFailureReportsObservable(String) use RedisClient.rxClusterCountFailureReports(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.clusterCountkeysinslotObservable(long) use RedisTransaction.rxClusterCountkeysinslot(long) instead
io.vertx.rxjava.redis.RedisClient.clusterCountkeysinslotObservable(long) use RedisClient.rxClusterCountkeysinslot(long) instead
io.vertx.rxjava.redis.RedisClient.clusterDelslotsManyObservable(List<Long>) use RedisClient.rxClusterDelslotsMany(java.util.List<java.lang.Long>) instead
io.vertx.rxjava.redis.RedisTransaction.clusterDelslotsManyObservable(List<String>) use RedisTransaction.rxClusterDelslotsMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.clusterDelslotsObservable(long) use RedisTransaction.rxClusterDelslots(long) instead
io.vertx.rxjava.redis.RedisClient.clusterDelslotsObservable(long) use RedisClient.rxClusterDelslots(long) instead
io.vertx.rxjava.core.Vertx.clusteredVertxObservable(VertxOptions) use Vertx.rxClusteredVertx(io.vertx.core.VertxOptions) instead
io.vertx.rxjava.redis.RedisTransaction.clusterFailoverObservable() use RedisTransaction.rxClusterFailover() instead
io.vertx.rxjava.redis.RedisClient.clusterFailoverObservable() use RedisClient.rxClusterFailover() instead
io.vertx.rxjava.redis.RedisTransaction.clusterFailOverWithOptionsObservable(FailoverOptions) use RedisTransaction.rxClusterFailOverWithOptions(io.vertx.redis.op.FailoverOptions) instead
io.vertx.rxjava.redis.RedisClient.clusterFailOverWithOptionsObservable(FailoverOptions) use RedisClient.rxClusterFailOverWithOptions(io.vertx.redis.op.FailoverOptions) instead
io.vertx.rxjava.redis.RedisTransaction.clusterForgetObservable(String) use RedisTransaction.rxClusterForget(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.clusterForgetObservable(String) use RedisClient.rxClusterForget(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.clusterGetkeysinslotObservable(long, long) use RedisTransaction.rxClusterGetkeysinslot(long, long) instead
io.vertx.rxjava.redis.RedisClient.clusterGetkeysinslotObservable(long, long) use RedisClient.rxClusterGetkeysinslot(long, long) instead
io.vertx.rxjava.redis.RedisTransaction.clusterInfoObservable() use RedisTransaction.rxClusterInfo() instead
io.vertx.rxjava.redis.RedisClient.clusterInfoObservable() use RedisClient.rxClusterInfo() instead
io.vertx.rxjava.redis.RedisTransaction.clusterKeyslotObservable(String) use RedisTransaction.rxClusterKeyslot(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.clusterKeyslotObservable(String) use RedisClient.rxClusterKeyslot(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.clusterMeetObservable(String, long) use RedisTransaction.rxClusterMeet(java.lang.String, long) instead
io.vertx.rxjava.redis.RedisClient.clusterMeetObservable(String, long) use RedisClient.rxClusterMeet(java.lang.String, long) instead
io.vertx.rxjava.redis.RedisTransaction.clusterNodesObservable() use RedisTransaction.rxClusterNodes() instead
io.vertx.rxjava.redis.RedisClient.clusterNodesObservable() use RedisClient.rxClusterNodes() instead
io.vertx.rxjava.redis.client.RedisAPI.clusterObservable(List<String>) use RedisAPI.rxCluster(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.clusterReplicateObservable(String) use RedisTransaction.rxClusterReplicate(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.clusterReplicateObservable(String) use RedisClient.rxClusterReplicate(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.clusterResetObservable() use RedisTransaction.rxClusterReset() instead
io.vertx.rxjava.redis.RedisClient.clusterResetObservable() use RedisClient.rxClusterReset() instead
io.vertx.rxjava.redis.RedisTransaction.clusterResetWithOptionsObservable(ResetOptions) use RedisTransaction.rxClusterResetWithOptions(io.vertx.redis.op.ResetOptions) instead
io.vertx.rxjava.redis.RedisClient.clusterResetWithOptionsObservable(ResetOptions) use RedisClient.rxClusterResetWithOptions(io.vertx.redis.op.ResetOptions) instead
io.vertx.rxjava.redis.RedisTransaction.clusterSaveconfigObservable() use RedisTransaction.rxClusterSaveconfig() instead
io.vertx.rxjava.redis.RedisClient.clusterSaveconfigObservable() use RedisClient.rxClusterSaveconfig() instead
io.vertx.rxjava.redis.RedisTransaction.clusterSetConfigEpochObservable(long) use RedisTransaction.rxClusterSetConfigEpoch(long) instead
io.vertx.rxjava.redis.RedisClient.clusterSetConfigEpochObservable(long) use RedisClient.rxClusterSetConfigEpoch(long) instead
io.vertx.rxjava.redis.RedisTransaction.clusterSetslotObservable(long, SlotCmd) use RedisTransaction.rxClusterSetslot(long, io.vertx.redis.op.SlotCmd) instead
io.vertx.rxjava.redis.RedisClient.clusterSetslotObservable(long, SlotCmd) use RedisClient.rxClusterSetslot(long, io.vertx.redis.op.SlotCmd) instead
io.vertx.rxjava.redis.RedisTransaction.clusterSetslotWithNodeObservable(long, SlotCmd, String) use RedisTransaction.rxClusterSetslotWithNode(long, io.vertx.redis.op.SlotCmd, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.clusterSetslotWithNodeObservable(long, SlotCmd, String) use RedisClient.rxClusterSetslotWithNode(long, io.vertx.redis.op.SlotCmd, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.clusterSlavesObservable(String) use RedisTransaction.rxClusterSlaves(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.clusterSlavesObservable(String) use RedisClient.rxClusterSlaves(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.clusterSlotsObservable() use RedisTransaction.rxClusterSlots() instead
io.vertx.rxjava.redis.RedisClient.clusterSlotsObservable() use RedisClient.rxClusterSlots() instead
io.vertx.rxjava.redis.RedisTransaction.commandCountObservable() use RedisTransaction.rxCommandCount() instead
io.vertx.rxjava.redis.RedisClient.commandCountObservable() use RedisClient.rxCommandCount() instead
io.vertx.rxjava.redis.RedisTransaction.commandGetkeysObservable() use RedisTransaction.rxCommandGetkeys() instead
io.vertx.rxjava.redis.RedisClient.commandGetkeysObservable() use RedisClient.rxCommandGetkeys() instead
io.vertx.rxjava.redis.RedisTransaction.commandInfoObservable(List<String>) use RedisTransaction.rxCommandInfo(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.commandInfoObservable(List<String>) use RedisClient.rxCommandInfo(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.commandObservable() use RedisTransaction.rxCommand() instead
io.vertx.rxjava.redis.RedisClient.commandObservable() use RedisClient.rxCommand() instead
io.vertx.rxjava.redis.client.RedisAPI.commandObservable() use RedisAPI.rxCommand() instead
io.vertx.rxjava.ext.sql.SQLConnection.commitObservable() use SQLConnection.rxCommit() instead
io.vertx.rxjava.core.shareddata.Counter.compareAndSetObservable(long, long) use Counter.rxCompareAndSet(long, long) instead
io.vertx.core.Future.complete() instead create a Promise and use Promise.complete()
io.vertx.rxjava.core.Future.complete()
io.vertx.reactivex.core.Future.complete()
io.vertx.rxjava.core.CompositeFuture.complete(CompositeFuture)
io.vertx.reactivex.core.CompositeFuture.complete(CompositeFuture)
io.vertx.core.Future.complete(T) instead create a Promise and use Promise.complete(Object)
io.vertx.rxjava.core.Future.complete(T)
io.vertx.reactivex.core.Future.complete(T)
io.vertx.core.Future.completer() use this object instead since it extends Handler<AsyncResult<T>>
io.vertx.rxjava.core.Future.completer()
io.vertx.rxjava.core.CompositeFuture.completer()
io.vertx.reactivex.core.Future.completer()
io.vertx.reactivex.core.CompositeFuture.completer()
io.vertx.rxjava.core.eventbus.MessageConsumer.completionHandlerObservable() use MessageConsumer.rxCompletionHandler() instead
io.vertx.core.Future.compose(Handler<T>, Future<U>) use Future.compose(Function))} instead
io.vertx.rxjava.redis.RedisTransaction.configGetObservable(String) use RedisTransaction.rxConfigGet(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.configGetObservable(String) use RedisClient.rxConfigGet(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.configObservable(List<String>) use RedisAPI.rxConfig(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.configResetstatObservable() use RedisTransaction.rxConfigResetstat() instead
io.vertx.rxjava.redis.RedisClient.configResetstatObservable() use RedisClient.rxConfigResetstat() instead
io.vertx.rxjava.redis.RedisTransaction.configRewriteObservable() use RedisTransaction.rxConfigRewrite() instead
io.vertx.rxjava.redis.RedisClient.configRewriteObservable() use RedisClient.rxConfigRewrite() instead
io.vertx.rxjava.redis.RedisTransaction.configSetObservable(String, String) use RedisTransaction.rxConfigSet(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.configSetObservable(String, String) use RedisClient.rxConfigSet(java.lang.String, java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.confirmSelectObservable() use RabbitMQClient.rxConfirmSelect() instead
io.vertx.core.http.HttpClientRequest.connectionHandler(Handler<HttpConnection>) instead use HttpClient.connectionHandler(Handler)
io.vertx.rxjava.core.http.HttpClientRequest.connectionHandler(Handler<HttpConnection>)
io.vertx.reactivex.core.http.HttpClientRequest.connectionHandler(Handler<HttpConnection>)
io.vertx.rxjava.redis.client.Redis.connectObservable() use Redis.rxConnect() instead
io.vertx.rxjava.ext.stomp.StompClient.connectObservable() use StompClient.rxConnect(int, java.lang.String) instead
io.vertx.rxjava.core.net.NetClient.connectObservable(int, String) use NetClient.rxConnect(int, java.lang.String) instead
io.vertx.rxjava.ext.stomp.StompClient.connectObservable(int, String) use StompClient.rxConnect(int, java.lang.String) instead
io.vertx.rxjava.ext.stomp.StompClient.connectObservable(int, String, NetClient) use StompClient.rxConnect(int, java.lang.String) instead
io.vertx.rxjava.core.net.NetClient.connectObservable(int, String, String) use NetClient.rxConnect(int, java.lang.String) instead
io.vertx.rxjava.ext.stomp.StompClient.connectObservable(NetClient) use StompClient.rxConnect(int, java.lang.String) instead
io.vertx.rxjava.core.net.NetClient.connectObservable(SocketAddress) use NetClient.rxConnect(int, java.lang.String) instead
io.vertx.rxjava.core.net.NetClient.connectObservable(SocketAddress, String) use NetClient.rxConnect(int, java.lang.String) instead
io.vertx.rxjava.ext.web.Cookie.cookie(String, String)
io.vertx.reactivex.ext.web.Cookie.cookie(String, String)
io.vertx.ext.web.RoutingContext.cookies() use instead RoutingContext.cookieMap()
io.vertx.rxjava.ext.web.RoutingContext.cookies()
io.vertx.reactivex.ext.web.RoutingContext.cookies()
io.vertx.rxjava.core.file.FileSystem.copyObservable(String, String) use FileSystem.rxCopy(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.copyObservable(String, String, CopyOptions) use FileSystem.rxCopy(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.copyRecursiveObservable(String, String, boolean) use FileSystem.rxCopyRecursive(java.lang.String, java.lang.String, boolean) instead
io.vertx.rxjava.ext.mongo.MongoClient.countObservable(String, JsonObject) use MongoClient.rxCount(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.countObservable(String, JsonObject)
io.vertx.ext.web.Locale.country() Use LanguageHeader.subtag() instead
io.vertx.rxjava.ext.web.Locale.country()
io.vertx.reactivex.ext.web.Locale.country()
io.vertx.ext.web.templ.rocker.RockerTemplateEngine.create() as a user you should use filename with extensions on the render method instead of relying on this method to suffix your filenames. Using this method is quite an opinionated API and has the side effect that you cannot use files without extensions as templates. Create a template engine using defaults
io.vertx.rxjava.ext.web.handler.CookieHandler.create()
io.vertx.rxjava.ext.web.Locale.create()
io.vertx.reactivex.ext.web.handler.CookieHandler.create()
io.vertx.reactivex.ext.web.Locale.create()
io.vertx.rxjava.ext.web.handler.UserSessionHandler.create(AuthProvider)
io.vertx.reactivex.ext.web.handler.UserSessionHandler.create(AuthProvider)
io.vertx.rxjava.ext.web.Locale.create(String)
io.vertx.reactivex.ext.web.Locale.create(String)
io.vertx.ext.web.handler.StaticHandler.create(String, ClassLoader) this factory will not exist on 4.0. You can load resources from the classpath, so this makes this factory obsolete.
io.vertx.rxjava.ext.web.Locale.create(String, String)
io.vertx.reactivex.ext.web.Locale.create(String, String)
io.vertx.rxjava.ext.web.Locale.create(String, String, String)
io.vertx.reactivex.ext.web.Locale.create(String, String, String)
io.vertx.rxjava.servicediscovery.ServiceDiscovery.create(Vertx, Handler<ServiceDiscovery>)
io.vertx.servicediscovery.ServiceDiscovery.create(Vertx, Handler<ServiceDiscovery>) this will be removed in Vert.x 4, instead use ServiceDiscovery.create(Vertx)
io.vertx.reactivex.servicediscovery.ServiceDiscovery.create(Vertx, Handler<ServiceDiscovery>)
io.vertx.ext.auth.jwt.JWTAuth.create(Vertx, JsonObject)
io.vertx.ext.auth.oauth2.OAuth2Auth.create(Vertx, OAuth2FlowType) the flow configuration should be passed in the config object
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.create(Vertx, OAuth2FlowType)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.create(Vertx, OAuth2FlowType)
io.vertx.ext.auth.oauth2.OAuth2Auth.create(Vertx, OAuth2FlowType, OAuth2ClientOptions) the flow configuration should be passed in the config object
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.create(Vertx, OAuth2FlowType, OAuth2ClientOptions)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.create(Vertx, OAuth2FlowType, OAuth2ClientOptions)
io.vertx.rxjava.servicediscovery.ServiceDiscovery.create(Vertx, ServiceDiscoveryOptions, Handler<ServiceDiscovery>)
io.vertx.servicediscovery.ServiceDiscovery.create(Vertx, ServiceDiscoveryOptions, Handler<ServiceDiscovery>) this will be removed in Vert.x 4, instead use ServiceDiscovery.create(Vertx, ServiceDiscoveryOptions)
io.vertx.reactivex.servicediscovery.ServiceDiscovery.create(Vertx, ServiceDiscoveryOptions, Handler<ServiceDiscovery>)
io.vertx.ext.auth.shiro.ShiroAuth.create(Vertx, ShiroAuthRealmType, JsonObject) see ShiroAuth.create(Vertx, ShiroAuthOptions)
io.vertx.rxjava.ext.auth.shiro.ShiroAuth.create(Vertx, ShiroAuthRealmType, JsonObject)
io.vertx.reactivex.ext.auth.shiro.ShiroAuth.create(Vertx, ShiroAuthRealmType, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.createCollectionObservable(String) use MongoClient.rxCreateCollection(java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoService.createCollectionObservable(String)
io.vertx.rxjava.core.file.FileSystem.createFileObservable(String) use FileSystem.rxCreateFile(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.createFileObservable(String, String) use FileSystem.rxCreateFile(java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoClient.createIndexObservable(String, JsonObject) use MongoClient.rxCreateIndex(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.createIndexObservable(String, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.createIndexWithOptionsObservable(String, JsonObject, IndexOptions) use MongoClient.rxCreateIndexWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.IndexOptions) instead
io.vertx.rxjava.ext.mongo.MongoService.createIndexWithOptionsObservable(String, JsonObject, IndexOptions)
io.vertx.ext.auth.oauth2.OAuth2Auth.createKeycloak(Vertx, OAuth2FlowType, JsonObject) You should use the provider helper KeycloakAuth instead. Create a OAuth2 auth provider
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.createKeycloak(Vertx, OAuth2FlowType, JsonObject)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.createKeycloak(Vertx, OAuth2FlowType, JsonObject)
io.vertx.cassandra.CassandraClient.createNonShared(Vertx) use CassandraClient.create(Vertx) instead
io.vertx.rxjava.cassandra.CassandraClient.createNonShared(Vertx)
io.vertx.reactivex.cassandra.CassandraClient.createNonShared(Vertx)
io.vertx.cassandra.CassandraClient.createNonShared(Vertx, CassandraClientOptions) use CassandraClient.create(Vertx, CassandraClientOptions) instead
io.vertx.rxjava.cassandra.CassandraClient.createNonShared(Vertx, CassandraClientOptions)
io.vertx.reactivex.cassandra.CassandraClient.createNonShared(Vertx, CassandraClientOptions)
io.vertx.ext.jdbc.JDBCClient.createNonShared(Vertx, JsonObject) use JDBCClient.create(Vertx, JsonObject) instead
io.vertx.ext.mongo.MongoClient.createNonShared(Vertx, JsonObject) use MongoClient.create(Vertx, JsonObject) instead
io.vertx.rxjava.ext.jdbc.JDBCClient.createNonShared(Vertx, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.createNonShared(Vertx, JsonObject)
io.vertx.reactivex.ext.jdbc.JDBCClient.createNonShared(Vertx, JsonObject)
io.vertx.reactivex.ext.mongo.MongoClient.createNonShared(Vertx, JsonObject)
io.vertx.ext.mail.MailClient.createNonShared(Vertx, MailConfig) use MailClient.create(Vertx, MailConfig) instead
io.vertx.rxjava.ext.mail.MailClient.createNonShared(Vertx, MailConfig)
io.vertx.reactivex.ext.mail.MailClient.createNonShared(Vertx, MailConfig)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.createObservable(Vertx, String) use OpenAPI3RouterFactory.rxCreate(io.vertx.rxjava.core.Vertx, java.lang.String) instead
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.createObservable(Vertx, String, List<JsonObject>) use OpenAPI3RouterFactory.rxCreate(io.vertx.rxjava.core.Vertx, java.lang.String) instead
io.vertx.serviceproxy.ProxyHelper.createProxy(Class<T>, Vertx, String) use instead ServiceProxyBuilder
io.vertx.serviceproxy.ProxyHelper.createProxy(Class<T>, Vertx, String, DeliveryOptions) use instead ServiceProxyBuilder
io.vertx.rxjava.core.file.FileSystem.createTempDirectoryObservable(String) use FileSystem.rxCreateTempDirectory(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.createTempDirectoryObservable(String, String) use FileSystem.rxCreateTempDirectory(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.createTempDirectoryObservable(String, String, String) use FileSystem.rxCreateTempDirectory(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.createTempFileObservable(String, String) use FileSystem.rxCreateTempFile(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.createTempFileObservable(String, String, String) use FileSystem.rxCreateTempFile(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.createTempFileObservable(String, String, String, String) use FileSystem.rxCreateTempFile(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.dbsizeObservable() use RedisTransaction.rxDbsize() instead
io.vertx.rxjava.redis.RedisClient.dbsizeObservable() use RedisClient.rxDbsize() instead
io.vertx.rxjava.redis.client.RedisAPI.dbsizeObservable() use RedisAPI.rxDbsize() instead
io.vertx.rxjava.redis.RedisTransaction.debugObjectObservable(String) use RedisTransaction.rxDebugObject(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.debugObjectObservable(String) use RedisClient.rxDebugObject(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.debugObservable(List<String>) use RedisAPI.rxDebug(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.debugSegfaultObservable() use RedisTransaction.rxDebugSegfault() instead
io.vertx.rxjava.redis.RedisClient.debugSegfaultObservable() use RedisClient.rxDebugSegfault() instead
io.vertx.ext.auth.oauth2.OAuth2Auth.decodeToken(String, Handler<AsyncResult<AccessToken>>) use AuthProvider.authenticate(JsonObject, Handler) instead.
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.decodeToken(String, Handler<AsyncResult<AccessToken>>)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.decodeToken(String, Handler<AsyncResult<AccessToken>>)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.decodeTokenObservable(String) use OAuth2Auth.rxDecodeToken(java.lang.String) instead
io.vertx.core.json.Json.decodeValue(Buffer, TypeReference<T>) Instead use JacksonCodec.decodeValue(Buffer, TypeReference)
io.vertx.core.json.Json.decodeValue(String, TypeReference<T>) Instead use JacksonCodec.decodeValue(String, TypeReference)
io.vertx.rxjava.redis.RedisTransaction.decrbyObservable(String, long) use RedisTransaction.rxDecrby(java.lang.String, long) instead
io.vertx.rxjava.redis.RedisClient.decrbyObservable(String, long) use RedisClient.rxDecrby(java.lang.String, long) instead
io.vertx.rxjava.redis.client.RedisAPI.decrbyObservable(String, String) use RedisAPI.rxDecrby(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.shareddata.Counter.decrementAndGetObservable() use Counter.rxDecrementAndGet() instead
io.vertx.rxjava.redis.RedisTransaction.decrObservable(String) use RedisTransaction.rxDecr(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.decrObservable(String) use RedisClient.rxDecr(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.decrObservable(String) use RedisAPI.rxDecr(java.lang.String) instead
io.vertx.core.http.HttpClient.delete(int, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.delete(int, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.delete(int, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.delete(RequestOptions, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.delete(RequestOptions, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.delete(RequestOptions, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.delete(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.delete(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.delete(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.delete(String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.delete(String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.delete(String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.deleteAbs(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.deleteAbs(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.deleteAbs(String, Handler<HttpClientResponse>)
io.vertx.rxjava.core.file.FileSystem.deleteObservable(String) use FileSystem.rxDelete(java.lang.String) instead
io.vertx.rxjava.ext.web.sstore.SessionStore.deleteObservable(String) use SessionStore.rxDelete(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.deleteRecursiveObservable(String, boolean) use FileSystem.rxDeleteRecursive(java.lang.String, boolean) instead
io.vertx.rxjava.redis.RedisTransaction.delManyObservable(List<String>) use RedisTransaction.rxDelMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.delManyObservable(List<String>) use RedisClient.rxDelMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.delObservable(List<String>) use RedisAPI.rxDel(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.delObservable(String) use RedisTransaction.rxDel(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.delObservable(String) use RedisClient.rxDel(java.lang.String) instead
io.vertx.rxjava.core.Vertx.deployVerticleObservable(String) use Vertx.rxDeployVerticle(java.lang.String) instead
io.vertx.rxjava.core.Vertx.deployVerticleObservable(String, DeploymentOptions) use Vertx.rxDeployVerticle(java.lang.String) instead
io.vertx.rxjava.core.Vertx.deployVerticleObservable(Supplier<Verticle>, DeploymentOptions) use Vertx.rxDeployVerticle(java.lang.String) instead
io.vertx.rxjava.core.Vertx.deployVerticleObservable(Verticle) use Vertx.rxDeployVerticle(java.lang.String) instead
io.vertx.rxjava.core.Vertx.deployVerticleObservable(Verticle, DeploymentOptions) use Vertx.rxDeployVerticle(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.discardObservable() use RedisTransaction.rxDiscard() instead
io.vertx.rxjava.redis.client.RedisAPI.discardObservable() use RedisAPI.rxDiscard() instead
io.vertx.rxjava.ext.auth.oauth2.providers.SalesforceAuth.discoverObservable(Vertx, OAuth2ClientOptions) use SalesforceAuth.rxDiscover(io.vertx.rxjava.core.Vertx, io.vertx.ext.auth.oauth2.OAuth2ClientOptions) instead
io.vertx.rxjava.ext.auth.oauth2.providers.GoogleAuth.discoverObservable(Vertx, OAuth2ClientOptions) use GoogleAuth.rxDiscover(io.vertx.rxjava.core.Vertx, io.vertx.ext.auth.oauth2.OAuth2ClientOptions) instead
io.vertx.rxjava.ext.auth.oauth2.providers.AzureADAuth.discoverObservable(Vertx, OAuth2ClientOptions) use AzureADAuth.rxDiscover(io.vertx.rxjava.core.Vertx, io.vertx.ext.auth.oauth2.OAuth2ClientOptions) instead
io.vertx.rxjava.ext.auth.oauth2.providers.OpenIDConnectAuth.discoverObservable(Vertx, OAuth2ClientOptions) use OpenIDConnectAuth.rxDiscover(io.vertx.rxjava.core.Vertx, io.vertx.ext.auth.oauth2.OAuth2ClientOptions) instead
io.vertx.rxjava.ext.auth.oauth2.providers.KeycloakAuth.discoverObservable(Vertx, OAuth2ClientOptions) use KeycloakAuth.rxDiscover(io.vertx.rxjava.core.Vertx, io.vertx.ext.auth.oauth2.OAuth2ClientOptions) instead
io.vertx.rxjava.ext.mongo.MongoClient.distinctObservable(String, String, String) use MongoClient.rxDistinct(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoService.distinctObservable(String, String, String)
io.vertx.rxjava.ext.mongo.MongoClient.distinctWithQueryObservable(String, String, String, JsonObject) use MongoClient.rxDistinctWithQuery(java.lang.String, java.lang.String, java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.distinctWithQueryObservable(String, String, String, JsonObject)
io.vertx.ext.web.common.template.CachingTemplateEngine.doSetExtension(String)
io.vertx.rxjava.ext.mongo.MongoClient.dropCollectionObservable(String) use MongoClient.rxDropCollection(java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoService.dropCollectionObservable(String)
io.vertx.rxjava.ext.mongo.MongoClient.dropIndexObservable(String, String) use MongoClient.rxDropIndex(java.lang.String, java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoService.dropIndexObservable(String, String)
io.vertx.rxjava.redis.RedisTransaction.dumpObservable(String) use RedisTransaction.rxDump(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.dumpObservable(String) use RedisClient.rxDump(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.dumpObservable(String) use RedisAPI.rxDump(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.echoObservable(String) use RedisTransaction.rxEcho(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.echoObservable(String) use RedisClient.rxEcho(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.echoObservable(String) use RedisAPI.rxEcho(java.lang.String) instead
io.vertx.core.http.HttpClientRequest.endHandler(Handler<Void>) this method will be removed in Vert.x 4
io.vertx.rxjava.core.http.HttpClientRequest.endHandler(Handler<Void>)
io.vertx.reactivex.core.http.HttpClientRequest.endHandler(Handler<Void>)
io.vertx.rxjava.core.eventbus.MessageProducer.endObservable() use MessageProducer.rxEnd(T) instead
io.vertx.rxjava.core.net.NetSocket.endObservable() use NetSocket.rxEnd(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.file.AsyncFile.endObservable() use AsyncFile.rxEnd(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.http.HttpServerResponse.endObservable() use HttpServerResponse.rxEnd() instead
io.vertx.rxjava.core.http.ServerWebSocket.endObservable() use ServerWebSocket.rxEnd(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.http.HttpClientRequest.endObservable() use HttpClientRequest.rxEnd(java.lang.String) instead
io.vertx.rxjava.core.http.WebSocket.endObservable() use WebSocket.rxEnd(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket.endObservable() use SockJSSocket.rxEnd() instead
io.vertx.rxjava.core.net.NetSocket.endObservable(Buffer) use NetSocket.rxEnd(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.file.AsyncFile.endObservable(Buffer) use AsyncFile.rxEnd(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.http.HttpServerResponse.endObservable(Buffer) use HttpServerResponse.rxEnd() instead
io.vertx.rxjava.core.http.ServerWebSocket.endObservable(Buffer) use ServerWebSocket.rxEnd(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.http.HttpClientRequest.endObservable(Buffer) use HttpClientRequest.rxEnd(java.lang.String) instead
io.vertx.rxjava.core.http.WebSocket.endObservable(Buffer) use WebSocket.rxEnd(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket.endObservable(Buffer) use SockJSSocket.rxEnd() instead
io.vertx.rxjava.core.http.HttpServerResponse.endObservable(String) use HttpServerResponse.rxEnd() instead
io.vertx.rxjava.core.http.HttpClientRequest.endObservable(String) use HttpClientRequest.rxEnd(java.lang.String) instead
io.vertx.rxjava.core.http.HttpServerResponse.endObservable(String, String) use HttpServerResponse.rxEnd() instead
io.vertx.rxjava.core.http.HttpClientRequest.endObservable(String, String) use HttpClientRequest.rxEnd(java.lang.String) instead
io.vertx.rxjava.core.eventbus.MessageProducer.endObservable(T) use MessageProducer.rxEnd(T) instead
io.vertx.rxjava.redis.client.RedisAPI.evalObservable(List<String>) use RedisAPI.rxEval(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.evalObservable(String, List<String>, List<String>) use RedisTransaction.rxEval(java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.evalObservable(String, List<String>, List<String>) use RedisClient.rxEval(java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.evalScriptObservable(Script, List<String>, List<String>) use RedisClient.rxEvalScript(io.vertx.rxjava.redis.Script, java.util.List<java.lang.String>, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.evalshaObservable(List<String>) use RedisAPI.rxEvalsha(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.evalshaObservable(String, List<String>, List<String>) use RedisTransaction.rxEvalsha(java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.evalshaObservable(String, List<String>, List<String>) use RedisClient.rxEvalsha(java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>) instead
io.vertx.ext.web.Router.exceptionHandler(Handler<Throwable>) you should use Router.errorHandler(int, Handler) with 500 status code
io.vertx.rxjava.ext.web.Router.exceptionHandler(Handler<Throwable>)
io.vertx.reactivex.ext.web.Router.exceptionHandler(Handler<Throwable>)
io.vertx.rxjava.rabbitmq.RabbitMQClient.exchangeBindObservable(String, String, String) use RabbitMQClient.rxExchangeBind(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.exchangeBindObservable(String, String, String, Map<String, Object>) use RabbitMQClient.rxExchangeBind(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rabbitmq.RabbitMQClient.exchangeDeclare(String, String, boolean, boolean, Map<String, String>, Handler<AsyncResult<Void>>) Use RabbitMQClient.exchangeDeclare(String, String, boolean, boolean, JsonObject, Handler) instead for support for more than just String config values
io.vertx.rxjava.rabbitmq.RabbitMQClient.exchangeDeclareObservable(String, String, boolean, boolean) use RabbitMQClient.rxExchangeDeclare(java.lang.String, java.lang.String, boolean, boolean) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.exchangeDeclareObservable(String, String, boolean, boolean, JsonObject) use RabbitMQClient.rxExchangeDeclare(java.lang.String, java.lang.String, boolean, boolean) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.exchangeDeleteObservable(String) use RabbitMQClient.rxExchangeDelete(java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.exchangeUnbindObservable(String, String, String) use RabbitMQClient.rxExchangeUnbind(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.exchangeUnbindObservable(String, String, String, Map<String, Object>) use RabbitMQClient.rxExchangeUnbind(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.execObservable() use RedisTransaction.rxExec() instead
io.vertx.rxjava.redis.client.RedisAPI.execObservable() use RedisAPI.rxExec() instead
io.vertx.circuitbreaker.CircuitBreaker.executeAndReport(Future<T>, Handler<Promise<T>>) use CircuitBreaker.executeAndReport(Promise, Handler) instead
io.vertx.circuitbreaker.CircuitBreaker.executeAndReportWithFallback(Future<T>, Handler<Promise<T>>, Function<Throwable, T>) use CircuitBreaker.executeAndReportWithFallback(Promise, Handler, Function) instead
io.vertx.rxjava.core.Context.executeBlockingObservable(Handler<Promise<T>>) use Context.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean) instead
io.vertx.rxjava.core.Vertx.executeBlockingObservable(Handler<Promise<T>>) use Vertx.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean) instead
io.vertx.rxjava.core.WorkerExecutor.executeBlockingObservable(Handler<Promise<T>>) use WorkerExecutor.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean) instead
io.vertx.rxjava.core.Context.executeBlockingObservable(Handler<Promise<T>>, boolean) use Context.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean) instead
io.vertx.rxjava.core.Vertx.executeBlockingObservable(Handler<Promise<T>>, boolean) use Vertx.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean) instead
io.vertx.rxjava.core.WorkerExecutor.executeBlockingObservable(Handler<Promise<T>>, boolean) use WorkerExecutor.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean) instead
io.vertx.rxjava.circuitbreaker.CircuitBreaker.executeCommand(Handler<Promise<T>>, Handler<AsyncResult<T>>)
io.vertx.reactivex.circuitbreaker.CircuitBreaker.executeCommand(Handler<Promise<T>>, Handler<AsyncResult<T>>)
io.vertx.circuitbreaker.CircuitBreaker.executeCommand(Handler<Promise<T>>, Handler<AsyncResult<T>>) instead use CircuitBreaker.execute(Handler, Handler)
io.vertx.rxjava.circuitbreaker.CircuitBreaker.executeCommandWithFallback(Handler<Promise<T>>, Function<Throwable, T>, Handler<AsyncResult<T>>)
io.vertx.reactivex.circuitbreaker.CircuitBreaker.executeCommandWithFallback(Handler<Promise<T>>, Function<Throwable, T>, Handler<AsyncResult<T>>)
io.vertx.circuitbreaker.CircuitBreaker.executeCommandWithFallback(Handler<Promise<T>>, Function<Throwable, T>, Handler<AsyncResult<T>>) instead use CircuitBreaker.executeWithFallback(Handler, Function, Handler)
io.vertx.rxjava.ext.sql.SQLConnection.executeObservable(String) use SQLConnection.rxExecute(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.existsManyObservable(List<String>) use RedisTransaction.rxExistsMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.existsManyObservable(List<String>) use RedisClient.rxExistsMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.existsObservable(List<String>) use RedisAPI.rxExists(java.util.List<java.lang.String>) instead
io.vertx.rxjava.core.file.FileSystem.existsObservable(String) use FileSystem.rxExists(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.existsObservable(String) use RedisTransaction.rxExists(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.existsObservable(String) use RedisClient.rxExists(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.expireatObservable(String, long) use RedisTransaction.rxExpireat(java.lang.String, long) instead
io.vertx.rxjava.redis.RedisClient.expireatObservable(String, long) use RedisClient.rxExpireat(java.lang.String, long) instead
io.vertx.rxjava.redis.client.RedisAPI.expireatObservable(String, String) use RedisAPI.rxExpireat(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.expireObservable(String, int) use RedisTransaction.rxExpire(java.lang.String, int) instead
io.vertx.rxjava.redis.RedisClient.expireObservable(String, long) use RedisClient.rxExpire(java.lang.String, long) instead
io.vertx.rxjava.redis.client.RedisAPI.expireObservable(String, String) use RedisAPI.rxExpire(java.lang.String, java.lang.String) instead
io.vertx.core.Future.fail(String) instead create a Promise and use Promise.fail(String)
io.vertx.rxjava.core.Future.fail(String)
io.vertx.reactivex.core.Future.fail(String)
io.vertx.core.Future.fail(Throwable) instead create a Promise and use Promise.fail(Throwable)
io.vertx.rxjava.core.Future.fail(Throwable)
io.vertx.reactivex.core.Future.fail(Throwable)
io.vertx.rxjava.redis.sentinel.RedisSentinel.failoverObservable(String) use RedisSentinel.rxFailover(java.lang.String) instead
io.vertx.core.http.HttpClientRequest.fetch(long) this method will be removed in Vert.x 4
io.vertx.rxjava.core.http.HttpClientRequest.fetch(long)
io.vertx.reactivex.core.http.HttpClientRequest.fetch(long)
io.vertx.rxjava.ext.auth.oauth2.AccessToken.fetchObservable(HttpMethod, String, JsonObject, Buffer) use AccessToken.rxFetch(java.lang.String) instead
io.vertx.rxjava.ext.auth.oauth2.AccessToken.fetchObservable(String) use AccessToken.rxFetch(java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoClient.findObservable(String, JsonObject) use MongoClient.rxFind(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.findObservable(String, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.findOneAndDeleteObservable(String, JsonObject) use MongoClient.rxFindOneAndDelete(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.findOneAndDeleteObservable(String, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.findOneAndDeleteWithOptionsObservable(String, JsonObject, FindOptions) use MongoClient.rxFindOneAndDeleteWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.FindOptions) instead
io.vertx.rxjava.ext.mongo.MongoService.findOneAndDeleteWithOptionsObservable(String, JsonObject, FindOptions)
io.vertx.rxjava.ext.mongo.MongoClient.findOneAndReplaceObservable(String, JsonObject, JsonObject) use MongoClient.rxFindOneAndReplace(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.findOneAndReplaceObservable(String, JsonObject, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.findOneAndReplaceWithOptionsObservable(String, JsonObject, JsonObject, FindOptions, UpdateOptions) use MongoClient.rxFindOneAndReplaceWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.FindOptions, io.vertx.ext.mongo.UpdateOptions) instead
io.vertx.rxjava.ext.mongo.MongoService.findOneAndReplaceWithOptionsObservable(String, JsonObject, JsonObject, FindOptions, UpdateOptions)
io.vertx.rxjava.ext.mongo.MongoClient.findOneAndUpdateObservable(String, JsonObject, JsonObject) use MongoClient.rxFindOneAndUpdate(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.findOneAndUpdateObservable(String, JsonObject, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.findOneAndUpdateWithOptionsObservable(String, JsonObject, JsonObject, FindOptions, UpdateOptions) use MongoClient.rxFindOneAndUpdateWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.FindOptions, io.vertx.ext.mongo.UpdateOptions) instead
io.vertx.rxjava.ext.mongo.MongoService.findOneAndUpdateWithOptionsObservable(String, JsonObject, JsonObject, FindOptions, UpdateOptions)
io.vertx.rxjava.ext.mongo.MongoClient.findOneObservable(String, JsonObject, JsonObject) use MongoClient.rxFindOne(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.findOneObservable(String, JsonObject, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.findWithOptionsObservable(String, JsonObject, FindOptions) use MongoClient.rxFindWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.FindOptions) instead
io.vertx.rxjava.ext.mongo.MongoService.findWithOptionsObservable(String, JsonObject, FindOptions)
io.vertx.rxjava.redis.RedisTransaction.flushallObservable() use RedisTransaction.rxFlushall() instead
io.vertx.rxjava.redis.RedisClient.flushallObservable() use RedisClient.rxFlushall() instead
io.vertx.rxjava.redis.client.RedisAPI.flushallObservable(List<String>) use RedisAPI.rxFlushall(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.sentinel.RedisSentinel.flushConfigObservable() use RedisSentinel.rxFlushConfig() instead
io.vertx.rxjava.redis.RedisTransaction.flushdbObservable() use RedisTransaction.rxFlushdb() instead
io.vertx.rxjava.redis.RedisClient.flushdbObservable() use RedisClient.rxFlushdb() instead
io.vertx.rxjava.redis.client.RedisAPI.flushdbObservable(List<String>) use RedisAPI.rxFlushdb(java.util.List<java.lang.String>) instead
io.vertx.rxjava.core.file.AsyncFile.flushObservable() use AsyncFile.rxFlush() instead
io.vertx.rxjava.ext.web.handler.SessionHandler.flushObservable(RoutingContext) use SessionHandler.rxFlush(io.vertx.rxjava.ext.web.RoutingContext) instead
io.vertx.rxjava.core.file.FileSystem.fsPropsObservable(String) use FileSystem.rxFsProps(java.lang.String) instead
io.vertx.core.Future.future() instead use Promise.promise()
io.vertx.rxjava.core.Future.future()
io.vertx.reactivex.core.Future.future()
io.vertx.rxjava.redis.RedisTransaction.geoaddManyObservable(String, List<GeoMember>) use RedisTransaction.rxGeoaddMany(java.lang.String, java.util.List<io.vertx.redis.op.GeoMember>) instead
io.vertx.rxjava.redis.RedisClient.geoaddManyObservable(String, List<GeoMember>) use RedisClient.rxGeoaddMany(java.lang.String, java.util.List<io.vertx.redis.op.GeoMember>) instead
io.vertx.rxjava.redis.client.RedisAPI.geoaddObservable(List<String>) use RedisAPI.rxGeoadd(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.geoaddObservable(String, double, double, String) use RedisTransaction.rxGeoadd(java.lang.String, double, double, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.geoaddObservable(String, double, double, String) use RedisClient.rxGeoadd(java.lang.String, double, double, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.geodistObservable(List<String>) use RedisAPI.rxGeodist(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.geodistObservable(String, String, String) use RedisTransaction.rxGeodist(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.geodistObservable(String, String, String) use RedisClient.rxGeodist(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.geodistWithUnitObservable(String, String, String, GeoUnit) use RedisTransaction.rxGeodistWithUnit(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.GeoUnit) instead
io.vertx.rxjava.redis.RedisClient.geodistWithUnitObservable(String, String, String, GeoUnit) use RedisClient.rxGeodistWithUnit(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.GeoUnit) instead
io.vertx.rxjava.redis.RedisTransaction.geohashManyObservable(String, List<String>) use RedisTransaction.rxGeohashMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.geohashManyObservable(String, List<String>) use RedisClient.rxGeohashMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.geohashObservable(List<String>) use RedisAPI.rxGeohash(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.geohashObservable(String, String) use RedisTransaction.rxGeohash(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.geohashObservable(String, String) use RedisClient.rxGeohash(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.geoposManyObservable(String, List<String>) use RedisTransaction.rxGeoposMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.geoposManyObservable(String, List<String>) use RedisClient.rxGeoposMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.geoposObservable(List<String>) use RedisAPI.rxGeopos(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.geoposObservable(String, String) use RedisTransaction.rxGeopos(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.geoposObservable(String, String) use RedisClient.rxGeopos(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.georadiusbymemberObservable(List<String>) use RedisAPI.rxGeoradiusbymember(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.georadiusbymemberObservable(String, String, double, GeoUnit) use RedisTransaction.rxGeoradiusbymember(java.lang.String, java.lang.String, double, io.vertx.redis.op.GeoUnit) instead
io.vertx.rxjava.redis.RedisClient.georadiusbymemberObservable(String, String, double, GeoUnit) use RedisClient.rxGeoradiusbymember(java.lang.String, java.lang.String, double, io.vertx.redis.op.GeoUnit) instead
io.vertx.rxjava.redis.client.RedisAPI.georadiusbymemberRoObservable(List<String>) use RedisAPI.rxGeoradiusbymemberRo(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.georadiusbymemberWithOptionsObservable(String, String, double, GeoUnit, GeoRadiusOptions) use RedisTransaction.rxGeoradiusbymemberWithOptions(java.lang.String, java.lang.String, double, io.vertx.redis.op.GeoUnit, io.vertx.redis.op.GeoRadiusOptions) instead
io.vertx.rxjava.redis.RedisClient.georadiusbymemberWithOptionsObservable(String, String, double, GeoUnit, GeoRadiusOptions) use RedisClient.rxGeoradiusbymemberWithOptions(java.lang.String, java.lang.String, double, io.vertx.redis.op.GeoUnit, io.vertx.redis.op.GeoRadiusOptions) instead
io.vertx.rxjava.redis.client.RedisAPI.georadiusObservable(List<String>) use RedisAPI.rxGeoradius(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.georadiusObservable(String, double, double, double, GeoUnit) use RedisTransaction.rxGeoradius(java.lang.String, double, double, double, io.vertx.redis.op.GeoUnit) instead
io.vertx.rxjava.redis.RedisClient.georadiusObservable(String, double, double, double, GeoUnit) use RedisClient.rxGeoradius(java.lang.String, double, double, double, io.vertx.redis.op.GeoUnit) instead
io.vertx.rxjava.redis.client.RedisAPI.georadiusRoObservable(List<String>) use RedisAPI.rxGeoradiusRo(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.georadiusWithOptionsObservable(String, double, double, double, GeoUnit, GeoRadiusOptions) use RedisTransaction.rxGeoradiusWithOptions(java.lang.String, double, double, double, io.vertx.redis.op.GeoUnit, io.vertx.redis.op.GeoRadiusOptions) instead
io.vertx.rxjava.redis.RedisClient.georadiusWithOptionsObservable(String, double, double, double, GeoUnit, GeoRadiusOptions) use RedisClient.rxGeoradiusWithOptions(java.lang.String, double, double, double, io.vertx.redis.op.GeoUnit, io.vertx.redis.op.GeoRadiusOptions) instead
io.vertx.core.http.HttpClient.get(int, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.get(int, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.get(int, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.get(RequestOptions, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.get(RequestOptions, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.get(RequestOptions, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.get(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.get(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.get(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.get(String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.get(String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.get(String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.getAbs(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.getAbs(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.getAbs(String, Handler<HttpClientResponse>)
io.vertx.rxjava.core.shareddata.Counter.getAndAddObservable(long) use Counter.rxGetAndAdd(long) instead
io.vertx.rxjava.core.shareddata.Counter.getAndIncrementObservable() use Counter.rxGetAndIncrement() instead
io.vertx.rxjava.core.shareddata.SharedData.getAsyncMapObservable(String) use SharedData.rxGetAsyncMap(java.lang.String) instead
io.vertx.sqlclient.Tuple.getBigDecimalArray(int) instead use Tuple.getArrayOfBigDecimals(int)
io.vertx.rxjava.sqlclient.Tuple.getBigDecimalArray(int)
io.vertx.reactivex.sqlclient.Tuple.getBigDecimalArray(int)
io.vertx.sqlclient.Row.getBigDecimalArray(String) instead use Row.getArrayOfBigDecimals(String)
io.vertx.rxjava.sqlclient.Row.getBigDecimalArray(String)
io.vertx.reactivex.sqlclient.Row.getBigDecimalArray(String)
io.vertx.rxjava.redis.RedisTransaction.getBinaryObservable(String) use RedisTransaction.rxGetBinary(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.getBinaryObservable(String) use RedisClient.rxGetBinary(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.getbitObservable(String, long) use RedisTransaction.rxGetbit(java.lang.String, long) instead
io.vertx.rxjava.redis.RedisClient.getbitObservable(String, long) use RedisClient.rxGetbit(java.lang.String, long) instead
io.vertx.rxjava.redis.client.RedisAPI.getbitObservable(String, String) use RedisAPI.rxGetbit(java.lang.String, java.lang.String) instead
io.vertx.sqlclient.Tuple.getBooleanArray(int) instead use Tuple.getArrayOfBooleans(int)
io.vertx.rxjava.sqlclient.Tuple.getBooleanArray(int)
io.vertx.reactivex.sqlclient.Tuple.getBooleanArray(int)
io.vertx.sqlclient.Row.getBooleanArray(String) instead use Row.getArrayOfBooleans(String)
io.vertx.rxjava.sqlclient.Row.getBooleanArray(String)
io.vertx.reactivex.sqlclient.Row.getBooleanArray(String)
io.vertx.sqlclient.Tuple.getBufferArray(int) instead use Tuple.getArrayOfBuffers(int)
io.vertx.sqlclient.Row.getBufferArray(String) instead use Row.getArrayOfBuffers(String)
io.vertx.core.VertxOptions.getClusterHost() as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.getHost() instead
io.vertx.core.VertxOptions.getClusterPingInterval() as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.getClusterPingInterval() instead
io.vertx.core.VertxOptions.getClusterPingReplyInterval() as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.getClusterPingReplyInterval() instead
io.vertx.core.VertxOptions.getClusterPort() as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.getPort() instead
io.vertx.core.VertxOptions.getClusterPublicHost() as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.getClusterPublicHost() instead
io.vertx.core.VertxOptions.getClusterPublicPort() as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.getClusterPublicPort() instead
io.vertx.rxjava.core.shareddata.SharedData.getClusterWideMapObservable(String) use SharedData.rxGetClusterWideMap(java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoClient.getCollectionsObservable() use MongoClient.rxGetCollections() instead
io.vertx.rxjava.ext.mongo.MongoService.getCollectionsObservable()
io.vertx.config.ConfigRetriever.getConfigAsFuture(ConfigRetriever) removed in Vert.x 4 for ConfigRetriever#getConfig() method that returns a Future<JsonObject> in 3.x you can use instead Future.future(retriever::getConfig)
io.vertx.rxjava.config.ConfigRetriever.getConfigAsFuture(ConfigRetriever)
io.vertx.reactivex.config.ConfigRetriever.getConfigAsFuture(ConfigRetriever)
io.vertx.rxjava.ext.sql.SQLClient.getConnectionObservable() use SQLClient.rxGetConnection() instead
io.vertx.rxjava.core.shareddata.SharedData.getCounterObservable(String) use SharedData.rxGetCounter(java.lang.String) instead
io.vertx.sqlclient.Tuple.getDoubleArray(int) instead use Tuple.getArrayOfDoubles(int)
io.vertx.rxjava.sqlclient.Tuple.getDoubleArray(int)
io.vertx.reactivex.sqlclient.Tuple.getDoubleArray(int)
io.vertx.sqlclient.Row.getDoubleArray(String) instead use Row.getArrayOfDoubles(String)
io.vertx.rxjava.sqlclient.Row.getDoubleArray(String)
io.vertx.reactivex.sqlclient.Row.getDoubleArray(String)
io.vertx.sqlclient.Tuple.getFloatArray(int) instead use Tuple.getArrayOfFloats(int)
io.vertx.rxjava.sqlclient.Tuple.getFloatArray(int)
io.vertx.reactivex.sqlclient.Tuple.getFloatArray(int)
io.vertx.sqlclient.Row.getFloatArray(String) instead use Row.getArrayOfFloats(String)
io.vertx.rxjava.sqlclient.Row.getFloatArray(String)
io.vertx.reactivex.sqlclient.Row.getFloatArray(String)
io.vertx.ext.auth.oauth2.OAuth2Auth.getFlowType()
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.getFlowType()
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.getFlowType()
io.vertx.sqlclient.Tuple.getIntegerArray(int) instead use Tuple.getArrayOfIntegers(int)
io.vertx.rxjava.sqlclient.Tuple.getIntegerArray(int)
io.vertx.reactivex.sqlclient.Tuple.getIntegerArray(int)
io.vertx.sqlclient.Row.getIntegerArray(String) instead use Row.getArrayOfIntegers(String)
io.vertx.rxjava.sqlclient.Row.getIntegerArray(String)
io.vertx.reactivex.sqlclient.Row.getIntegerArray(String)
io.vertx.mqtt.MqttClientOptions.getKeepAliveTimeSeconds() instead use MqttClientOptions.getKeepAliveInterval()
io.vertx.rxjava.core.shareddata.SharedData.getLocalAsyncMapObservable(String) use SharedData.rxGetLocalAsyncMap(java.lang.String) instead
io.vertx.rxjava.core.shareddata.SharedData.getLocalCounterObservable(String) use SharedData.rxGetLocalCounter(java.lang.String) instead
io.vertx.sqlclient.Tuple.getLocalDateArray(int) instead use Tuple.getArrayOfLocalDates(int)
io.vertx.rxjava.sqlclient.Tuple.getLocalDateArray(int)
io.vertx.reactivex.sqlclient.Tuple.getLocalDateArray(int)
io.vertx.sqlclient.Row.getLocalDateArray(String) instead use Row.getArrayOfLocalDates(String)
io.vertx.rxjava.sqlclient.Row.getLocalDateArray(String)
io.vertx.reactivex.sqlclient.Row.getLocalDateArray(String)
io.vertx.sqlclient.Tuple.getLocalDateTimeArray(int) instead use Tuple.getArrayOfLocalDateTimes(int)
io.vertx.rxjava.sqlclient.Tuple.getLocalDateTimeArray(int)
io.vertx.reactivex.sqlclient.Tuple.getLocalDateTimeArray(int)
io.vertx.sqlclient.Row.getLocalDateTimeArray(String) instead use Row.getArrayOfLocalDateTimes(String)
io.vertx.rxjava.sqlclient.Row.getLocalDateTimeArray(String)
io.vertx.reactivex.sqlclient.Row.getLocalDateTimeArray(String)
io.vertx.rxjava.core.shareddata.SharedData.getLocalLockObservable(String) use SharedData.rxGetLocalLock(java.lang.String) instead
io.vertx.rxjava.core.shareddata.SharedData.getLocalLockWithTimeoutObservable(String, long) use SharedData.rxGetLocalLockWithTimeout(java.lang.String, long) instead
io.vertx.sqlclient.Tuple.getLocalTimeArray(int) instead use Tuple.getArrayOfLocalTimes(int)
io.vertx.rxjava.sqlclient.Tuple.getLocalTimeArray(int)
io.vertx.reactivex.sqlclient.Tuple.getLocalTimeArray(int)
io.vertx.sqlclient.Row.getLocalTimeArray(String) instead use Row.getArrayOfLocalTimes(String)
io.vertx.rxjava.sqlclient.Row.getLocalTimeArray(String)
io.vertx.reactivex.sqlclient.Row.getLocalTimeArray(String)
io.vertx.rxjava.core.shareddata.SharedData.getLockObservable(String) use SharedData.rxGetLock(java.lang.String) instead
io.vertx.rxjava.core.shareddata.SharedData.getLockWithTimeoutObservable(String, long) use SharedData.rxGetLockWithTimeout(java.lang.String, long) instead
io.vertx.sqlclient.Tuple.getLongArray(int) instead use Tuple.getArrayOfLongs(int)
io.vertx.rxjava.sqlclient.Tuple.getLongArray(int)
io.vertx.reactivex.sqlclient.Tuple.getLongArray(int)
io.vertx.sqlclient.Row.getLongArray(String) instead use Row.getArrayOfLongs(String)
io.vertx.rxjava.sqlclient.Row.getLongArray(String)
io.vertx.reactivex.sqlclient.Row.getLongArray(String)
io.vertx.rxjava.redis.sentinel.RedisSentinel.getMasterAddrByNameObservable(String) use RedisSentinel.rxGetMasterAddrByName(java.lang.String) instead
io.vertx.core.http.HttpClientOptions.getMaxWebsocketFrameSize() instead use HttpClientOptions.getMaxWebSocketFrameSize()
io.vertx.core.http.HttpServerOptions.getMaxWebsocketFrameSize() use instead HttpServerOptions.getMaxWebSocketFrameSize()
io.vertx.core.http.HttpClientOptions.getMaxWebsocketMessageSize() instead use HttpClientOptions.getMaxWebSocketMessageSize()
io.vertx.core.http.HttpServerOptions.getMaxWebsocketMessageSize() use instead HttpServerOptions.getMaxWebSocketMessageSize()
io.vertx.core.http.HttpClient.getNow(int, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.getNow(int, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.getNow(int, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.getNow(RequestOptions, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.getNow(RequestOptions, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.getNow(RequestOptions, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.getNow(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.getNow(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.getNow(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.getNow(String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.getNow(String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.getNow(String, String, Handler<HttpClientResponse>)
io.vertx.sqlclient.Tuple.getNumericArray(int) instead use Tuple.getArrayOfNumerics(int)
io.vertx.rxjava.sqlclient.Tuple.getNumericArray(int)
io.vertx.reactivex.sqlclient.Tuple.getNumericArray(int)
io.vertx.sqlclient.Row.getNumericArray(String) instead use Row.getArrayOfNumerics(String)
io.vertx.rxjava.sqlclient.Row.getNumericArray(String)
io.vertx.reactivex.sqlclient.Row.getNumericArray(String)
io.vertx.rxjava.core.shareddata.Counter.getObservable() use Counter.rxGet() instead
io.vertx.rxjava.core.shareddata.AsyncMap.getObservable(K) use AsyncMap.rxGet(K) instead
io.vertx.rxjava.redis.RedisTransaction.getObservable(String) use RedisTransaction.rxGet(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.getObservable(String) use RedisClient.rxGet(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.getObservable(String) use RedisAPI.rxGet(java.lang.String) instead
io.vertx.rxjava.ext.web.sstore.SessionStore.getObservable(String) use SessionStore.rxGet(java.lang.String) instead
io.vertx.sqlclient.Tuple.getOffsetDateTimeArray(int) instead use Tuple.getArrayOfOffsetDateTimes(int)
io.vertx.rxjava.sqlclient.Tuple.getOffsetDateTimeArray(int)
io.vertx.reactivex.sqlclient.Tuple.getOffsetDateTimeArray(int)
io.vertx.sqlclient.Row.getOffsetDateTimeArray(String) instead use Row.getArrayOfOffsetDateTimes(String)
io.vertx.rxjava.sqlclient.Row.getOffsetDateTimeArray(String)
io.vertx.reactivex.sqlclient.Row.getOffsetDateTimeArray(String)
io.vertx.sqlclient.Tuple.getOffsetTimeArray(int) instead use Tuple.getArrayOfOffsetTimes(int)
io.vertx.rxjava.sqlclient.Tuple.getOffsetTimeArray(int)
io.vertx.reactivex.sqlclient.Tuple.getOffsetTimeArray(int)
io.vertx.sqlclient.Row.getOffsetTimeArray(String) instead use Row.getArrayOfOffsetTimes(String)
io.vertx.rxjava.sqlclient.Row.getOffsetTimeArray(String)
io.vertx.reactivex.sqlclient.Row.getOffsetTimeArray(String)
io.vertx.core.http.HttpServerOptions.getPerFrameWebsocketCompressionSupported() instead use HttpServerOptions.getPerFrameWebSocketCompressionSupported()
io.vertx.core.http.HttpServerOptions.getPerMessageWebsocketCompressionSupported() instead use HttpServerOptions.getPerMessageWebSocketCompressionSupported()
io.vertx.ext.auth.PubSecKeyOptions.getPublicKey()
io.vertx.rxjava.redis.RedisTransaction.getrangeObservable(String, long, long) use RedisTransaction.rxGetrange(java.lang.String, long, long) instead
io.vertx.rxjava.redis.RedisClient.getrangeObservable(String, long, long) use RedisClient.rxGetrange(java.lang.String, long, long) instead
io.vertx.rxjava.redis.client.RedisAPI.getrangeObservable(String, String, String) use RedisAPI.rxGetrange(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.core.cli.CommandLine.getRawValues(Option) use CommandLine.getRawValuesForOption(Option)
io.vertx.rxjava.core.cli.CommandLine.getRawValues(Option)
io.vertx.reactivex.core.cli.CommandLine.getRawValues(Option)
io.vertx.ext.auth.oauth2.OAuth2ClientOptions.getScopeSeparator()
io.vertx.ext.auth.oauth2.OAuth2Auth.getScopeSeparator()
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.getScopeSeparator()
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.getScopeSeparator()
io.vertx.ext.auth.PubSecKeyOptions.getSecretKey()
io.vertx.ext.auth.jwt.JWTAuthOptions.getSecrets()
io.vertx.rxjava.redis.RedisTransaction.getsetObservable(String, String) use RedisTransaction.rxGetset(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.getsetObservable(String, String) use RedisClient.rxGetset(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.getsetObservable(String, String) use RedisAPI.rxGetset(java.lang.String, java.lang.String) instead
io.vertx.sqlclient.Tuple.getShortArray(int) instead use Tuple.getArrayOfShorts(int)
io.vertx.rxjava.sqlclient.Tuple.getShortArray(int)
io.vertx.reactivex.sqlclient.Tuple.getShortArray(int)
io.vertx.sqlclient.Row.getShortArray(String) instead use Row.getArrayOfShorts(String)
io.vertx.rxjava.sqlclient.Row.getShortArray(String)
io.vertx.reactivex.sqlclient.Row.getShortArray(String)
io.vertx.sqlclient.Tuple.getStringArray(int) instead use Tuple.getArrayOfStrings(int)
io.vertx.rxjava.sqlclient.Tuple.getStringArray(int)
io.vertx.reactivex.sqlclient.Tuple.getStringArray(int)
io.vertx.sqlclient.Row.getStringArray(String) instead use Row.getArrayOfStrings(String)
io.vertx.rxjava.sqlclient.Row.getStringArray(String)
io.vertx.reactivex.sqlclient.Row.getStringArray(String)
io.vertx.sqlclient.Tuple.getTemporalArray(int) instead use Tuple.getArrayOfTemporals(int)
io.vertx.rxjava.sqlclient.Tuple.getTemporalArray(int)
io.vertx.reactivex.sqlclient.Tuple.getTemporalArray(int)
io.vertx.sqlclient.Row.getTemporalArray(String) instead use Row.getArrayOfTemporals(String)
io.vertx.rxjava.sqlclient.Row.getTemporalArray(String)
io.vertx.reactivex.sqlclient.Row.getTemporalArray(String)
io.vertx.ext.auth.oauth2.OAuth2Auth.getToken(JsonObject, Handler<AsyncResult<AccessToken>>) use AuthProvider.authenticate(JsonObject, Handler) instead.
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.getToken(JsonObject, Handler<AsyncResult<AccessToken>>)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.getToken(JsonObject, Handler<AsyncResult<AccessToken>>)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.getTokenObservable(JsonObject) use OAuth2Auth.rxGetToken(io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.sql.SQLConnection.getTransactionIsolationObservable() use SQLConnection.rxGetTransactionIsolation() instead
io.vertx.core.http.HttpClientOptions.getTryUsePerMessageWebsocketCompression() instead use HttpClientOptions.getTryUsePerMessageWebSocketCompression()
io.vertx.core.http.HttpClientOptions.getTryWebsocketDeflateFrameCompression() instead use HttpClientOptions.getTryWebSocketDeflateFrameCompression()
io.vertx.sqlclient.Tuple.getUUIDArray(int) instead use Tuple.getArrayOfUUIDs(int)
io.vertx.rxjava.sqlclient.Tuple.getUUIDArray(int)
io.vertx.reactivex.sqlclient.Tuple.getUUIDArray(int)
io.vertx.sqlclient.Row.getUUIDArray(String) instead use Row.getArrayOfUUIDs(String)
io.vertx.rxjava.sqlclient.Row.getUUIDArray(String)
io.vertx.reactivex.sqlclient.Row.getUUIDArray(String)
io.vertx.ext.web.api.contract.RouterFactory.getValidationFailureHandler() Router Factory won't manage the validation errors anymore. You must use Router.errorHandler(int, Handler) with 400 error
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getValidationFailureHandler()
io.vertx.rxjava.ext.web.api.contract.RouterFactory.getValidationFailureHandler()
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getValidationFailureHandler()
io.vertx.reactivex.ext.web.api.contract.RouterFactory.getValidationFailureHandler()
io.vertx.amqpbridge.AmqpBridgeOptions.getVhost() use ProtonClientOptions.getVirtualHost() option instead.
io.vertx.core.http.HttpServerOptions.getWebsocketAllowServerNoContext() instead use HttpServerOptions.getWebSocketAllowServerNoContext()
io.vertx.core.http.HttpClientOptions.getWebsocketCompressionAllowClientNoContext() instead use HttpClientOptions.getWebSocketCompressionAllowClientNoContext()
io.vertx.core.http.HttpClientOptions.getWebsocketCompressionLevel() instead use HttpClientOptions.getWebSocketCompressionLevel()
io.vertx.core.http.HttpServerOptions.getWebsocketCompressionLevel() instead use HttpServerOptions.getWebSocketCompressionLevel()
io.vertx.core.http.HttpClientOptions.getWebsocketCompressionRequestServerNoContext() instead use HttpClientOptions.getWebSocketCompressionRequestServerNoContext()
io.vertx.core.http.HttpServerOptions.getWebsocketPreferredClientNoContext() instead use HttpServerOptions.getWebSocketPreferredClientNoContext()
io.vertx.core.http.HttpServerOptions.getWebsocketSubProtocols() use HttpServerOptions.getWebSocketSubProtocols() instead
io.vertx.mqtt.MqttWill.getWillMessage() use MqttWill.getWillMessageBytes() instead
io.vertx.ext.web.handler.sockjs.SockJSHandler.handle(RoutingContext) mount the router as a sub-router instead. This method will not properly handle errors.
io.vertx.rxjava.ext.web.handler.UserSessionHandler.handle(RoutingContext)
io.vertx.rxjava.ext.web.handler.sockjs.SockJSHandler.handle(RoutingContext)
io.vertx.rxjava.ext.web.handler.CookieHandler.handle(RoutingContext)
io.vertx.reactivex.ext.web.handler.UserSessionHandler.handle(RoutingContext)
io.vertx.reactivex.ext.web.handler.sockjs.SockJSHandler.handle(RoutingContext)
io.vertx.reactivex.ext.web.handler.CookieHandler.handle(RoutingContext)
io.vertx.core.http.HttpClientRequest.handler(Handler<HttpClientResponse>) this method will break in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>
io.vertx.rxjava.core.http.HttpClientRequest.handler(Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClientRequest.handler(Handler<HttpClientResponse>)
io.vertx.rxjava.ext.unit.Async.handlerObservable() use Async.rxHandler() instead
io.vertx.rxjava.ext.unit.Completion.handlerObservable() use Completion.rxHandler() instead
io.vertx.rxjava.ext.unit.TestCompletion.handlerObservable() use TestCompletion.rxHandler() instead
io.vertx.rxjava.redis.RedisTransaction.hdelManyObservable(String, List<String>) use RedisTransaction.rxHdelMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.hdelManyObservable(String, List<String>) use RedisClient.rxHdelMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.hdelObservable(List<String>) use RedisAPI.rxHdel(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.hdelObservable(String, String) use RedisTransaction.rxHdel(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.hdelObservable(String, String) use RedisClient.rxHdel(java.lang.String, java.lang.String) instead
io.vertx.core.http.HttpClient.head(int, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.head(int, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.head(int, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.head(RequestOptions, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.head(RequestOptions, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.head(RequestOptions, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.head(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.head(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.head(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.head(String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.head(String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.head(String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.headAbs(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.headAbs(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.headAbs(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.headNow(int, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.headNow(int, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.headNow(int, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.headNow(RequestOptions, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.headNow(RequestOptions, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.headNow(RequestOptions, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.headNow(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.headNow(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.headNow(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.headNow(String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.headNow(String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.headNow(String, String, Handler<HttpClientResponse>)
io.vertx.rxjava.redis.RedisTransaction.hexistsObservable(String, String) use RedisTransaction.rxHexists(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.hexistsObservable(String, String) use RedisClient.rxHexists(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.hexistsObservable(String, String) use RedisAPI.rxHexists(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.hgetallObservable(String) use RedisTransaction.rxHgetall(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.hgetallObservable(String) use RedisClient.rxHgetall(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.hgetallObservable(String) use RedisAPI.rxHgetall(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.hgetObservable(String, String) use RedisTransaction.rxHget(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.hgetObservable(String, String) use RedisClient.rxHget(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.hgetObservable(String, String) use RedisAPI.rxHget(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.hincrbyfloatObservable(String, String, double) use RedisTransaction.rxHincrbyfloat(java.lang.String, java.lang.String, double) instead
io.vertx.rxjava.redis.RedisClient.hincrbyfloatObservable(String, String, double) use RedisClient.rxHincrbyfloat(java.lang.String, java.lang.String, double) instead
io.vertx.rxjava.redis.client.RedisAPI.hincrbyfloatObservable(String, String, String) use RedisAPI.rxHincrbyfloat(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.hincrbyObservable(String, String, long) use RedisTransaction.rxHincrby(java.lang.String, java.lang.String, long) instead
io.vertx.rxjava.redis.RedisClient.hincrbyObservable(String, String, long) use RedisClient.rxHincrby(java.lang.String, java.lang.String, long) instead
io.vertx.rxjava.redis.client.RedisAPI.hincrbyObservable(String, String, String) use RedisAPI.rxHincrby(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.hkeysObservable(String) use RedisTransaction.rxHkeys(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.hkeysObservable(String) use RedisClient.rxHkeys(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.hkeysObservable(String) use RedisAPI.rxHkeys(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.hlenObservable(String) use RedisTransaction.rxHlen(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.hlenObservable(String) use RedisClient.rxHlen(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.hlenObservable(String) use RedisAPI.rxHlen(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.hmgetObservable(List<String>) use RedisAPI.rxHmget(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.hmgetObservable(String, List<String>) use RedisTransaction.rxHmget(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.hmgetObservable(String, List<String>) use RedisClient.rxHmget(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.hmsetObservable(List<String>) use RedisAPI.rxHmset(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.hmsetObservable(String, JsonObject) use RedisTransaction.rxHmset(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.redis.RedisClient.hmsetObservable(String, JsonObject) use RedisClient.rxHmset(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.redis.client.RedisAPI.hostObservable(List<String>) use RedisAPI.rxHost(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.hscanObservable(List<String>) use RedisAPI.rxHscan(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.hscanObservable(String, String, ScanOptions) use RedisTransaction.rxHscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions) instead
io.vertx.rxjava.redis.RedisClient.hscanObservable(String, String, ScanOptions) use RedisClient.rxHscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions) instead
io.vertx.rxjava.redis.RedisTransaction.hsetnxObservable(String, String, String) use RedisTransaction.rxHsetnx(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.hsetnxObservable(String, String, String) use RedisClient.rxHsetnx(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.hsetnxObservable(String, String, String) use RedisAPI.rxHsetnx(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.hsetObservable(List<String>) use RedisAPI.rxHset(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.hsetObservable(String, String, String) use RedisTransaction.rxHset(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.hsetObservable(String, String, String) use RedisClient.rxHset(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.hstrlenObservable(String, String) use RedisClient.rxHstrlen(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.hstrlenObservable(String, String) use RedisAPI.rxHstrlen(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.hvalsObservable(String) use RedisTransaction.rxHvals(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.hvalsObservable(String) use RedisClient.rxHvals(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.hvalsObservable(String) use RedisAPI.rxHvals(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.incrbyfloatObservable(String, double) use RedisTransaction.rxIncrbyfloat(java.lang.String, double) instead
io.vertx.rxjava.redis.RedisClient.incrbyfloatObservable(String, double) use RedisClient.rxIncrbyfloat(java.lang.String, double) instead
io.vertx.rxjava.redis.client.RedisAPI.incrbyfloatObservable(String, String) use RedisAPI.rxIncrbyfloat(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.incrbyObservable(String, long) use RedisTransaction.rxIncrby(java.lang.String, long) instead
io.vertx.rxjava.redis.RedisClient.incrbyObservable(String, long) use RedisClient.rxIncrby(java.lang.String, long) instead
io.vertx.rxjava.redis.client.RedisAPI.incrbyObservable(String, String) use RedisAPI.rxIncrby(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.shareddata.Counter.incrementAndGetObservable() use Counter.rxIncrementAndGet() instead
io.vertx.rxjava.redis.RedisTransaction.incrObservable(String) use RedisTransaction.rxIncr(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.incrObservable(String) use RedisClient.rxIncr(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.incrObservable(String) use RedisAPI.rxIncr(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.infoObservable() use RedisTransaction.rxInfo() instead
io.vertx.rxjava.redis.RedisClient.infoObservable() use RedisClient.rxInfo() instead
io.vertx.rxjava.redis.client.RedisAPI.infoObservable(List<String>) use RedisAPI.rxInfo(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.infoSectionObservable(String) use RedisTransaction.rxInfoSection(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.infoSectionObservable(String) use RedisClient.rxInfoSection(java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoClient.insertObservable(String, JsonObject) use MongoClient.rxInsert(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.insertObservable(String, JsonObject)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.insertUserObservable(String, String, List<String>, List<String>) use MongoAuth.rxInsertUser(java.lang.String, java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>) instead
io.vertx.rxjava.ext.mongo.MongoClient.insertWithOptionsObservable(String, JsonObject, WriteOption) use MongoClient.rxInsertWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.WriteOption) instead
io.vertx.rxjava.ext.mongo.MongoService.insertWithOptionsObservable(String, JsonObject, WriteOption)
io.vertx.rxjava.ext.auth.oauth2.AccessToken.introspectObservable() use AccessToken.rxIntrospect() instead
io.vertx.rxjava.ext.auth.oauth2.AccessToken.introspectObservable(String) use AccessToken.rxIntrospect() instead
io.vertx.ext.auth.oauth2.OAuth2Auth.introspectToken(String, Handler<AsyncResult<AccessToken>>)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.introspectToken(String, Handler<AsyncResult<AccessToken>>)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.introspectToken(String, Handler<AsyncResult<AccessToken>>)
io.vertx.ext.auth.oauth2.OAuth2Auth.introspectToken(String, String, Handler<AsyncResult<AccessToken>>)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.introspectToken(String, String, Handler<AsyncResult<AccessToken>>)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.introspectToken(String, String, Handler<AsyncResult<AccessToken>>)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.introspectTokenObservable(String) use OAuth2Auth.rxIntrospectToken(java.lang.String) instead
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.introspectTokenObservable(String, String) use OAuth2Auth.rxIntrospectToken(java.lang.String) instead
io.vertx.ext.auth.User.isAuthorised(String, Handler<AsyncResult<Boolean>>) See User.isAuthorized(String, Handler)
io.vertx.rxjava.ext.auth.User.isAuthorised(String, Handler<AsyncResult<Boolean>>)
io.vertx.reactivex.ext.auth.User.isAuthorised(String, Handler<AsyncResult<Boolean>>)
io.vertx.rxjava.ext.auth.User.isAuthorisedObservable(String) use User.rxIsAuthorised(java.lang.String) instead
io.vertx.ext.auth.User.isAuthorized(String, Handler<AsyncResult<Boolean>>)
io.vertx.rxjava.ext.auth.User.isAuthorized(String, Handler<AsyncResult<Boolean>>)
io.vertx.reactivex.ext.auth.User.isAuthorized(String, Handler<AsyncResult<Boolean>>)
io.vertx.rxjava.ext.auth.oauth2.OAuth2RBAC.isAuthorizedObservable(AccessToken, String) use OAuth2RBAC.rxIsAuthorized(io.vertx.rxjava.ext.auth.oauth2.AccessToken, java.lang.String) instead
io.vertx.rxjava.ext.auth.User.isAuthorizedObservable(String) use User.rxIsAuthorized(java.lang.String) instead
io.vertx.ext.auth.PubSecKeyOptions.isCertificate()
io.vertx.rxjava.ext.web.Cookie.isChanged()
io.vertx.reactivex.ext.web.Cookie.isChanged()
io.vertx.core.net.NetServerOptions.isClientAuthRequired() use getClientAuth() == ClientAuth.REQUIRED instead
io.vertx.core.VertxOptions.isClustered() as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.isClustered() instead
io.vertx.core.spi.metrics.Metrics.isEnabled() the SPI metrics should instead return a null object to signal that metrics is not provided
io.vertx.core.VertxOptions.isFileResolverCachingEnabled() use getFileSystemOptions().isFileCachingEnabled() instead
io.vertx.rxjava.ext.web.Cookie.isFromUserAgent()
io.vertx.reactivex.ext.web.Cookie.isFromUserAgent()
io.vertx.ext.web.api.contract.RouterFactoryOptions.isMountValidationFailureHandler() Router Factory won't manage the validation errors anymore. You must use Router.errorHandler(int, Handler) with 400 error
io.vertx.ext.auth.PubSecKeyOptions.isSymmetric()
io.vertx.ext.auth.oauth2.OAuth2ClientOptions.isUseBasicAuthorizationHeader()
io.vertx.core.net.TCPSSLOptions.isUsePooledBuffers() this has no effect, just don't use it
io.vertx.rxjava.redis.RedisTransaction.keysObservable(String) use RedisTransaction.rxKeys(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.keysObservable(String) use RedisClient.rxKeys(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.keysObservable(String) use RedisAPI.rxKeys(java.lang.String) instead
io.vertx.ext.web.Locale.language() Use LanguageHeader.tag() instead
io.vertx.rxjava.ext.web.Locale.language()
io.vertx.reactivex.ext.web.Locale.language()
io.vertx.rxjava.redis.RedisTransaction.lastsaveObservable() use RedisTransaction.rxLastsave() instead
io.vertx.rxjava.redis.RedisClient.lastsaveObservable() use RedisClient.rxLastsave() instead
io.vertx.rxjava.redis.client.RedisAPI.lastsaveObservable() use RedisAPI.rxLastsave() instead
io.vertx.rxjava.redis.client.RedisAPI.latencyObservable(List<String>) use RedisAPI.rxLatency(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.lindexObservable(String, int) use RedisTransaction.rxLindex(java.lang.String, int) instead
io.vertx.rxjava.redis.RedisClient.lindexObservable(String, int) use RedisClient.rxLindex(java.lang.String, int) instead
io.vertx.rxjava.redis.client.RedisAPI.lindexObservable(String, String) use RedisAPI.rxLindex(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.linkObservable(String, String) use FileSystem.rxLink(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.linsertObservable(String, InsertOptions, String, String) use RedisTransaction.rxLinsert(java.lang.String, io.vertx.redis.op.InsertOptions, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.linsertObservable(String, InsertOptions, String, String) use RedisClient.rxLinsert(java.lang.String, io.vertx.redis.op.InsertOptions, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.linsertObservable(String, String, String, String) use RedisAPI.rxLinsert(java.lang.String, java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.datagram.DatagramSocket.listenMulticastGroupObservable(String) use DatagramSocket.rxListenMulticastGroup(java.lang.String) instead
io.vertx.rxjava.core.datagram.DatagramSocket.listenMulticastGroupObservable(String, String, String) use DatagramSocket.rxListenMulticastGroup(java.lang.String) instead
io.vertx.rxjava.core.net.NetServer.listenObservable() use NetServer.rxListen() instead
io.vertx.rxjava.core.http.HttpServer.listenObservable() use HttpServer.rxListen(int, java.lang.String) instead
io.vertx.rxjava.ext.shell.term.TermServer.listenObservable() use TermServer.rxListen() instead
io.vertx.rxjava.ext.shell.ShellServer.listenObservable() use ShellServer.rxListen() instead
io.vertx.rxjava.ext.stomp.StompServer.listenObservable() use StompServer.rxListen() instead
io.vertx.rxjava.core.net.NetServer.listenObservable(int) use NetServer.rxListen() instead
io.vertx.rxjava.core.http.HttpServer.listenObservable(int) use HttpServer.rxListen(int, java.lang.String) instead
io.vertx.rxjava.ext.stomp.StompServer.listenObservable(int) use StompServer.rxListen() instead
io.vertx.rxjava.core.net.NetServer.listenObservable(int, String) use NetServer.rxListen() instead
io.vertx.rxjava.core.http.HttpServer.listenObservable(int, String) use HttpServer.rxListen(int, java.lang.String) instead
io.vertx.rxjava.core.datagram.DatagramSocket.listenObservable(int, String) use DatagramSocket.rxListen(int, java.lang.String) instead
io.vertx.rxjava.ext.stomp.StompServer.listenObservable(int, String) use StompServer.rxListen() instead
io.vertx.rxjava.core.net.NetServer.listenObservable(SocketAddress) use NetServer.rxListen() instead
io.vertx.rxjava.core.http.HttpServer.listenObservable(SocketAddress) use HttpServer.rxListen(int, java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoClient.listIndexesObservable(String) use MongoClient.rxListIndexes(java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoService.listIndexesObservable(String)
io.vertx.rxjava.redis.RedisTransaction.llenObservable(String) use RedisTransaction.rxLlen(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.llenObservable(String) use RedisClient.rxLlen(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.llenObservable(String) use RedisAPI.rxLlen(java.lang.String) instead
io.vertx.ext.auth.oauth2.OAuth2Auth.loadJWK(Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.loadJWK(Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.loadJWK(Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.loadJWKObservable() use OAuth2Auth.rxLoadJWK() instead
io.vertx.rxjava.ext.auth.oauth2.AccessToken.logoutObservable() use AccessToken.rxLogout() instead
io.vertx.rxjava.redis.client.RedisAPI.lolwutObservable(List<String>) use RedisAPI.rxLolwut(java.util.List<java.lang.String>) instead
io.vertx.rxjava.core.dns.DnsClient.lookup4Observable(String) use DnsClient.rxLookup4(java.lang.String) instead
io.vertx.rxjava.core.dns.DnsClient.lookup6Observable(String) use DnsClient.rxLookup6(java.lang.String) instead
io.vertx.rxjava.core.dns.DnsClient.lookupObservable(String) use DnsClient.rxLookup(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.lpopObservable(String) use RedisTransaction.rxLpop(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.lpopObservable(String) use RedisClient.rxLpop(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.lpopObservable(String) use RedisAPI.rxLpop(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.lpropsObservable(String) use FileSystem.rxLprops(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.lpushManyObservable(String, List<String>) use RedisTransaction.rxLpushMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.lpushManyObservable(String, List<String>) use RedisClient.rxLpushMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.lpushObservable(List<String>) use RedisAPI.rxLpush(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.lpushObservable(String, String) use RedisTransaction.rxLpush(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.lpushObservable(String, String) use RedisClient.rxLpush(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.lpushxObservable(List<String>) use RedisAPI.rxLpushx(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.lpushxObservable(String, String) use RedisTransaction.rxLpushx(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.lpushxObservable(String, String) use RedisClient.rxLpushx(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.lrangeObservable(String, long, long) use RedisTransaction.rxLrange(java.lang.String, long, long) instead
io.vertx.rxjava.redis.RedisClient.lrangeObservable(String, long, long) use RedisClient.rxLrange(java.lang.String, long, long) instead
io.vertx.rxjava.redis.client.RedisAPI.lrangeObservable(String, String, String) use RedisAPI.rxLrange(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.lremObservable(String, long, String) use RedisTransaction.rxLrem(java.lang.String, long, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.lremObservable(String, long, String) use RedisClient.rxLrem(java.lang.String, long, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.lremObservable(String, String, String) use RedisAPI.rxLrem(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.lsetObservable(String, long, String) use RedisTransaction.rxLset(java.lang.String, long, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.lsetObservable(String, long, String) use RedisClient.rxLset(java.lang.String, long, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.lsetObservable(String, String, String) use RedisAPI.rxLset(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.ltrimObservable(String, long, long) use RedisTransaction.rxLtrim(java.lang.String, long, long) instead
io.vertx.rxjava.redis.RedisClient.ltrimObservable(String, long, long) use RedisClient.rxLtrim(java.lang.String, long, long) instead
io.vertx.rxjava.redis.client.RedisAPI.ltrimObservable(String, String, String) use RedisAPI.rxLtrim(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.sentinel.RedisSentinel.masterObservable(String) use RedisSentinel.rxMaster(java.lang.String) instead
io.vertx.rxjava.redis.sentinel.RedisSentinel.mastersObservable() use RedisSentinel.rxMasters() instead
io.vertx.rxjava.redis.client.RedisAPI.memoryObservable(List<String>) use RedisAPI.rxMemory(java.util.List<java.lang.String>) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.messageCountObservable(String) use RabbitMQClient.rxMessageCount(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.mgetManyObservable(List<String>) use RedisTransaction.rxMgetMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.mgetManyObservable(List<String>) use RedisClient.rxMgetMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.mgetObservable(List<String>) use RedisAPI.rxMget(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.mgetObservable(String) use RedisTransaction.rxMget(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.mgetObservable(String) use RedisClient.rxMget(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.migrateObservable(List<String>) use RedisAPI.rxMigrate(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.migrateObservable(String, int, String, int, long, MigrateOptions) use RedisTransaction.rxMigrate(java.lang.String, int, java.lang.String, int, long, io.vertx.redis.op.MigrateOptions) instead
io.vertx.rxjava.redis.RedisClient.migrateObservable(String, int, String, int, long, MigrateOptions) use RedisClient.rxMigrate(java.lang.String, int, java.lang.String, int, long, io.vertx.redis.op.MigrateOptions) instead
io.vertx.rxjava.core.file.FileSystem.mkdirObservable(String) use FileSystem.rxMkdir(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.mkdirObservable(String, String) use FileSystem.rxMkdir(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.mkdirsObservable(String) use FileSystem.rxMkdirs(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.mkdirsObservable(String, String) use FileSystem.rxMkdirs(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.moduleObservable(List<String>) use RedisAPI.rxModule(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.monitorObservable() use RedisTransaction.rxMonitor() instead
io.vertx.rxjava.redis.RedisClient.monitorObservable() use RedisClient.rxMonitor() instead
io.vertx.rxjava.redis.client.RedisAPI.monitorObservable() use RedisAPI.rxMonitor() instead
io.vertx.rxjava.redis.RedisTransaction.moveObservable(String, int) use RedisTransaction.rxMove(java.lang.String, int) instead
io.vertx.rxjava.redis.RedisClient.moveObservable(String, int) use RedisClient.rxMove(java.lang.String, int) instead
io.vertx.rxjava.core.file.FileSystem.moveObservable(String, String) use FileSystem.rxMove(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.moveObservable(String, String) use RedisAPI.rxMove(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.moveObservable(String, String, CopyOptions) use FileSystem.rxMove(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.msetnxObservable(JsonObject) use RedisTransaction.rxMsetnx(io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.redis.RedisClient.msetnxObservable(JsonObject) use RedisClient.rxMsetnx(io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.redis.client.RedisAPI.msetnxObservable(List<String>) use RedisAPI.rxMsetnx(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.msetObservable(JsonObject) use RedisTransaction.rxMset(io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.redis.RedisClient.msetObservable(JsonObject) use RedisClient.rxMset(io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.redis.client.RedisAPI.msetObservable(List<String>) use RedisAPI.rxMset(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.multiObservable() use RedisTransaction.rxMulti() instead
io.vertx.rxjava.redis.client.RedisAPI.multiObservable() use RedisAPI.rxMulti() instead
io.vertx.core.http.HttpServerRequest.netSocket() instead use HttpServerRequest.toNetSocket(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.net.NetSocket>>)
io.vertx.rxjava.core.http.HttpServerRequest.netSocket()
io.vertx.reactivex.core.http.HttpServerRequest.netSocket()
io.vertx.rxjava.redis.client.RedisAPI.objectObservable(List<String>) use RedisAPI.rxObject(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.objectObservable(String, ObjectCmd) use RedisTransaction.rxObject(java.lang.String, io.vertx.redis.op.ObjectCmd) instead
io.vertx.rxjava.redis.RedisClient.objectObservable(String, ObjectCmd) use RedisClient.rxObject(java.lang.String, io.vertx.redis.op.ObjectCmd) instead
io.vertx.rxjava.ext.stomp.StompServerHandler.onAuthenticationRequestObservable(StompServerConnection, String, String) use StompServerHandler.rxOnAuthenticationRequest(io.vertx.rxjava.ext.stomp.StompServerConnection, java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.Future.onCompleteObservable() use Future.rxOnComplete() instead
io.vertx.rxjava.core.CompositeFuture.onCompleteObservable()
io.vertx.rxjava.core.file.FileSystem.openObservable(String, OpenOptions) use FileSystem.rxOpen(java.lang.String, io.vertx.core.file.OpenOptions) instead
io.vertx.core.http.HttpClient.options(int, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.options(int, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.options(int, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.options(RequestOptions, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.options(RequestOptions, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.options(RequestOptions, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.options(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.options(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.options(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.options(String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.options(String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.options(String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.optionsAbs(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.optionsAbs(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.optionsAbs(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.optionsNow(int, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.optionsNow(int, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.optionsNow(int, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.optionsNow(RequestOptions, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.optionsNow(RequestOptions, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.optionsNow(RequestOptions, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.optionsNow(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.optionsNow(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.optionsNow(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.optionsNow(String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.optionsNow(String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.optionsNow(String, String, Handler<HttpClientResponse>)
io.vertx.rxjava.ext.web.handler.BasicAuthHandler.parseCredentialsObservable(RoutingContext) use BasicAuthHandler.rxParseCredentials(io.vertx.rxjava.ext.web.RoutingContext) instead
io.vertx.rxjava.ext.web.handler.DigestAuthHandler.parseCredentialsObservable(RoutingContext) use DigestAuthHandler.rxParseCredentials(io.vertx.rxjava.ext.web.RoutingContext) instead
io.vertx.rxjava.ext.web.handler.JWTAuthHandler.parseCredentialsObservable(RoutingContext) use JWTAuthHandler.rxParseCredentials(io.vertx.rxjava.ext.web.RoutingContext) instead
io.vertx.rxjava.ext.web.handler.RedirectAuthHandler.parseCredentialsObservable(RoutingContext) use RedirectAuthHandler.rxParseCredentials(io.vertx.rxjava.ext.web.RoutingContext) instead
io.vertx.rxjava.ext.web.handler.ChainAuthHandler.parseCredentialsObservable(RoutingContext) use ChainAuthHandler.rxParseCredentials(io.vertx.rxjava.ext.web.RoutingContext) instead
io.vertx.rxjava.ext.web.handler.OAuth2AuthHandler.parseCredentialsObservable(RoutingContext) use OAuth2AuthHandler.rxParseCredentials(io.vertx.rxjava.ext.web.RoutingContext) instead
io.vertx.mqtt.MqttAuth.password() use instead MqttAuth.getPassword()
io.vertx.core.http.HttpClientRequest.pause() this method will be removed in Vert.x 4
io.vertx.rxjava.core.http.HttpClientRequest.pause()
io.vertx.reactivex.core.http.HttpClientRequest.pause()
io.vertx.rxjava.redis.RedisTransaction.persistObservable(String) use RedisTransaction.rxPersist(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.persistObservable(String) use RedisClient.rxPersist(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.persistObservable(String) use RedisAPI.rxPersist(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.pexpireatObservable(String, long) use RedisTransaction.rxPexpireat(java.lang.String, long) instead
io.vertx.rxjava.redis.RedisClient.pexpireatObservable(String, long) use RedisClient.rxPexpireat(java.lang.String, long) instead
io.vertx.rxjava.redis.client.RedisAPI.pexpireatObservable(String, String) use RedisAPI.rxPexpireat(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.pexpireObservable(String, long) use RedisTransaction.rxPexpire(java.lang.String, long) instead
io.vertx.rxjava.redis.RedisClient.pexpireObservable(String, long) use RedisClient.rxPexpire(java.lang.String, long) instead
io.vertx.rxjava.redis.client.RedisAPI.pexpireObservable(String, String) use RedisAPI.rxPexpire(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.pfaddManyObservable(String, List<String>) use RedisTransaction.rxPfaddMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.pfaddManyObservable(String, List<String>) use RedisClient.rxPfaddMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.pfaddObservable(List<String>) use RedisAPI.rxPfadd(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.pfaddObservable(String, String) use RedisTransaction.rxPfadd(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.pfaddObservable(String, String) use RedisClient.rxPfadd(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.pfcountManyObservable(List<String>) use RedisTransaction.rxPfcountMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.pfcountManyObservable(List<String>) use RedisClient.rxPfcountMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.pfcountObservable(List<String>) use RedisAPI.rxPfcount(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.pfcountObservable(String) use RedisTransaction.rxPfcount(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.pfcountObservable(String) use RedisClient.rxPfcount(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.pfdebugObservable(List<String>) use RedisAPI.rxPfdebug(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.pfmergeObservable(List<String>) use RedisAPI.rxPfmerge(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.pfmergeObservable(String, List<String>) use RedisTransaction.rxPfmerge(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.pfmergeObservable(String, List<String>) use RedisClient.rxPfmerge(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.pfselftestObservable() use RedisAPI.rxPfselftest() instead
io.vertx.rxjava.redis.RedisTransaction.pingObservable() use RedisTransaction.rxPing() instead
io.vertx.rxjava.redis.RedisClient.pingObservable() use RedisClient.rxPing() instead
io.vertx.rxjava.core.http.HttpConnection.pingObservable(Buffer) use HttpConnection.rxPing(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.redis.client.RedisAPI.pingObservable(List<String>) use RedisAPI.rxPing(java.util.List<java.lang.String>) instead
io.vertx.rxjava.core.net.NetSocket.pipeToObservable(WriteStream<Buffer>) use NetSocket.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.core.file.AsyncFile.pipeToObservable(WriteStream<Buffer>) use AsyncFile.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.core.http.HttpClientResponse.pipeToObservable(WriteStream<Buffer>) use HttpClientResponse.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.core.http.ServerWebSocket.pipeToObservable(WriteStream<Buffer>) use ServerWebSocket.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.core.http.WebSocket.pipeToObservable(WriteStream<Buffer>) use WebSocket.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.core.http.HttpServerFileUpload.pipeToObservable(WriteStream<Buffer>) use HttpServerFileUpload.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.core.http.HttpServerRequest.pipeToObservable(WriteStream<Buffer>) use HttpServerRequest.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.core.parsetools.RecordParser.pipeToObservable(WriteStream<Buffer>) use RecordParser.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket.pipeToObservable(WriteStream<Buffer>) use SockJSSocket.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.core.datagram.DatagramSocket.pipeToObservable(WriteStream<DatagramPacket>) use DatagramSocket.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.datagram.DatagramPacket>) instead
io.vertx.rxjava.core.http.HttpClientRequest.pipeToObservable(WriteStream<HttpClientResponse>) use HttpClientRequest.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.http.HttpClientResponse>) instead
io.vertx.rxjava.ext.sql.SQLRowStream.pipeToObservable(WriteStream<JsonArray>) use SQLRowStream.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.core.json.JsonArray>) instead
io.vertx.rxjava.core.parsetools.JsonParser.pipeToObservable(WriteStream<JsonEvent>) use JsonParser.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.parsetools.JsonEvent>) instead
io.vertx.rxjava.core.TimeoutStream.pipeToObservable(WriteStream<Long>) use TimeoutStream.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<java.lang.Long>) instead
io.vertx.rxjava.core.eventbus.MessageConsumer.pipeToObservable(WriteStream<Message<T>>) use MessageConsumer.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.eventbus.Message<T>>) instead
io.vertx.rxjava.rabbitmq.RabbitMQConsumer.pipeToObservable(WriteStream<RabbitMQMessage>) use RabbitMQConsumer.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.rabbitmq.RabbitMQMessage>) instead
io.vertx.rxjava.redis.client.RedisConnection.pipeToObservable(WriteStream<Response>) use RedisConnection.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.redis.client.Response>) instead
io.vertx.rxjava.ext.unit.report.TestSuiteReport.pipeToObservable(WriteStream<TestCaseReport>) use TestSuiteReport.rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.ext.unit.report.TestCaseReport>) instead
io.vertx.kafka.client.consumer.KafkaReadStream.poll(long, Handler<AsyncResult<ConsumerRecords<K, V>>>) use KafkaReadStream.poll(Duration, Handler)
io.vertx.kafka.client.consumer.KafkaConsumer.poll(long, Handler<AsyncResult<KafkaConsumerRecords<K, V>>>) use KafkaConsumer.poll(Duration, Handler)
io.vertx.rxjava.kafka.client.consumer.KafkaConsumer.poll(long, Handler<AsyncResult<KafkaConsumerRecords<K, V>>>)
io.vertx.reactivex.kafka.client.consumer.KafkaConsumer.poll(long, Handler<AsyncResult<KafkaConsumerRecords<K, V>>>)
io.vertx.kafka.client.consumer.KafkaReadStream.pollTimeout(long) use KafkaReadStream.pollTimeout(Duration)
io.vertx.kafka.client.consumer.KafkaConsumer.pollTimeout(long) use KafkaConsumer.pollTimeout(Duration)
io.vertx.rxjava.kafka.client.consumer.KafkaConsumer.pollTimeout(long)
io.vertx.reactivex.kafka.client.consumer.KafkaConsumer.pollTimeout(long)
io.vertx.core.http.HttpClient.post(int, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.post(int, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.post(int, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.post(RequestOptions, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.post(RequestOptions, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.post(RequestOptions, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.post(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.post(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.post(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.post(String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.post(String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.post(String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.postAbs(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.postAbs(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.postAbs(String, Handler<HttpClientResponse>)
io.vertx.rxjava.redis.client.RedisAPI.postObservable(List<String>) use RedisAPI.rxPost(java.util.List<java.lang.String>) instead
io.vertx.ext.web.RoutingContext.preferredLocale() Use RoutingContext.preferredLanguage() instead
io.vertx.rxjava.ext.web.RoutingContext.preferredLocale()
io.vertx.reactivex.ext.web.RoutingContext.preferredLocale()
io.vertx.rxjava.core.file.FileSystem.propsObservable(String) use FileSystem.rxProps(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.psetexObservable(String, long, String) use RedisTransaction.rxPsetex(java.lang.String, long, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.psetexObservable(String, long, String) use RedisClient.rxPsetex(java.lang.String, long, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.psetexObservable(String, String, String) use RedisAPI.rxPsetex(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.psubscribeManyObservable(List<String>) use RedisTransaction.rxPsubscribeMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.psubscribeManyObservable(List<String>) use RedisClient.rxPsubscribeMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.psubscribeObservable(List<String>) use RedisAPI.rxPsubscribe(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.psubscribeObservable(String) use RedisTransaction.rxPsubscribe(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.psubscribeObservable(String) use RedisClient.rxPsubscribe(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.psyncObservable(String, String) use RedisAPI.rxPsync(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.pttlObservable(String) use RedisTransaction.rxPttl(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.pttlObservable(String) use RedisClient.rxPttl(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.pttlObservable(String) use RedisAPI.rxPttl(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.publishObservable(String, String) use RedisTransaction.rxPublish(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.publishObservable(String, String) use RedisClient.rxPublish(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.publishObservable(String, String) use RedisAPI.rxPublish(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.pubsubChannelsObservable(String) use RedisTransaction.rxPubsubChannels(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.pubsubChannelsObservable(String) use RedisClient.rxPubsubChannels(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.pubsubNumpatObservable() use RedisTransaction.rxPubsubNumpat() instead
io.vertx.rxjava.redis.RedisClient.pubsubNumpatObservable() use RedisClient.rxPubsubNumpat() instead
io.vertx.rxjava.redis.RedisTransaction.pubsubNumsubObservable(List<String>) use RedisTransaction.rxPubsubNumsub(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.pubsubNumsubObservable(List<String>) use RedisClient.rxPubsubNumsub(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.pubsubObservable(List<String>) use RedisAPI.rxPubsub(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.punsubscribeObservable(List<String>) use RedisTransaction.rxPunsubscribe(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.punsubscribeObservable(List<String>) use RedisClient.rxPunsubscribe(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.punsubscribeObservable(List<String>) use RedisAPI.rxPunsubscribe(java.util.List<java.lang.String>) instead
io.vertx.rxjava.core.http.HttpServerResponse.pushObservable(HttpMethod, String) use HttpServerResponse.rxPush(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.http.HttpServerResponse.pushObservable(HttpMethod, String, MultiMap) use HttpServerResponse.rxPush(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.http.HttpServerResponse.pushObservable(HttpMethod, String, String) use HttpServerResponse.rxPush(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.http.HttpServerResponse.pushObservable(HttpMethod, String, String, MultiMap) use HttpServerResponse.rxPush(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String) instead
io.vertx.core.http.HttpClient.put(int, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.put(int, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.put(int, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.put(RequestOptions, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.put(RequestOptions, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.put(RequestOptions, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.put(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.put(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.put(String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.put(String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.put(String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.put(String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.putAbs(String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.putAbs(String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.putAbs(String, Handler<HttpClientResponse>)
io.vertx.rxjava.core.shareddata.AsyncMap.putIfAbsentObservable(K, V) use AsyncMap.rxPutIfAbsent(K, V) instead
io.vertx.rxjava.core.shareddata.AsyncMap.putIfAbsentObservable(K, V, long) use AsyncMap.rxPutIfAbsent(K, V) instead
io.vertx.rxjava.core.shareddata.AsyncMap.putObservable(K, V) use AsyncMap.rxPut(K, V) instead
io.vertx.rxjava.core.shareddata.AsyncMap.putObservable(K, V, long) use AsyncMap.rxPut(K, V) instead
io.vertx.rxjava.ext.web.sstore.SessionStore.putObservable(Session) use SessionStore.rxPut(io.vertx.rxjava.ext.web.Session) instead
io.vertx.rxjava.ext.sql.SQLConnection.queryObservable(String) use SQLConnection.rxQuery(java.lang.String) instead
io.vertx.rxjava.ext.sql.SQLClient.queryObservable(String) use SQLClient.rxQuery(java.lang.String) instead
io.vertx.rxjava.ext.asyncsql.PostgreSQLClient.querySingleObservable(String) use PostgreSQLClient.rxQuerySingle(java.lang.String) instead
io.vertx.rxjava.ext.asyncsql.AsyncSQLClient.querySingleObservable(String) use AsyncSQLClient.rxQuerySingle(java.lang.String) instead
io.vertx.rxjava.ext.asyncsql.MySQLClient.querySingleObservable(String) use MySQLClient.rxQuerySingle(java.lang.String) instead
io.vertx.rxjava.ext.jdbc.JDBCClient.querySingleObservable(String) use JDBCClient.rxQuerySingle(java.lang.String) instead
io.vertx.rxjava.ext.sql.SQLConnection.querySingleObservable(String) use SQLConnection.rxQuerySingle(java.lang.String) instead
io.vertx.rxjava.ext.sql.SQLClient.querySingleObservable(String) use SQLClient.rxQuerySingle(java.lang.String) instead
io.vertx.rxjava.ext.asyncsql.PostgreSQLClient.querySingleWithParamsObservable(String, JsonArray) use PostgreSQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.asyncsql.AsyncSQLClient.querySingleWithParamsObservable(String, JsonArray) use AsyncSQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.asyncsql.MySQLClient.querySingleWithParamsObservable(String, JsonArray) use MySQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.jdbc.JDBCClient.querySingleWithParamsObservable(String, JsonArray) use JDBCClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.sql.SQLConnection.querySingleWithParamsObservable(String, JsonArray) use SQLConnection.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.sql.SQLClient.querySingleWithParamsObservable(String, JsonArray) use SQLClient.rxQuerySingleWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.sql.SQLConnection.queryStreamObservable(String) use SQLConnection.rxQueryStream(java.lang.String) instead
io.vertx.rxjava.ext.sql.SQLClient.queryStreamObservable(String) use SQLClient.rxQueryStream(java.lang.String) instead
io.vertx.rxjava.ext.sql.SQLConnection.queryStreamWithParamsObservable(String, JsonArray) use SQLConnection.rxQueryStreamWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.sql.SQLClient.queryStreamWithParamsObservable(String, JsonArray) use SQLClient.rxQueryStreamWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.sql.SQLConnection.queryWithParamsObservable(String, JsonArray) use SQLConnection.rxQueryWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.sql.SQLClient.queryWithParamsObservable(String, JsonArray) use SQLClient.rxQueryWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.queueBindObservable(String, String, String) use RabbitMQClient.rxQueueBind(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.queueBindObservable(String, String, String, Map<String, Object>) use RabbitMQClient.rxQueueBind(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rabbitmq.RabbitMQClient.queueDeclare(String, boolean, boolean, boolean, Map<String, String>, Handler<AsyncResult<JsonObject>>) See RabbitMQClient.queueDeclare(String, boolean, boolean, boolean, JsonObject, Handler) instead for support for more than just String config values
io.vertx.rxjava.rabbitmq.RabbitMQClient.queueDeclareAutoObservable() use RabbitMQClient.rxQueueDeclareAuto() instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.queueDeclareObservable(String, boolean, boolean, boolean) use RabbitMQClient.rxQueueDeclare(java.lang.String, boolean, boolean, boolean) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.queueDeclareObservable(String, boolean, boolean, boolean, JsonObject) use RabbitMQClient.rxQueueDeclare(java.lang.String, boolean, boolean, boolean) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.queueDeleteIfObservable(String, boolean, boolean) use RabbitMQClient.rxQueueDeleteIf(java.lang.String, boolean, boolean) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.queueDeleteObservable(String) use RabbitMQClient.rxQueueDelete(java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.queueUnbindObservable(String, String, String) use RabbitMQClient.rxQueueUnbind(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.queueUnbindObservable(String, String, String, Map<String, Object>) use RabbitMQClient.rxQueueUnbind(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.randomkeyObservable() use RedisTransaction.rxRandomkey() instead
io.vertx.rxjava.redis.RedisClient.randomkeyObservable() use RedisClient.rxRandomkey() instead
io.vertx.rxjava.redis.client.RedisAPI.randomkeyObservable() use RedisAPI.rxRandomkey() instead
io.vertx.ext.auth.oauth2.OAuth2Auth.rbacHandler(OAuth2RBAC)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.rbacHandler(OAuth2RBAC)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.rbacHandler(OAuth2RBAC)
io.vertx.rxjava.core.file.FileSystem.readDirObservable(String) use FileSystem.rxReadDir(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.readDirObservable(String, String) use FileSystem.rxReadDir(java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.readFileObservable(String) use FileSystem.rxReadFile(java.lang.String) instead
io.vertx.rxjava.core.file.AsyncFile.readObservable(Buffer, int, long, int) use AsyncFile.rxRead(io.vertx.rxjava.core.buffer.Buffer, int, long, int) instead
io.vertx.rxjava.redis.client.RedisAPI.readonlyObservable() use RedisAPI.rxReadonly() instead
io.vertx.rxjava.core.file.FileSystem.readSymlinkObservable(String) use FileSystem.rxReadSymlink(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.readwriteObservable() use RedisAPI.rxReadwrite() instead
io.vertx.rxjava.ext.auth.oauth2.AccessToken.refreshObservable() use AccessToken.rxRefresh() instead
io.vertx.ext.auth.oauth2.AccessToken.refreshToken() refresh tokens are specific to the provider and should not be handled by the consumer. Tokens are still available as an opaque string.
io.vertx.rxjava.ext.auth.oauth2.AccessToken.refreshToken()
io.vertx.reactivex.ext.auth.oauth2.AccessToken.refreshToken()
io.vertx.rxjava.ext.shell.command.CommandRegistry.registerCommandObservable(Command) use CommandRegistry.rxRegisterCommand(io.vertx.rxjava.ext.shell.command.Command) instead
io.vertx.rxjava.ext.shell.command.CommandRegistry.registerCommandsObservable(List<Command>) use CommandRegistry.rxRegisterCommands(java.util.List<io.vertx.rxjava.ext.shell.command.Command>) instead
io.vertx.serviceproxy.ProxyHelper.registerLocalService(Class<T>, Vertx, T, String) use instead ServiceBinder
io.vertx.serviceproxy.ProxyHelper.registerLocalService(Class<T>, Vertx, T, String, boolean, long) use instead ServiceBinder
io.vertx.serviceproxy.ProxyHelper.registerLocalService(Class<T>, Vertx, T, String, long) use instead ServiceBinder
io.vertx.serviceproxy.ProxyHelper.registerService(Class<T>, Vertx, T, String) use instead ServiceBinder
io.vertx.serviceproxy.ProxyHelper.registerService(Class<T>, Vertx, T, String, boolean, long) use instead ServiceBinder
io.vertx.serviceproxy.ProxyHelper.registerService(Class<T>, Vertx, T, String, long) use instead ServiceBinder
io.vertx.ext.mongo.MongoClient.remove(String, JsonObject, Handler<AsyncResult<Void>>) use instead MongoClient.removeDocuments(String, JsonObject, Handler)
io.vertx.ext.mongo.MongoService.remove(String, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.remove(String, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoService.remove(String, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoClient.remove(String, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoService.remove(String, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.removeDocumentObservable(String, JsonObject) use MongoClient.rxRemoveDocument(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.removeDocumentObservable(String, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.removeDocumentsObservable(String, JsonObject) use MongoClient.rxRemoveDocuments(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.removeDocumentsObservable(String, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.removeDocumentsWithOptionsObservable(String, JsonObject, WriteOption) use MongoClient.rxRemoveDocumentsWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.WriteOption) instead
io.vertx.rxjava.ext.mongo.MongoService.removeDocumentsWithOptionsObservable(String, JsonObject, WriteOption)
io.vertx.rxjava.ext.mongo.MongoClient.removeDocumentWithOptionsObservable(String, JsonObject, WriteOption) use MongoClient.rxRemoveDocumentWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.WriteOption) instead
io.vertx.rxjava.ext.mongo.MongoService.removeDocumentWithOptionsObservable(String, JsonObject, WriteOption)
io.vertx.rxjava.core.shareddata.AsyncMap.removeIfPresentObservable(K, V) use AsyncMap.rxRemoveIfPresent(K, V) instead
io.vertx.rxjava.core.shareddata.AsyncMap.removeObservable(K) use AsyncMap.rxRemove(K) instead
io.vertx.rxjava.ext.mongo.MongoClient.removeObservable(String, JsonObject) use MongoClient.rxRemove(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.removeObservable(String, JsonObject)
io.vertx.ext.mongo.MongoClient.removeOne(String, JsonObject, Handler<AsyncResult<Void>>) instead use MongoClient.removeDocument(String, JsonObject, Handler)
io.vertx.ext.mongo.MongoService.removeOne(String, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.removeOne(String, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoService.removeOne(String, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoClient.removeOne(String, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoService.removeOne(String, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.removeOneObservable(String, JsonObject) use MongoClient.rxRemoveOne(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.removeOneObservable(String, JsonObject)
io.vertx.ext.mongo.MongoClient.removeOneWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>) instead use MongoClient.removeDocumentsWithOptions(String, JsonObject, WriteOption, Handler)
io.vertx.ext.mongo.MongoService.removeOneWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.removeOneWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoService.removeOneWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoClient.removeOneWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoService.removeOneWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.removeOneWithOptionsObservable(String, JsonObject, WriteOption) use MongoClient.rxRemoveOneWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.WriteOption) instead
io.vertx.rxjava.ext.mongo.MongoService.removeOneWithOptionsObservable(String, JsonObject, WriteOption)
io.vertx.ext.mongo.MongoClient.removeWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>) instead use MongoClient.removeDocumentsWithOptions(String, JsonObject, WriteOption, Handler)
io.vertx.ext.mongo.MongoService.removeWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.removeWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoService.removeWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoClient.removeWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoService.removeWithOptions(String, JsonObject, WriteOption, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.removeWithOptionsObservable(String, JsonObject, WriteOption) use MongoClient.rxRemoveWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.WriteOption) instead
io.vertx.rxjava.ext.mongo.MongoService.removeWithOptionsObservable(String, JsonObject, WriteOption)
io.vertx.rxjava.redis.RedisTransaction.renamenxObservable(String, String) use RedisTransaction.rxRenamenx(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.renamenxObservable(String, String) use RedisClient.rxRenamenx(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.renamenxObservable(String, String) use RedisAPI.rxRenamenx(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.renameObservable(String, String) use RedisTransaction.rxRename(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.renameObservable(String, String) use RedisClient.rxRename(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.renameObservable(String, String) use RedisAPI.rxRename(java.lang.String, java.lang.String) instead
io.vertx.ext.web.templ.TemplateEngine.render(RoutingContext, String, Handler<AsyncResult<Buffer>>) use TemplateEngine.render(RoutingContext, String, String, Handler)
io.vertx.ext.web.templ.FreeMarkerTemplateEngine.render(RoutingContext, String, Handler<AsyncResult<Buffer>>)
io.vertx.ext.web.templ.PebbleTemplateEngine.render(RoutingContext, String, Handler<AsyncResult<Buffer>>)
io.vertx.ext.web.templ.JadeTemplateEngine.render(RoutingContext, String, Handler<AsyncResult<Buffer>>)
io.vertx.ext.web.templ.ThymeleafTemplateEngine.render(RoutingContext, String, Handler<AsyncResult<Buffer>>)
io.vertx.ext.web.templ.HandlebarsTemplateEngine.render(RoutingContext, String, Handler<AsyncResult<Buffer>>)
io.vertx.ext.web.templ.RockerTemplateEngine.render(RoutingContext, String, Handler<AsyncResult<Buffer>>)
io.vertx.ext.web.templ.MVELTemplateEngine.render(RoutingContext, String, Handler<AsyncResult<Buffer>>)
io.vertx.rxjava.ext.web.templ.TemplateEngine.render(RoutingContext, String, Handler<AsyncResult<Buffer>>)
io.vertx.reactivex.ext.web.templ.TemplateEngine.render(RoutingContext, String, Handler<AsyncResult<Buffer>>)
io.vertx.ext.web.templ.TemplateEngine.render(RoutingContext, String, String, Handler<AsyncResult<Buffer>>)
io.vertx.rxjava.ext.web.templ.TemplateEngine.render(RoutingContext, String, String, Handler<AsyncResult<Buffer>>)
io.vertx.reactivex.ext.web.templ.TemplateEngine.render(RoutingContext, String, String, Handler<AsyncResult<Buffer>>)
io.vertx.rxjava.ext.web.common.template.TemplateEngine.renderObservable(JsonObject, String) use TemplateEngine.rxRender(io.vertx.core.json.JsonObject, java.lang.String) instead
io.vertx.rxjava.ext.web.common.template.TemplateEngine.renderObservable(Map<String, Object>, String) use TemplateEngine.rxRender(io.vertx.core.json.JsonObject, java.lang.String) instead
io.vertx.rxjava.ext.web.templ.TemplateEngine.renderObservable(RoutingContext, String) use TemplateEngine.rxRender(io.vertx.rxjava.ext.web.RoutingContext, java.lang.String) instead
io.vertx.rxjava.ext.web.templ.TemplateEngine.renderObservable(RoutingContext, String, String) use TemplateEngine.rxRender(io.vertx.rxjava.ext.web.RoutingContext, java.lang.String) instead
io.vertx.ext.mongo.MongoClient.replace(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>) instead use MongoClient.replaceDocuments(String, JsonObject, JsonObject, Handler)
io.vertx.ext.mongo.MongoService.replace(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.replace(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoService.replace(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoClient.replace(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoService.replace(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.replaceDocumentsObservable(String, JsonObject, JsonObject) use MongoClient.rxReplaceDocuments(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.replaceDocumentsObservable(String, JsonObject, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.replaceDocumentsWithOptionsObservable(String, JsonObject, JsonObject, UpdateOptions) use MongoClient.rxReplaceDocumentsWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.UpdateOptions) instead
io.vertx.rxjava.ext.mongo.MongoService.replaceDocumentsWithOptionsObservable(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.rxjava.core.shareddata.AsyncMap.replaceIfPresentObservable(K, V, V) use AsyncMap.rxReplaceIfPresent(K, V, V) instead
io.vertx.rxjava.core.shareddata.AsyncMap.replaceObservable(K, V) use AsyncMap.rxReplace(K, V) instead
io.vertx.rxjava.ext.mongo.MongoClient.replaceObservable(String, JsonObject, JsonObject) use MongoClient.rxReplace(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.replaceObservable(String, JsonObject, JsonObject)
io.vertx.ext.mongo.MongoClient.replaceWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>) instead use MongoClient.replaceDocumentsWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler)
io.vertx.ext.mongo.MongoService.replaceWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.replaceWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoService.replaceWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoClient.replaceWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoService.replaceWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.replaceWithOptionsObservable(String, JsonObject, JsonObject, UpdateOptions) use MongoClient.rxReplaceWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.UpdateOptions) instead
io.vertx.rxjava.ext.mongo.MongoService.replaceWithOptionsObservable(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.rxjava.redis.client.RedisAPI.replconfObservable(List<String>) use RedisAPI.rxReplconf(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.replicaofObservable(String, String) use RedisAPI.rxReplicaof(java.lang.String, java.lang.String) instead
io.vertx.core.eventbus.Message.reply(Object, DeliveryOptions, Handler<AsyncResult<Message<R>>>) use Message.replyAndRequest(Object, DeliveryOptions, Handler)
io.vertx.rxjava.core.eventbus.Message.reply(Object, DeliveryOptions, Handler<AsyncResult<Message<R>>>)
io.vertx.reactivex.core.eventbus.Message.reply(Object, DeliveryOptions, Handler<AsyncResult<Message<R>>>)
io.vertx.core.eventbus.Message.reply(Object, Handler<AsyncResult<Message<R>>>) use Message.replyAndRequest(Object, Handler)
io.vertx.rxjava.core.eventbus.Message.reply(Object, Handler<AsyncResult<Message<R>>>)
io.vertx.reactivex.core.eventbus.Message.reply(Object, Handler<AsyncResult<Message<R>>>)
io.vertx.rxjava.core.eventbus.Message.replyAndRequestObservable(Object) use Message.rxReplyAndRequest(java.lang.Object) instead
io.vertx.rxjava.core.eventbus.Message.replyAndRequestObservable(Object, DeliveryOptions) use Message.rxReplyAndRequest(java.lang.Object) instead
io.vertx.rxjava.core.eventbus.Message.replyObservable(Object) use Message.rxReply(java.lang.Object) instead
io.vertx.rxjava.core.eventbus.Message.replyObservable(Object, DeliveryOptions) use Message.rxReply(java.lang.Object) instead
io.vertx.core.http.HttpClient.request(HttpMethod, int, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.request(HttpMethod, int, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.request(HttpMethod, int, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.request(HttpMethod, RequestOptions, Handler<HttpClientResponse>) this method will break in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>
io.vertx.rxjava.core.http.HttpClient.request(HttpMethod, RequestOptions, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.request(HttpMethod, RequestOptions, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.request(HttpMethod, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.request(HttpMethod, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.request(HttpMethod, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.request(HttpMethod, String, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.request(HttpMethod, String, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.request(HttpMethod, String, String, Handler<HttpClientResponse>)
io.vertx.core.http.HttpClient.requestAbs(HttpMethod, String, Handler<HttpClientResponse>) this method signature will change in Vert.x 4, the handler will use an Handler<AsyncResult<HttpClientResponse>>, you can use instead the WebClient
io.vertx.rxjava.core.http.HttpClient.requestAbs(HttpMethod, String, Handler<HttpClientResponse>)
io.vertx.reactivex.core.http.HttpClient.requestAbs(HttpMethod, String, Handler<HttpClientResponse>)
io.vertx.rxjava.core.eventbus.EventBus.requestObservable(String, Object) use EventBus.rxRequest(java.lang.String, java.lang.Object) instead
io.vertx.rxjava.core.eventbus.EventBus.requestObservable(String, Object, DeliveryOptions) use EventBus.rxRequest(java.lang.String, java.lang.Object) instead
io.vertx.rxjava.redis.sentinel.RedisSentinel.resetObservable(String) use RedisSentinel.rxReset(java.lang.String) instead
io.vertx.ext.unit.Completion.resolve(Future<T>) use Completion.resolve(Promise) instead
io.vertx.rxjava.core.dns.DnsClient.resolveAAAAObservable(String) use DnsClient.rxResolveAAAA(java.lang.String) instead
io.vertx.rxjava.core.dns.DnsClient.resolveAObservable(String) use DnsClient.rxResolveA(java.lang.String) instead
io.vertx.rxjava.core.dns.DnsClient.resolveCNAMEObservable(String) use DnsClient.rxResolveCNAME(java.lang.String) instead
io.vertx.rxjava.core.dns.DnsClient.resolveMXObservable(String) use DnsClient.rxResolveMX(java.lang.String) instead
io.vertx.rxjava.core.dns.DnsClient.resolveNSObservable(String) use DnsClient.rxResolveNS(java.lang.String) instead
io.vertx.rxjava.core.dns.DnsClient.resolvePTRObservable(String) use DnsClient.rxResolvePTR(java.lang.String) instead
io.vertx.rxjava.core.dns.DnsClient.resolveSRVObservable(String) use DnsClient.rxResolveSRV(java.lang.String) instead
io.vertx.rxjava.core.dns.DnsClient.resolveTXTObservable(String) use DnsClient.rxResolveTXT(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.restoreAskingObservable(List<String>) use RedisAPI.rxRestoreAsking(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.restoreObservable(List<String>) use RedisAPI.rxRestore(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.restoreObservable(String, long, String) use RedisTransaction.rxRestore(java.lang.String, long, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.restoreObservable(String, long, String) use RedisClient.rxRestore(java.lang.String, long, java.lang.String) instead
io.vertx.core.http.HttpClientRequest.resume() this method will be removed in Vert.x 4
io.vertx.rxjava.core.http.HttpClientRequest.resume()
io.vertx.reactivex.core.http.HttpClientRequest.resume()
io.vertx.rxjava.core.dns.DnsClient.reverseLookupObservable(String) use DnsClient.rxReverseLookup(java.lang.String) instead
io.vertx.rxjava.ext.auth.oauth2.AccessToken.revokeObservable(String) use AccessToken.rxRevoke(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.roleObservable() use RedisTransaction.rxRole() instead
io.vertx.rxjava.redis.RedisClient.roleObservable() use RedisClient.rxRole() instead
io.vertx.rxjava.redis.client.RedisAPI.roleObservable() use RedisAPI.rxRole() instead
io.vertx.rxjava.ext.sql.SQLConnection.rollbackObservable() use SQLConnection.rxRollback() instead
io.vertx.rxjava.redis.RedisTransaction.rpoplpushObservable(String, String) use RedisTransaction.rxRpoplpush(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.rpoplpushObservable(String, String) use RedisClient.rxRpoplpush(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.rpoplpushObservable(String, String) use RedisAPI.rxRpoplpush(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.rpopObservable(String) use RedisTransaction.rxRpop(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.rpopObservable(String) use RedisClient.rxRpop(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.rpopObservable(String) use RedisAPI.rxRpop(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.rpushManyObservable(String, List<String>) use RedisTransaction.rxRpushMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.rpushManyObservable(String, List<String>) use RedisClient.rxRpushMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.rpushObservable(List<String>) use RedisAPI.rxRpush(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.rpushObservable(String, String) use RedisTransaction.rxRpush(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.rpushObservable(String, String) use RedisClient.rxRpush(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.rpushxObservable(List<String>) use RedisAPI.rxRpushx(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.rpushxObservable(String, String) use RedisTransaction.rxRpushx(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.rpushxObservable(String, String) use RedisClient.rxRpushx(java.lang.String, java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoClient.runCommandObservable(String, JsonObject) use MongoClient.rxRunCommand(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.runCommandObservable(String, JsonObject)
io.vertx.rxjava.rabbitmq.RabbitMQClient.rxBasicCancel(String)
io.vertx.reactivex.rabbitmq.RabbitMQClient.rxBasicCancel(String)
io.vertx.rxjava.rabbitmq.RabbitMQClient.rxBasicConsume(String, String)
io.vertx.reactivex.rabbitmq.RabbitMQClient.rxBasicConsume(String, String)
io.vertx.rxjava.rabbitmq.RabbitMQClient.rxBasicConsume(String, String, boolean)
io.vertx.reactivex.rabbitmq.RabbitMQClient.rxBasicConsume(String, String, boolean)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.rxDecodeToken(String)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.rxDecodeToken(String)
io.vertx.rxjava.circuitbreaker.CircuitBreaker.rxExecuteCommand(Handler<Promise<T>>)
io.vertx.reactivex.circuitbreaker.CircuitBreaker.rxExecuteCommand(Handler<Promise<T>>)
io.vertx.rxjava.circuitbreaker.CircuitBreaker.rxExecuteCommandWithFallback(Handler<Promise<T>>, Function<Throwable, T>)
io.vertx.reactivex.circuitbreaker.CircuitBreaker.rxExecuteCommandWithFallback(Handler<Promise<T>>, Function<Throwable, T>)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.rxGetToken(JsonObject)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.rxGetToken(JsonObject)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.rxIntrospectToken(String)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.rxIntrospectToken(String)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.rxIntrospectToken(String, String)
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.rxIntrospectToken(String, String)
io.vertx.rxjava.ext.auth.User.rxIsAuthorised(String)
io.vertx.reactivex.ext.auth.User.rxIsAuthorised(String)
io.vertx.rxjava.ext.auth.User.rxIsAuthorized(String)
io.vertx.reactivex.ext.auth.User.rxIsAuthorized(String)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.rxLoadJWK()
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.rxLoadJWK()
io.vertx.rxjava.kafka.client.consumer.KafkaConsumer.rxPoll(long)
io.vertx.reactivex.kafka.client.consumer.KafkaConsumer.rxPoll(long)
io.vertx.rxjava.ext.mongo.MongoClient.rxRemove(String, JsonObject)
io.vertx.rxjava.ext.mongo.MongoService.rxRemove(String, JsonObject)
io.vertx.reactivex.ext.mongo.MongoClient.rxRemove(String, JsonObject)
io.vertx.reactivex.ext.mongo.MongoService.rxRemove(String, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.rxRemoveOne(String, JsonObject)
io.vertx.rxjava.ext.mongo.MongoService.rxRemoveOne(String, JsonObject)
io.vertx.reactivex.ext.mongo.MongoClient.rxRemoveOne(String, JsonObject)
io.vertx.reactivex.ext.mongo.MongoService.rxRemoveOne(String, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.rxRemoveOneWithOptions(String, JsonObject, WriteOption)
io.vertx.rxjava.ext.mongo.MongoService.rxRemoveOneWithOptions(String, JsonObject, WriteOption)
io.vertx.reactivex.ext.mongo.MongoClient.rxRemoveOneWithOptions(String, JsonObject, WriteOption)
io.vertx.reactivex.ext.mongo.MongoService.rxRemoveOneWithOptions(String, JsonObject, WriteOption)
io.vertx.rxjava.ext.mongo.MongoClient.rxRemoveWithOptions(String, JsonObject, WriteOption)
io.vertx.rxjava.ext.mongo.MongoService.rxRemoveWithOptions(String, JsonObject, WriteOption)
io.vertx.reactivex.ext.mongo.MongoClient.rxRemoveWithOptions(String, JsonObject, WriteOption)
io.vertx.reactivex.ext.mongo.MongoService.rxRemoveWithOptions(String, JsonObject, WriteOption)
io.vertx.rxjava.ext.web.templ.TemplateEngine.rxRender(RoutingContext, String)
io.vertx.reactivex.ext.web.templ.TemplateEngine.rxRender(RoutingContext, String)
io.vertx.rxjava.ext.web.templ.TemplateEngine.rxRender(RoutingContext, String, String)
io.vertx.reactivex.ext.web.templ.TemplateEngine.rxRender(RoutingContext, String, String)
io.vertx.rxjava.ext.mongo.MongoClient.rxReplace(String, JsonObject, JsonObject)
io.vertx.rxjava.ext.mongo.MongoService.rxReplace(String, JsonObject, JsonObject)
io.vertx.reactivex.ext.mongo.MongoClient.rxReplace(String, JsonObject, JsonObject)
io.vertx.reactivex.ext.mongo.MongoService.rxReplace(String, JsonObject, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.rxReplaceWithOptions(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.rxjava.ext.mongo.MongoService.rxReplaceWithOptions(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.reactivex.ext.mongo.MongoClient.rxReplaceWithOptions(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.reactivex.ext.mongo.MongoService.rxReplaceWithOptions(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.rxjava.core.eventbus.Message.rxReply(Object)
io.vertx.reactivex.core.eventbus.Message.rxReply(Object)
io.vertx.rxjava.core.eventbus.Message.rxReply(Object, DeliveryOptions)
io.vertx.reactivex.core.eventbus.Message.rxReply(Object, DeliveryOptions)
io.vertx.rxjava.core.eventbus.EventBus.rxSend(String, Object)
io.vertx.reactivex.core.eventbus.EventBus.rxSend(String, Object)
io.vertx.rxjava.core.eventbus.EventBus.rxSend(String, Object, DeliveryOptions)
io.vertx.reactivex.core.eventbus.EventBus.rxSend(String, Object, DeliveryOptions)
io.vertx.rxjava.core.Future.rxSetHandler()
io.vertx.rxjava.core.CompositeFuture.rxSetHandler()
io.vertx.reactivex.core.Future.rxSetHandler()
io.vertx.reactivex.core.CompositeFuture.rxSetHandler()
io.vertx.rxjava.ext.mongo.MongoClient.rxUpdate(String, JsonObject, JsonObject)
io.vertx.rxjava.ext.mongo.MongoService.rxUpdate(String, JsonObject, JsonObject)
io.vertx.reactivex.ext.mongo.MongoClient.rxUpdate(String, JsonObject, JsonObject)
io.vertx.reactivex.ext.mongo.MongoService.rxUpdate(String, JsonObject, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.rxUpdateWithOptions(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.rxjava.ext.mongo.MongoService.rxUpdateWithOptions(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.reactivex.ext.mongo.MongoClient.rxUpdateWithOptions(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.reactivex.ext.mongo.MongoService.rxUpdateWithOptions(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.rxjava.redis.RedisTransaction.saddManyObservable(String, List<String>) use RedisTransaction.rxSaddMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.saddManyObservable(String, List<String>) use RedisClient.rxSaddMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.saddObservable(List<String>) use RedisAPI.rxSadd(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.saddObservable(String, String) use RedisTransaction.rxSadd(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.saddObservable(String, String) use RedisClient.rxSadd(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.saveObservable() use RedisTransaction.rxSave() instead
io.vertx.rxjava.redis.RedisClient.saveObservable() use RedisClient.rxSave() instead
io.vertx.rxjava.redis.client.RedisAPI.saveObservable() use RedisAPI.rxSave() instead
io.vertx.rxjava.ext.mongo.MongoClient.saveObservable(String, JsonObject) use MongoClient.rxSave(java.lang.String, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.saveObservable(String, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.saveWithOptionsObservable(String, JsonObject, WriteOption) use MongoClient.rxSaveWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.WriteOption) instead
io.vertx.rxjava.ext.mongo.MongoService.saveWithOptionsObservable(String, JsonObject, WriteOption)
io.vertx.rxjava.redis.client.RedisAPI.scanObservable(List<String>) use RedisAPI.rxScan(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.scanObservable(String, ScanOptions) use RedisTransaction.rxScan(java.lang.String, io.vertx.redis.op.ScanOptions) instead
io.vertx.rxjava.redis.RedisClient.scanObservable(String, ScanOptions) use RedisClient.rxScan(java.lang.String, io.vertx.redis.op.ScanOptions) instead
io.vertx.rxjava.redis.RedisTransaction.scardObservable(String) use RedisTransaction.rxScard(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.scardObservable(String) use RedisClient.rxScard(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.scardObservable(String) use RedisAPI.rxScard(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.scriptDebugObservable(ScriptDebugOptions) use RedisClient.rxScriptDebug(io.vertx.redis.op.ScriptDebugOptions) instead
io.vertx.rxjava.redis.RedisTransaction.scriptExistsManyObservable(List<String>) use RedisTransaction.rxScriptExistsMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.scriptExistsManyObservable(List<String>) use RedisClient.rxScriptExistsMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.scriptExistsObservable(String) use RedisTransaction.rxScriptExists(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.scriptExistsObservable(String) use RedisClient.rxScriptExists(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.scriptFlushObservable() use RedisTransaction.rxScriptFlush() instead
io.vertx.rxjava.redis.RedisClient.scriptFlushObservable() use RedisClient.rxScriptFlush() instead
io.vertx.rxjava.redis.RedisTransaction.scriptKillObservable() use RedisTransaction.rxScriptKill() instead
io.vertx.rxjava.redis.RedisClient.scriptKillObservable() use RedisClient.rxScriptKill() instead
io.vertx.rxjava.redis.RedisTransaction.scriptLoadObservable(String) use RedisTransaction.rxScriptLoad(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.scriptLoadObservable(String) use RedisClient.rxScriptLoad(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.scriptObservable(List<String>) use RedisAPI.rxScript(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.sdiffObservable(List<String>) use RedisAPI.rxSdiff(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.sdiffObservable(String, List<String>) use RedisTransaction.rxSdiff(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.sdiffObservable(String, List<String>) use RedisClient.rxSdiff(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.sdiffstoreObservable(List<String>) use RedisAPI.rxSdiffstore(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.sdiffstoreObservable(String, String, List<String>) use RedisTransaction.rxSdiffstore(java.lang.String, java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.sdiffstoreObservable(String, String, List<String>) use RedisClient.rxSdiffstore(java.lang.String, java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.selectObservable(int) use RedisTransaction.rxSelect(int) instead
io.vertx.rxjava.redis.RedisClient.selectObservable(int) use RedisClient.rxSelect(int) instead
io.vertx.rxjava.redis.client.RedisAPI.selectObservable(String) use RedisAPI.rxSelect(java.lang.String) instead
io.vertx.core.eventbus.EventBus.send(String, Object, DeliveryOptions, Handler<AsyncResult<Message<T>>>) use EventBus.request(String, Object, DeliveryOptions, Handler) instead
io.vertx.rxjava.core.eventbus.EventBus.send(String, Object, DeliveryOptions, Handler<AsyncResult<Message<T>>>)
io.vertx.reactivex.core.eventbus.EventBus.send(String, Object, DeliveryOptions, Handler<AsyncResult<Message<T>>>)
io.vertx.core.eventbus.EventBus.send(String, Object, Handler<AsyncResult<Message<T>>>) use EventBus.request(String, Object, Handler) instead
io.vertx.rxjava.core.eventbus.EventBus.send(String, Object, Handler<AsyncResult<Message<T>>>)
io.vertx.reactivex.core.eventbus.EventBus.send(String, Object, Handler<AsyncResult<Message<T>>>)
io.vertx.core.eventbus.MessageProducer.send(T) instead use MessageProducer.write(T) with a producer obtained from EventBus.sender(java.lang.String)
io.vertx.rxjava.core.eventbus.MessageProducer.send(T)
io.vertx.reactivex.core.eventbus.MessageProducer.send(T)
io.vertx.core.eventbus.MessageProducer.send(T, Handler<AsyncResult<Message<R>>>) instead use EventBus.request(String, Object, Handler)
io.vertx.rxjava.core.eventbus.MessageProducer.send(T, Handler<AsyncResult<Message<R>>>)
io.vertx.reactivex.core.eventbus.MessageProducer.send(T, Handler<AsyncResult<Message<R>>>)
io.vertx.rxjava.ext.web.client.HttpRequest.sendBufferObservable(Buffer) use HttpRequest.rxSendBuffer(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.net.NetSocket.sendFileObservable(String) use NetSocket.rxSendFile(java.lang.String) instead
io.vertx.rxjava.core.http.HttpServerResponse.sendFileObservable(String) use HttpServerResponse.rxSendFile(java.lang.String) instead
io.vertx.rxjava.core.net.NetSocket.sendFileObservable(String, long) use NetSocket.rxSendFile(java.lang.String) instead
io.vertx.rxjava.core.http.HttpServerResponse.sendFileObservable(String, long) use HttpServerResponse.rxSendFile(java.lang.String) instead
io.vertx.rxjava.core.net.NetSocket.sendFileObservable(String, long, long) use NetSocket.rxSendFile(java.lang.String) instead
io.vertx.rxjava.core.http.HttpServerResponse.sendFileObservable(String, long, long) use HttpServerResponse.rxSendFile(java.lang.String) instead
io.vertx.rxjava.ext.web.client.HttpRequest.sendFormObservable(MultiMap) use HttpRequest.rxSendForm(io.vertx.rxjava.core.MultiMap) instead
io.vertx.rxjava.ext.web.client.HttpRequest.sendJsonObjectObservable(JsonObject) use HttpRequest.rxSendJsonObject(io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.web.client.HttpRequest.sendJsonObservable(Object) use HttpRequest.rxSendJson(java.lang.Object) instead
io.vertx.rxjava.ext.mail.MailClient.sendMailObservable(MailMessage) use MailClient.rxSendMail(io.vertx.ext.mail.MailMessage) instead
io.vertx.rxjava.ext.web.client.HttpRequest.sendMultipartFormObservable(MultipartForm) use HttpRequest.rxSendMultipartForm(io.vertx.rxjava.ext.web.multipart.MultipartForm) instead
io.vertx.rxjava.ext.web.client.HttpRequest.sendObservable() use HttpRequest.rxSend() instead
io.vertx.rxjava.core.datagram.DatagramSocket.sendObservable(Buffer, int, String) use DatagramSocket.rxSend(io.vertx.rxjava.core.buffer.Buffer, int, java.lang.String) instead
io.vertx.rxjava.redis.client.Redis.sendObservable(Request) use Redis.rxSend(io.vertx.rxjava.redis.client.Request) instead
io.vertx.rxjava.redis.client.RedisConnection.sendObservable(Request) use RedisConnection.rxSend(io.vertx.rxjava.redis.client.Request) instead
io.vertx.rxjava.core.datagram.DatagramSocket.sendObservable(String, int, String) use DatagramSocket.rxSend(io.vertx.rxjava.core.buffer.Buffer, int, java.lang.String) instead
io.vertx.rxjava.core.eventbus.EventBus.sendObservable(String, Object) use EventBus.rxSend(java.lang.String, java.lang.Object) instead
io.vertx.rxjava.core.eventbus.EventBus.sendObservable(String, Object, DeliveryOptions) use EventBus.rxSend(java.lang.String, java.lang.Object) instead
io.vertx.rxjava.core.datagram.DatagramSocket.sendObservable(String, String, int, String) use DatagramSocket.rxSend(io.vertx.rxjava.core.buffer.Buffer, int, java.lang.String) instead
io.vertx.rxjava.ext.web.client.HttpRequest.sendStreamObservable(Observable<Buffer>) use HttpRequest.rxSendStream(io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.ext.web.client.HttpRequest.sendStreamObservable(ReadStream<Buffer>) use HttpRequest.rxSendStream(io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.buffer.Buffer>) instead
io.vertx.rxjava.redis.sentinel.RedisSentinel.sentinelsObservable(String) use RedisSentinel.rxSentinels(java.lang.String) instead
io.vertx.ext.auth.User.setAuthProvider(AuthProvider)
io.vertx.ext.web.handler.SessionHandler.setAuthProvider(AuthProvider) this method has no effect
io.vertx.rxjava.ext.auth.User.setAuthProvider(AuthProvider)
io.vertx.rxjava.ext.web.handler.SessionHandler.setAuthProvider(AuthProvider)
io.vertx.reactivex.ext.auth.User.setAuthProvider(AuthProvider)
io.vertx.reactivex.ext.web.handler.SessionHandler.setAuthProvider(AuthProvider)
io.vertx.rxjava.ext.sql.SQLConnection.setAutoCommitObservable(boolean) use SQLConnection.rxSetAutoCommit(boolean) instead
io.vertx.rxjava.redis.RedisTransaction.setBinaryObservable(String, Buffer) use RedisTransaction.rxSetBinary(java.lang.String, io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.redis.RedisClient.setBinaryObservable(String, Buffer) use RedisClient.rxSetBinary(java.lang.String, io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.redis.RedisTransaction.setBinaryWithOptionsObservable(String, Buffer, SetOptions) use RedisTransaction.rxSetBinaryWithOptions(java.lang.String, io.vertx.rxjava.core.buffer.Buffer, io.vertx.redis.op.SetOptions) instead
io.vertx.rxjava.redis.RedisClient.setBinaryWithOptionsObservable(String, Buffer, SetOptions) use RedisClient.rxSetBinaryWithOptions(java.lang.String, io.vertx.rxjava.core.buffer.Buffer, io.vertx.redis.op.SetOptions) instead
io.vertx.rxjava.redis.RedisTransaction.setbitObservable(String, long, int) use RedisTransaction.rxSetbit(java.lang.String, long, int) instead
io.vertx.rxjava.redis.RedisClient.setbitObservable(String, long, int) use RedisClient.rxSetbit(java.lang.String, long, int) instead
io.vertx.rxjava.redis.client.RedisAPI.setbitObservable(String, String, String) use RedisAPI.rxSetbit(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.ext.auth.PubSecKeyOptions.setCertificate(boolean)
io.vertx.rxjava.ext.web.Cookie.setChanged(boolean)
io.vertx.reactivex.ext.web.Cookie.setChanged(boolean)
io.vertx.core.net.NetServerOptions.setClientAuthRequired(boolean) use setClientAuth(ClientAuth.REQUIRED) or setClientAuth(ClientAuth.NONE) instead
io.vertx.core.http.HttpServerOptions.setClientAuthRequired(boolean)
io.vertx.core.VertxOptions.setClustered(boolean) as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.setClustered(boolean) instead
io.vertx.core.VertxOptions.setClusterHost(String) as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.setHost(String) instead
io.vertx.core.VertxOptions.setClusterPingInterval(long) as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.setClusterPingInterval(long) instead
io.vertx.core.VertxOptions.setClusterPingReplyInterval(long) as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.setClusterPingReplyInterval(long) instead
io.vertx.core.VertxOptions.setClusterPort(int) as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.setPort(int) instead
io.vertx.core.VertxOptions.setClusterPublicHost(String) as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.setClusterPublicHost(String) instead
io.vertx.core.VertxOptions.setClusterPublicPort(int) as of 3.7, use VertxOptions.getEventBusOptions() and then EventBusOptions.setClusterPublicPort(int) instead
io.vertx.rxjava.ext.web.Cookie.setDomain(String)
io.vertx.reactivex.ext.web.Cookie.setDomain(String)
io.vertx.redis.client.RedisOptions.setEndpoint(String) see RedisOptions.setConnectionString(String connectionString) for a better naming
io.vertx.rxjava.redis.RedisTransaction.setexObservable(String, long, String) use RedisTransaction.rxSetex(java.lang.String, long, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.setexObservable(String, long, String) use RedisClient.rxSetex(java.lang.String, long, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.setexObservable(String, String, String) use RedisAPI.rxSetex(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.ext.web.templ.mvel.MVELTemplateEngine.setExtension(String) as a user you should use filename with extensions on the render method instead of relying on this method to suffix your filenames. Using this method is quite an opinionated API and has the side effect that you cannot use files without extensions as templates. Set the extension for the engine
io.vertx.ext.web.templ.pebble.PebbleTemplateEngine.setExtension(String) as a user you should use filename with extensions on the render method instead of relying on this method to suffix your filenames. Using this method is quite an opinionated API and has the side effect that you cannot use files without extensions as templates. Set the extension for the engine
io.vertx.ext.web.templ.freemarker.FreeMarkerTemplateEngine.setExtension(String) as a user you should use filename with extensions on the render method instead of relying on this method to suffix your filenames. Using this method is quite an opinionated API and has the side effect that you cannot use files without extensions as templates. Set the extension for the engine
io.vertx.ext.web.templ.handlebars.HandlebarsTemplateEngine.setExtension(String) as a user you should use filename with extensions on the render method instead of relying on this method to suffix your filenames. Using this method is quite an opinionated API and has the side effect that you cannot use files without extensions as templates. Set the extension for the engine
io.vertx.ext.web.templ.jade.JadeTemplateEngine.setExtension(String) as a user you should use filename with extensions on the render method instead of relying on this method to suffix your filenames. Using this method is quite an opinionated API and has the side effect that you cannot use files without extensions as templates. Set the extension for the engine
io.vertx.ext.web.templ.rocker.RockerTemplateEngine.setExtension(String)
io.vertx.rxjava.ext.web.templ.mvel.MVELTemplateEngine.setExtension(String)
io.vertx.rxjava.ext.web.templ.pebble.PebbleTemplateEngine.setExtension(String)
io.vertx.rxjava.ext.web.templ.freemarker.FreeMarkerTemplateEngine.setExtension(String)
io.vertx.rxjava.ext.web.templ.handlebars.HandlebarsTemplateEngine.setExtension(String)
io.vertx.rxjava.ext.web.templ.jade.JadeTemplateEngine.setExtension(String)
io.vertx.rxjava.ext.web.templ.rocker.RockerTemplateEngine.setExtension(String)
io.vertx.reactivex.ext.web.templ.mvel.MVELTemplateEngine.setExtension(String)
io.vertx.reactivex.ext.web.templ.pebble.PebbleTemplateEngine.setExtension(String)
io.vertx.reactivex.ext.web.templ.freemarker.FreeMarkerTemplateEngine.setExtension(String)
io.vertx.reactivex.ext.web.templ.handlebars.HandlebarsTemplateEngine.setExtension(String)
io.vertx.reactivex.ext.web.templ.jade.JadeTemplateEngine.setExtension(String)
io.vertx.reactivex.ext.web.templ.rocker.RockerTemplateEngine.setExtension(String)
io.vertx.core.VertxOptions.setFileResolverCachingEnabled(boolean) use getFileSystemOptions().setFileCachingEnabled(val) instead
io.vertx.core.CompositeFuture.setHandler(Handler<AsyncResult<CompositeFuture>>)
io.vertx.rxjava.core.CompositeFuture.setHandler(Handler<AsyncResult<CompositeFuture>>)
io.vertx.reactivex.core.CompositeFuture.setHandler(Handler<AsyncResult<CompositeFuture>>)
io.vertx.core.Future.setHandler(Handler<AsyncResult<T>>) use Future.onComplete(io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) instead
io.vertx.rxjava.core.Future.setHandler(Handler<AsyncResult<T>>)
io.vertx.reactivex.core.Future.setHandler(Handler<AsyncResult<T>>)
io.vertx.rxjava.core.Future.setHandlerObservable() use Future.rxSetHandler() instead
io.vertx.rxjava.core.CompositeFuture.setHandlerObservable()
io.vertx.rxjava.core.http.ServerWebSocket.setHandshakeObservable(Future<Integer>) use ServerWebSocket.rxSetHandshake(io.vertx.rxjava.core.Future<java.lang.Integer>) instead
io.vertx.rxjava.ext.web.Cookie.setHttpOnly(boolean)
io.vertx.reactivex.ext.web.Cookie.setHttpOnly(boolean)
io.vertx.mqtt.MqttClientOptions.setIdleTimeout(int)
io.vertx.mqtt.MqttClientOptions.setKeepAliveTimeSeconds(int) instead use MqttClientOptions.setKeepAliveInterval(int)
io.vertx.rxjava.ext.web.Cookie.setMaxAge(long)
io.vertx.reactivex.ext.web.Cookie.setMaxAge(long)
io.vertx.core.http.HttpClientOptions.setMaxWebsocketFrameSize(int) instead use HttpClientOptions.setMaxWebSocketFrameSize(int)
io.vertx.core.http.HttpServerOptions.setMaxWebsocketFrameSize(int) use instead HttpServerOptions.setMaxWebSocketFrameSize(int)
io.vertx.core.http.HttpClientOptions.setMaxWebsocketMessageSize(int) instead use HttpClientOptions.setMaxWebSocketMessageSize(int)
io.vertx.core.http.HttpServerOptions.setMaxWebsocketMessageSize(int) use instead HttpServerOptions.setMaxWebSocketMessageSize(int)
io.vertx.ext.web.api.contract.RouterFactoryOptions.setMountValidationFailureHandler(boolean) Router Factory won't manage the validation errors anymore. You must use Router.errorHandler(int, Handler) with 400 error
io.vertx.core.DeploymentOptions.setMultiThreaded(boolean) as of 3.6.0
io.vertx.ext.web.api.contract.RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext>) You must use Router.errorHandler(int, Handler) with 501 error
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext>)
io.vertx.rxjava.ext.web.api.contract.RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext>)
io.vertx.rxjava.redis.RedisTransaction.setnxObservable(String, String) use RedisTransaction.rxSetnx(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.setnxObservable(String, String) use RedisClient.rxSetnx(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.setnxObservable(String, String) use RedisAPI.rxSetnx(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.setObservable(List<String>) use RedisAPI.rxSet(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.setObservable(String, String) use RedisTransaction.rxSet(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.setObservable(String, String) use RedisClient.rxSet(java.lang.String, java.lang.String) instead
io.vertx.rxjava.ext.web.Cookie.setPath(String)
io.vertx.reactivex.ext.web.Cookie.setPath(String)
io.vertx.core.http.HttpServerOptions.setPerFrameWebsocketCompressionSupported(boolean) instead use HttpServerOptions.setPerFrameWebSocketCompressionSupported(boolean)
io.vertx.core.http.HttpServerOptions.setPerMessageWebsocketCompressionSupported(boolean) instead use HttpServerOptions.setPerMessageWebSocketCompressionSupported(boolean)
io.vertx.db2client.DB2ConnectOptions.setPipeliningLimit(int) UNSTABLE FEATURE: Current default value is 1, anything higher than 1 will result in errors currently.
io.vertx.ext.auth.PubSecKeyOptions.setPublicKey(String)
io.vertx.ext.sql.SQLConnection.setQueryTimeout(int) instead use SQLConnection.setOptions(SQLOptions) with SQLOptions.setQueryTimeout(int)
io.vertx.rxjava.ext.sql.SQLConnection.setQueryTimeout(int)
io.vertx.reactivex.ext.sql.SQLConnection.setQueryTimeout(int)
io.vertx.rxjava.redis.RedisTransaction.setrangeObservable(String, int, String) use RedisTransaction.rxSetrange(java.lang.String, int, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.setrangeObservable(String, int, String) use RedisClient.rxSetrange(java.lang.String, int, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.setrangeObservable(String, String, String) use RedisAPI.rxSetrange(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.ext.auth.oauth2.OAuth2ClientOptions.setScopeSeparator(String)
io.vertx.ext.auth.PubSecKeyOptions.setSecretKey(String)
io.vertx.ext.auth.jwt.JWTAuthOptions.setSecrets(List<SecretOptions>)
io.vertx.rxjava.ext.web.Cookie.setSecure(boolean)
io.vertx.reactivex.ext.web.Cookie.setSecure(boolean)
io.vertx.ext.auth.PubSecKeyOptions.setSymmetric(boolean)
io.vertx.rxjava.ext.sql.SQLConnection.setTransactionIsolationObservable(TransactionIsolation) use SQLConnection.rxSetTransactionIsolation(io.vertx.ext.sql.TransactionIsolation) instead
io.vertx.core.http.HttpClientOptions.setTryUsePerFrameWebsocketCompression(boolean) instead use HttpClientOptions.setTryUsePerFrameWebSocketCompression(boolean)
io.vertx.core.http.HttpClientOptions.setTryUsePerMessageWebsocketCompression(boolean) instead use HttpClientOptions.setTryUsePerMessageWebSocketCompression(boolean)
io.vertx.ext.auth.oauth2.OAuth2ClientOptions.setUseBasicAuthorizationHeader(boolean)
io.vertx.core.net.TCPSSLOptions.setUsePooledBuffers(boolean) this has no effect, just don't use it
io.vertx.ext.web.api.contract.RouterFactory.setValidationFailureHandler(Handler<RoutingContext>) Router Factory won't manage the validation errors anymore. You must use Router.errorHandler(int, Handler) with 400 error
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setValidationFailureHandler(Handler<RoutingContext>)
io.vertx.rxjava.ext.web.api.contract.RouterFactory.setValidationFailureHandler(Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setValidationFailureHandler(Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.RouterFactory.setValidationFailureHandler(Handler<RoutingContext>)
io.vertx.rxjava.ext.web.Cookie.setValue(String)
io.vertx.reactivex.ext.web.Cookie.setValue(String)
io.vertx.amqpbridge.AmqpBridgeOptions.setVhost(String) use AmqpBridgeOptions.setVirtualHost(String) option instead.
io.vertx.core.http.HttpServerOptions.setWebsocketAllowServerNoContext(boolean) instead use HttpServerOptions.setWebSocketAllowServerNoContext(boolean)
io.vertx.core.http.HttpClientOptions.setWebsocketCompressionAllowClientNoContext(boolean) instead use HttpClientOptions.setWebSocketCompressionAllowClientNoContext(boolean)
io.vertx.core.http.HttpClientOptions.setWebsocketCompressionLevel(int) instead use HttpClientOptions.setWebSocketCompressionLevel(int)
io.vertx.core.http.HttpServerOptions.setWebsocketCompressionLevel(int) instead use HttpServerOptions.setWebSocketCompressionLevel(int)
io.vertx.core.http.HttpClientOptions.setWebsocketCompressionRequestServerNoContext(boolean) instead use HttpClientOptions.setWebSocketCompressionRequestServerNoContext(boolean)
io.vertx.core.http.HttpServerOptions.setWebsocketPreferredClientNoContext(boolean) instead use HttpServerOptions.setWebSocketPreferredClientNoContext(boolean)
io.vertx.core.http.HttpServerOptions.setWebsocketSubProtocols(String) use HttpServerOptions.setWebSocketSubProtocols(List) or HttpServerOptions.addWebSocketSubProtocol(String) instead
io.vertx.rxjava.redis.RedisTransaction.setWithOptionsObservable(String, String, SetOptions) use RedisTransaction.rxSetWithOptions(java.lang.String, java.lang.String, io.vertx.redis.op.SetOptions) instead
io.vertx.rxjava.redis.RedisClient.setWithOptionsObservable(String, String, SetOptions) use RedisClient.rxSetWithOptions(java.lang.String, java.lang.String, io.vertx.redis.op.SetOptions) instead
io.vertx.rxjava.redis.client.RedisAPI.shutdownObservable(List<String>) use RedisAPI.rxShutdown(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.sinterObservable(List<String>) use RedisTransaction.rxSinter(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.sinterObservable(List<String>) use RedisClient.rxSinter(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.sinterObservable(List<String>) use RedisAPI.rxSinter(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.sinterstoreObservable(List<String>) use RedisAPI.rxSinterstore(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.sinterstoreObservable(String, List<String>) use RedisTransaction.rxSinterstore(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.sinterstoreObservable(String, List<String>) use RedisClient.rxSinterstore(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.sismemberObservable(String, String) use RedisTransaction.rxSismember(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.sismemberObservable(String, String) use RedisClient.rxSismember(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.sismemberObservable(String, String) use RedisAPI.rxSismember(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.shareddata.AsyncMap.sizeObservable() use AsyncMap.rxSize() instead
io.vertx.rxjava.ext.web.sstore.SessionStore.sizeObservable() use SessionStore.rxSize() instead
io.vertx.rxjava.redis.RedisTransaction.slaveofNooneObservable() use RedisTransaction.rxSlaveofNoone() instead
io.vertx.rxjava.redis.RedisClient.slaveofNooneObservable() use RedisClient.rxSlaveofNoone() instead
io.vertx.rxjava.redis.RedisTransaction.slaveofObservable(String, int) use RedisTransaction.rxSlaveof(java.lang.String, int) instead
io.vertx.rxjava.redis.RedisClient.slaveofObservable(String, int) use RedisClient.rxSlaveof(java.lang.String, int) instead
io.vertx.rxjava.redis.client.RedisAPI.slaveofObservable(String, String) use RedisAPI.rxSlaveof(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.sentinel.RedisSentinel.slavesObservable(String) use RedisSentinel.rxSlaves(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.slowlogGetObservable(int) use RedisTransaction.rxSlowlogGet(int) instead
io.vertx.rxjava.redis.RedisClient.slowlogGetObservable(int) use RedisClient.rxSlowlogGet(int) instead
io.vertx.rxjava.redis.RedisTransaction.slowlogLenObservable() use RedisTransaction.rxSlowlogLen() instead
io.vertx.rxjava.redis.RedisClient.slowlogLenObservable() use RedisClient.rxSlowlogLen() instead
io.vertx.rxjava.redis.client.RedisAPI.slowlogObservable(List<String>) use RedisAPI.rxSlowlog(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.slowlogResetObservable() use RedisTransaction.rxSlowlogReset() instead
io.vertx.rxjava.redis.RedisClient.slowlogResetObservable() use RedisClient.rxSlowlogReset() instead
io.vertx.rxjava.redis.RedisTransaction.smembersObservable(String) use RedisTransaction.rxSmembers(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.smembersObservable(String) use RedisClient.rxSmembers(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.smembersObservable(String) use RedisAPI.rxSmembers(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.smoveObservable(String, String, String) use RedisTransaction.rxSmove(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.smoveObservable(String, String, String) use RedisClient.rxSmove(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.smoveObservable(String, String, String) use RedisAPI.rxSmove(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.sortObservable(List<String>) use RedisAPI.rxSort(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.sortObservable(String, SortOptions) use RedisTransaction.rxSort(java.lang.String, io.vertx.redis.op.SortOptions) instead
io.vertx.rxjava.redis.RedisClient.sortObservable(String, SortOptions) use RedisClient.rxSort(java.lang.String, io.vertx.redis.op.SortOptions) instead
io.vertx.rxjava.redis.RedisTransaction.spopManyObservable(String, int) use RedisTransaction.rxSpopMany(java.lang.String, int) instead
io.vertx.rxjava.redis.RedisClient.spopManyObservable(String, int) use RedisClient.rxSpopMany(java.lang.String, int) instead
io.vertx.rxjava.redis.client.RedisAPI.spopObservable(List<String>) use RedisAPI.rxSpop(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.spopObservable(String) use RedisTransaction.rxSpop(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.spopObservable(String) use RedisClient.rxSpop(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.srandmemberCountObservable(String, int) use RedisTransaction.rxSrandmemberCount(java.lang.String, int) instead
io.vertx.rxjava.redis.RedisClient.srandmemberCountObservable(String, int) use RedisClient.rxSrandmemberCount(java.lang.String, int) instead
io.vertx.rxjava.redis.client.RedisAPI.srandmemberObservable(List<String>) use RedisAPI.rxSrandmember(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.srandmemberObservable(String) use RedisTransaction.rxSrandmember(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.srandmemberObservable(String) use RedisClient.rxSrandmember(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.sremManyObservable(String, List<String>) use RedisTransaction.rxSremMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.sremManyObservable(String, List<String>) use RedisClient.rxSremMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.sremObservable(List<String>) use RedisAPI.rxSrem(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.sremObservable(String, String) use RedisTransaction.rxSrem(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.sremObservable(String, String) use RedisClient.rxSrem(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.sscanObservable(List<String>) use RedisAPI.rxSscan(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.sscanObservable(String, String, ScanOptions) use RedisTransaction.rxSscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions) instead
io.vertx.rxjava.redis.RedisClient.sscanObservable(String, String, ScanOptions) use RedisClient.rxSscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions) instead
io.vertx.core.Verticle.start(Future<Void>) override instead Verticle.start(Promise)
io.vertx.core.AbstractVerticle.start(Future<Void>) Override Verticle.start(Promise) instead.
io.vertx.rxjava.ext.shell.ShellService.startObservable() use ShellService.rxStart() instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.startObservable() use RabbitMQClient.rxStart() instead
io.vertx.rxjava.amqpbridge.AmqpBridge.startObservable(String, int) use AmqpBridge.rxStart(java.lang.String, int, java.lang.String, java.lang.String) instead
io.vertx.rxjava.amqpbridge.AmqpBridge.startObservable(String, int, String, String) use AmqpBridge.rxStart(java.lang.String, int, java.lang.String, java.lang.String) instead
io.vertx.core.Verticle.stop(Future<Void>) override instead Verticle.stop(Promise)
io.vertx.core.AbstractVerticle.stop(Future<Void>) Override Verticle.stop(Promise) instead.
io.vertx.rxjava.ext.shell.ShellService.stopObservable() use ShellService.rxStop() instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.stopObservable() use RabbitMQClient.rxStop() instead
io.vertx.rxjava.redis.RedisTransaction.strlenObservable(String) use RedisTransaction.rxStrlen(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.strlenObservable(String) use RedisClient.rxStrlen(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.strlenObservable(String) use RedisAPI.rxStrlen(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.subscribeManyObservable(List<String>) use RedisTransaction.rxSubscribeMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.subscribeManyObservable(List<String>) use RedisClient.rxSubscribeMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.subscribeObservable(List<String>) use RedisAPI.rxSubscribe(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.subscribeObservable(String) use RedisTransaction.rxSubscribe(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.subscribeObservable(String) use RedisClient.rxSubscribe(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.substrObservable(String, String, String) use RedisAPI.rxSubstr(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.sunionObservable(List<String>) use RedisTransaction.rxSunion(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.sunionObservable(List<String>) use RedisClient.rxSunion(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.sunionObservable(List<String>) use RedisAPI.rxSunion(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.sunionstoreObservable(List<String>) use RedisAPI.rxSunionstore(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.sunionstoreObservable(String, List<String>) use RedisTransaction.rxSunionstore(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.sunionstoreObservable(String, List<String>) use RedisClient.rxSunionstore(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.swapdbObservable(int, int) use RedisTransaction.rxSwapdb(int, int) instead
io.vertx.rxjava.redis.RedisClient.swapdbObservable(int, int) use RedisClient.rxSwapdb(int, int) instead
io.vertx.rxjava.redis.client.RedisAPI.swapdbObservable(String, String) use RedisAPI.rxSwapdb(java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.file.FileSystem.symlinkObservable(String, String) use FileSystem.rxSymlink(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.syncObservable() use RedisTransaction.rxSync() instead
io.vertx.rxjava.redis.RedisClient.syncObservable() use RedisClient.rxSync() instead
io.vertx.rxjava.redis.client.RedisAPI.syncObservable() use RedisAPI.rxSync() instead
io.vertx.rxjava.redis.RedisTransaction.timeObservable() use RedisTransaction.rxTime() instead
io.vertx.rxjava.redis.RedisClient.timeObservable() use RedisClient.rxTime() instead
io.vertx.rxjava.redis.client.RedisAPI.timeObservable() use RedisAPI.rxTime() instead
io.vertx.config.spi.utils.JsonObjectHelper.toBuffer(JsonObject) use JsonObject.toBuffer() instead
io.vertx.rxjava.core.http.HttpServerRequest.toNetSocketObservable() use HttpServerRequest.rxToNetSocket() instead
io.vertx.rxjava.core.streams.Pipe.toObservable(WriteStream<T>) use Pipe.rxTo(io.vertx.rxjava.core.streams.WriteStream<T>) instead
io.vertx.rxjava.redis.RedisClient.touchManyObservable(List<String>) use RedisClient.rxTouchMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.touchObservable(List<String>) use RedisAPI.rxTouch(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.touchObservable(String) use RedisClient.rxTouch(java.lang.String) instead
io.vertx.rxjava.core.http.HttpServerRequest.toWebSocketObservable() use HttpServerRequest.rxToWebSocket() instead
io.vertx.rxjava.core.file.FileSystem.truncateObservable(String, long) use FileSystem.rxTruncate(java.lang.String, long) instead
io.vertx.core.Future.tryComplete() instead create a Promise and use Promise.tryComplete()
io.vertx.rxjava.core.Future.tryComplete()
io.vertx.reactivex.core.Future.tryComplete()
io.vertx.rxjava.core.CompositeFuture.tryComplete(CompositeFuture)
io.vertx.reactivex.core.CompositeFuture.tryComplete(CompositeFuture)
io.vertx.core.Future.tryComplete(T) instead create a Promise and use Promise.tryComplete(Object)
io.vertx.rxjava.core.Future.tryComplete(T)
io.vertx.reactivex.core.Future.tryComplete(T)
io.vertx.core.Future.tryFail(String) instead create a Promise and use Promise.tryFail(String)
io.vertx.rxjava.core.Future.tryFail(String)
io.vertx.reactivex.core.Future.tryFail(String)
io.vertx.core.Future.tryFail(Throwable) instead create a Promise and use Promise.tryFail(Throwable)
io.vertx.rxjava.core.Future.tryFail(Throwable)
io.vertx.reactivex.core.Future.tryFail(Throwable)
io.vertx.rxjava.redis.RedisTransaction.ttlObservable(String) use RedisTransaction.rxTtl(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.ttlObservable(String) use RedisClient.rxTtl(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.ttlObservable(String) use RedisAPI.rxTtl(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.typeObservable(String) use RedisTransaction.rxType(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.typeObservable(String) use RedisClient.rxType(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.typeObservable(String) use RedisAPI.rxType(java.lang.String) instead
io.vertx.rxjava.core.Vertx.undeployObservable(String) use Vertx.rxUndeploy(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.unlinkManyObservable(List<String>) use RedisTransaction.rxUnlinkMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.unlinkManyObservable(List<String>) use RedisClient.rxUnlinkMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.unlinkObservable(List<String>) use RedisAPI.rxUnlink(java.util.List<java.lang.String>) instead
io.vertx.rxjava.core.file.FileSystem.unlinkObservable(String) use FileSystem.rxUnlink(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.unlinkObservable(String) use RedisTransaction.rxUnlink(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.unlinkObservable(String) use RedisClient.rxUnlink(java.lang.String) instead
io.vertx.rxjava.core.datagram.DatagramSocket.unlistenMulticastGroupObservable(String) use DatagramSocket.rxUnlistenMulticastGroup(java.lang.String) instead
io.vertx.rxjava.core.datagram.DatagramSocket.unlistenMulticastGroupObservable(String, String, String) use DatagramSocket.rxUnlistenMulticastGroup(java.lang.String) instead
io.vertx.rxjava.ext.shell.command.CommandRegistry.unregisterCommandObservable(String) use CommandRegistry.rxUnregisterCommand(java.lang.String) instead
io.vertx.rxjava.core.eventbus.MessageConsumer.unregisterObservable() use MessageConsumer.rxUnregister() instead
io.vertx.serviceproxy.ProxyHelper.unregisterService(MessageConsumer<JsonObject>) use MessageConsumer.unregister()
io.vertx.rxjava.redis.RedisTransaction.unsubscribeObservable(List<String>) use RedisTransaction.rxUnsubscribe(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.unsubscribeObservable(List<String>) use RedisClient.rxUnsubscribe(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.unsubscribeObservable(List<String>) use RedisAPI.rxUnsubscribe(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.unwatchObservable() use RedisTransaction.rxUnwatch() instead
io.vertx.rxjava.redis.client.RedisAPI.unwatchObservable() use RedisAPI.rxUnwatch() instead
io.vertx.ext.mongo.MongoClient.update(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>) instead use MongoClient.updateCollection(String, JsonObject, JsonObject, Handler)
io.vertx.ext.mongo.MongoService.update(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.update(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoService.update(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoClient.update(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoService.update(String, JsonObject, JsonObject, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.updateCollectionObservable(String, JsonObject, JsonObject) use MongoClient.rxUpdateCollection(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.updateCollectionObservable(String, JsonObject, JsonObject)
io.vertx.rxjava.ext.mongo.MongoClient.updateCollectionWithOptionsObservable(String, JsonObject, JsonObject, UpdateOptions) use MongoClient.rxUpdateCollectionWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.UpdateOptions) instead
io.vertx.rxjava.ext.mongo.MongoService.updateCollectionWithOptionsObservable(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.rxjava.ext.sql.SQLConnection.updateObservable(String) use SQLConnection.rxUpdate(java.lang.String) instead
io.vertx.rxjava.ext.sql.SQLClient.updateObservable(String) use SQLClient.rxUpdate(java.lang.String) instead
io.vertx.rxjava.ext.mongo.MongoClient.updateObservable(String, JsonObject, JsonObject) use MongoClient.rxUpdate(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject) instead
io.vertx.rxjava.ext.mongo.MongoService.updateObservable(String, JsonObject, JsonObject)
io.vertx.rxjava.core.http.HttpConnection.updateSettingsObservable(Http2Settings) use HttpConnection.rxUpdateSettings(io.vertx.core.http.Http2Settings) instead
io.vertx.ext.mongo.MongoClient.updateWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>) use instead MongoClient.updateCollectionWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler)
io.vertx.ext.mongo.MongoService.updateWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.updateWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoService.updateWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoClient.updateWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.mongo.MongoService.updateWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.mongo.MongoClient.updateWithOptionsObservable(String, JsonObject, JsonObject, UpdateOptions) use MongoClient.rxUpdateWithOptions(java.lang.String, io.vertx.core.json.JsonObject, io.vertx.core.json.JsonObject, io.vertx.ext.mongo.UpdateOptions) instead
io.vertx.rxjava.ext.mongo.MongoService.updateWithOptionsObservable(String, JsonObject, JsonObject, UpdateOptions)
io.vertx.rxjava.ext.sql.SQLConnection.updateWithParamsObservable(String, JsonArray) use SQLConnection.rxUpdateWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.rxjava.ext.sql.SQLClient.updateWithParamsObservable(String, JsonArray) use SQLClient.rxUpdateWithParams(java.lang.String, io.vertx.core.json.JsonArray) instead
io.vertx.core.http.HttpServerRequest.upgrade() instead use HttpServerRequest.toWebSocket(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.http.ServerWebSocket>>)
io.vertx.rxjava.core.http.HttpServerRequest.upgrade()
io.vertx.reactivex.core.http.HttpServerRequest.upgrade()
io.vertx.rxjava.ext.auth.oauth2.AccessToken.userInfoObservable() use AccessToken.rxUserInfo() instead
io.vertx.mqtt.MqttAuth.userName() use instead MqttAuth.getUsername() ()}
io.vertx.ext.web.Locale.variant() Use LanguageHeader.subtag(int) with value 2 instead
io.vertx.rxjava.ext.web.Locale.variant()
io.vertx.reactivex.ext.web.Locale.variant()
io.vertx.rxjava.rabbitmq.RabbitMQClient.waitForConfirmsObservable() use RabbitMQClient.rxWaitForConfirms() instead
io.vertx.rxjava.rabbitmq.RabbitMQClient.waitForConfirmsObservable(long) use RabbitMQClient.rxWaitForConfirms() instead
io.vertx.rxjava.redis.RedisTransaction.waitObservable(long, long) use RedisTransaction.rxWait(long, long) instead
io.vertx.rxjava.redis.RedisClient.waitObservable(long, long) use RedisClient.rxWait(long, long) instead
io.vertx.rxjava.redis.client.RedisAPI.waitObservable(String, String) use RedisAPI.rxWait(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.watchManyObservable(List<String>) use RedisTransaction.rxWatchMany(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.watchObservable(List<String>) use RedisAPI.rxWatch(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.watchObservable(String) use RedisTransaction.rxWatch(java.lang.String) instead
io.vertx.core.http.HttpClient.websocket(int, String, String, Handler<WebSocket>) use HttpClient.webSocket(int, String, String, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(int, String, String, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(int, String, String, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(int, String, String, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(int, String, String, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(int, String, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(int, String, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(int, String, String, MultiMap, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(int, String, String, MultiMap, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(int, String, String, MultiMap, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(int, String, String, MultiMap, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(int, String, String, MultiMap, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(int, String, String, MultiMap, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(int, String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(RequestOptions, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(RequestOptions, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(RequestOptions, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(RequestOptions, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(RequestOptions, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(RequestOptions, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(RequestOptions, MultiMap, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(RequestOptions, MultiMap, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(RequestOptions, MultiMap, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(RequestOptions, MultiMap, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(RequestOptions, MultiMap, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(RequestOptions, MultiMap, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, String, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, String, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, String, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(RequestOptions, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(String, Handler<WebSocket>) use HttpClient.webSocket(String, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(String, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(String, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(String, MultiMap, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, MultiMap, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, MultiMap, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(String, MultiMap, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, MultiMap, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, MultiMap, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, String, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, String, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, String, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(String, String, Handler<WebSocket>) use HttpClient.webSocket(String, String, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, String, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, String, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(String, String, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(String, String, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(String, String, MultiMap, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, String, MultiMap, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, String, MultiMap, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(String, String, MultiMap, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, String, MultiMap, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, String, MultiMap, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>)
io.vertx.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocket(String, String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.core.http.HttpClient.websocketAbs(String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketAbs(String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.reactivex.core.http.HttpClient.websocketAbs(String, MultiMap, WebsocketVersion, String, Handler<WebSocket>, Handler<Throwable>)
io.vertx.rxjava.core.http.HttpClient.webSocketAbsObservable(String, MultiMap, WebsocketVersion, List<String>) use HttpClient.rxWebSocketAbs(java.lang.String, io.vertx.rxjava.core.MultiMap, io.vertx.core.http.WebsocketVersion, java.util.List<java.lang.String>) instead
io.vertx.core.http.HttpServer.websocketHandler() use instead HttpServer.webSocketHandler()
io.vertx.core.http.HttpServer.websocketHandler(Handler<ServerWebSocket>) use instead HttpServer.webSocketHandler()
io.vertx.rxjava.core.http.HttpServer.websocketHandler(Handler<ServerWebSocket>)
io.vertx.reactivex.core.http.HttpServer.websocketHandler(Handler<ServerWebSocket>)
io.vertx.rxjava.core.http.HttpClient.webSocketObservable(int, String, String) use HttpClient.rxWebSocket(int, java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.http.HttpClient.webSocketObservable(String) use HttpClient.rxWebSocket(int, java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.http.HttpClient.webSocketObservable(String, String) use HttpClient.rxWebSocket(int, java.lang.String, java.lang.String) instead
io.vertx.rxjava.core.http.HttpClient.webSocketObservable(WebSocketConnectOptions) use HttpClient.rxWebSocket(int, java.lang.String, java.lang.String) instead
io.vertx.core.http.HttpServer.websocketStream() instead use HttpServer.webSocketStream()
io.vertx.rxjava.core.http.HttpServer.websocketStream()
io.vertx.reactivex.core.http.HttpServer.websocketStream()
io.vertx.core.http.HttpClient.websocketStream(int, String, String) use HttpClient.webSocket(int, String, String, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(int, String, String)
io.vertx.reactivex.core.http.HttpClient.websocketStream(int, String, String)
io.vertx.core.http.HttpClient.websocketStream(int, String, String, MultiMap) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(int, String, String, MultiMap)
io.vertx.reactivex.core.http.HttpClient.websocketStream(int, String, String, MultiMap)
io.vertx.core.http.HttpClient.websocketStream(int, String, String, MultiMap, WebsocketVersion) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(int, String, String, MultiMap, WebsocketVersion)
io.vertx.reactivex.core.http.HttpClient.websocketStream(int, String, String, MultiMap, WebsocketVersion)
io.vertx.core.http.HttpClient.websocketStream(int, String, String, MultiMap, WebsocketVersion, String) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(int, String, String, MultiMap, WebsocketVersion, String)
io.vertx.reactivex.core.http.HttpClient.websocketStream(int, String, String, MultiMap, WebsocketVersion, String)
io.vertx.core.http.HttpClient.websocketStream(RequestOptions) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(RequestOptions)
io.vertx.reactivex.core.http.HttpClient.websocketStream(RequestOptions)
io.vertx.core.http.HttpClient.websocketStream(RequestOptions, MultiMap) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(RequestOptions, MultiMap)
io.vertx.reactivex.core.http.HttpClient.websocketStream(RequestOptions, MultiMap)
io.vertx.core.http.HttpClient.websocketStream(RequestOptions, MultiMap, WebsocketVersion) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(RequestOptions, MultiMap, WebsocketVersion)
io.vertx.reactivex.core.http.HttpClient.websocketStream(RequestOptions, MultiMap, WebsocketVersion)
io.vertx.core.http.HttpClient.websocketStream(RequestOptions, MultiMap, WebsocketVersion, String) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(RequestOptions, MultiMap, WebsocketVersion, String)
io.vertx.reactivex.core.http.HttpClient.websocketStream(RequestOptions, MultiMap, WebsocketVersion, String)
io.vertx.core.http.HttpClient.websocketStream(String) use HttpClient.webSocket(String, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(String)
io.vertx.reactivex.core.http.HttpClient.websocketStream(String)
io.vertx.core.http.HttpClient.websocketStream(String, MultiMap) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(String, MultiMap)
io.vertx.reactivex.core.http.HttpClient.websocketStream(String, MultiMap)
io.vertx.core.http.HttpClient.websocketStream(String, MultiMap, WebsocketVersion) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(String, MultiMap, WebsocketVersion)
io.vertx.reactivex.core.http.HttpClient.websocketStream(String, MultiMap, WebsocketVersion)
io.vertx.core.http.HttpClient.websocketStream(String, MultiMap, WebsocketVersion, String) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(String, MultiMap, WebsocketVersion, String)
io.vertx.reactivex.core.http.HttpClient.websocketStream(String, MultiMap, WebsocketVersion, String)
io.vertx.core.http.HttpClient.websocketStream(String, String) use HttpClient.webSocket(String, String, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(String, String)
io.vertx.reactivex.core.http.HttpClient.websocketStream(String, String)
io.vertx.core.http.HttpClient.websocketStream(String, String, MultiMap) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(String, String, MultiMap)
io.vertx.reactivex.core.http.HttpClient.websocketStream(String, String, MultiMap)
io.vertx.core.http.HttpClient.websocketStream(String, String, MultiMap, WebsocketVersion) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(String, String, MultiMap, WebsocketVersion)
io.vertx.reactivex.core.http.HttpClient.websocketStream(String, String, MultiMap, WebsocketVersion)
io.vertx.core.http.HttpClient.websocketStream(String, String, MultiMap, WebsocketVersion, String) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStream(String, String, MultiMap, WebsocketVersion, String)
io.vertx.reactivex.core.http.HttpClient.websocketStream(String, String, MultiMap, WebsocketVersion, String)
io.vertx.core.http.HttpClient.websocketStreamAbs(String, MultiMap, WebsocketVersion, String) use HttpClient.webSocket(WebSocketConnectOptions, Handler) instead
io.vertx.rxjava.core.http.HttpClient.websocketStreamAbs(String, MultiMap, WebsocketVersion, String)
io.vertx.reactivex.core.http.HttpClient.websocketStreamAbs(String, MultiMap, WebsocketVersion, String)
io.vertx.mqtt.MqttWill.willMessage() use MqttWill.getWillMessageBytes() instead
io.vertx.mqtt.MqttWill.willQos() use MqttWill.willQos() instead
io.vertx.mqtt.MqttWill.willTopic() use MqttWill.getWillTopic() instead
io.vertx.rxjava.core.http.ServerWebSocket.writeBinaryMessageObservable(Buffer)
io.vertx.rxjava.core.http.WebSocket.writeBinaryMessageObservable(Buffer)
io.vertx.rxjava.core.file.FileSystem.writeFileObservable(String, Buffer) use FileSystem.rxWriteFile(java.lang.String, io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.http.ServerWebSocket.writeFinalBinaryFrameObservable(Buffer)
io.vertx.rxjava.core.http.WebSocket.writeFinalBinaryFrameObservable(Buffer)
io.vertx.rxjava.core.http.ServerWebSocket.writeFinalTextFrameObservable(String)
io.vertx.rxjava.core.http.WebSocket.writeFinalTextFrameObservable(String)
io.vertx.rxjava.core.http.ServerWebSocket.writeFrameObservable(WebSocketFrame)
io.vertx.rxjava.core.http.WebSocket.writeFrameObservable(WebSocketFrame)
io.vertx.rxjava.core.net.NetSocket.writeObservable(Buffer) use NetSocket.rxWrite(java.lang.String) instead
io.vertx.rxjava.core.file.AsyncFile.writeObservable(Buffer) use AsyncFile.rxWrite(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.http.HttpServerResponse.writeObservable(Buffer) use HttpServerResponse.rxWrite(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.http.ServerWebSocket.writeObservable(Buffer)
io.vertx.rxjava.core.http.HttpClientRequest.writeObservable(Buffer) use HttpClientRequest.rxWrite(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.http.WebSocket.writeObservable(Buffer)
io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket.writeObservable(Buffer)
io.vertx.rxjava.core.file.AsyncFile.writeObservable(Buffer, long) use AsyncFile.rxWrite(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.net.NetSocket.writeObservable(String) use NetSocket.rxWrite(java.lang.String) instead
io.vertx.rxjava.core.http.HttpServerResponse.writeObservable(String) use HttpServerResponse.rxWrite(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.http.HttpClientRequest.writeObservable(String) use HttpClientRequest.rxWrite(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.net.NetSocket.writeObservable(String, String) use NetSocket.rxWrite(java.lang.String) instead
io.vertx.rxjava.core.http.HttpServerResponse.writeObservable(String, String) use HttpServerResponse.rxWrite(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.http.HttpClientRequest.writeObservable(String, String) use HttpClientRequest.rxWrite(io.vertx.rxjava.core.buffer.Buffer) instead
io.vertx.rxjava.core.eventbus.MessageProducer.writeObservable(T)
io.vertx.rxjava.core.http.ServerWebSocket.writeTextMessageObservable(String)
io.vertx.rxjava.core.http.WebSocket.writeTextMessageObservable(String)
io.vertx.rxjava.redis.client.RedisAPI.xackObservable(List<String>) use RedisAPI.rxXack(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xaddObservable(List<String>) use RedisAPI.rxXadd(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xclaimObservable(List<String>) use RedisAPI.rxXclaim(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xdelObservable(List<String>) use RedisAPI.rxXdel(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xgroupObservable(List<String>) use RedisAPI.rxXgroup(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xinfoObservable(List<String>) use RedisAPI.rxXinfo(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xlenObservable(String) use RedisAPI.rxXlen(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.xpendingObservable(List<String>) use RedisAPI.rxXpending(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xrangeObservable(List<String>) use RedisAPI.rxXrange(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xreadgroupObservable(List<String>) use RedisAPI.rxXreadgroup(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xreadObservable(List<String>) use RedisAPI.rxXread(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xrevrangeObservable(List<String>) use RedisAPI.rxXrevrange(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.xsetidObservable(String, String) use RedisAPI.rxXsetid(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.xtrimObservable(List<String>) use RedisAPI.rxXtrim(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zaddManyObservable(String, Map<String, Double>) use RedisTransaction.rxZaddMany(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>) instead
io.vertx.rxjava.redis.RedisClient.zaddManyObservable(String, Map<String, Double>) use RedisClient.rxZaddMany(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>) instead
io.vertx.rxjava.redis.client.RedisAPI.zaddObservable(List<String>) use RedisAPI.rxZadd(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zaddObservable(String, double, String) use RedisTransaction.rxZadd(java.lang.String, double, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.zaddObservable(String, double, String) use RedisClient.rxZadd(java.lang.String, double, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.zcardObservable(String) use RedisTransaction.rxZcard(java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.zcardObservable(String) use RedisClient.rxZcard(java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zcardObservable(String) use RedisAPI.rxZcard(java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.zcountObservable(String, double, double) use RedisTransaction.rxZcount(java.lang.String, double, double) instead
io.vertx.rxjava.redis.RedisClient.zcountObservable(String, double, double) use RedisClient.rxZcount(java.lang.String, double, double) instead
io.vertx.rxjava.redis.client.RedisAPI.zcountObservable(String, String, String) use RedisAPI.rxZcount(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.zincrbyObservable(String, double, String) use RedisTransaction.rxZincrby(java.lang.String, double, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.zincrbyObservable(String, double, String) use RedisClient.rxZincrby(java.lang.String, double, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zincrbyObservable(String, String, String) use RedisAPI.rxZincrby(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zinterstoreObservable(List<String>) use RedisAPI.rxZinterstore(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zinterstoreObservable(String, List<String>, AggregateOptions) use RedisTransaction.rxZinterstore(java.lang.String, java.util.List<java.lang.String>, io.vertx.redis.op.AggregateOptions) instead
io.vertx.rxjava.redis.RedisClient.zinterstoreObservable(String, List<String>, AggregateOptions) use RedisClient.rxZinterstore(java.lang.String, java.util.List<java.lang.String>, io.vertx.redis.op.AggregateOptions) instead
io.vertx.rxjava.redis.RedisTransaction.zinterstoreWeighedObservable(String, Map<String, Double>, AggregateOptions) use RedisTransaction.rxZinterstoreWeighed(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>, io.vertx.redis.op.AggregateOptions) instead
io.vertx.rxjava.redis.RedisClient.zinterstoreWeighedObservable(String, Map<String, Double>, AggregateOptions) use RedisClient.rxZinterstoreWeighed(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>, io.vertx.redis.op.AggregateOptions) instead
io.vertx.rxjava.redis.RedisTransaction.zlexcountObservable(String, String, String) use RedisTransaction.rxZlexcount(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.zlexcountObservable(String, String, String) use RedisClient.rxZlexcount(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zlexcountObservable(String, String, String) use RedisAPI.rxZlexcount(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zpopmaxObservable(List<String>) use RedisAPI.rxZpopmax(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.zpopminObservable(List<String>) use RedisAPI.rxZpopmin(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.zrangebylexObservable(List<String>) use RedisAPI.rxZrangebylex(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zrangebylexObservable(String, String, String, LimitOptions) use RedisTransaction.rxZrangebylex(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.LimitOptions) instead
io.vertx.rxjava.redis.RedisClient.zrangebylexObservable(String, String, String, LimitOptions) use RedisClient.rxZrangebylex(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.LimitOptions) instead
io.vertx.rxjava.redis.client.RedisAPI.zrangebyscoreObservable(List<String>) use RedisAPI.rxZrangebyscore(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zrangebyscoreObservable(String, String, String, RangeLimitOptions) use RedisTransaction.rxZrangebyscore(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.RangeLimitOptions) instead
io.vertx.rxjava.redis.RedisClient.zrangebyscoreObservable(String, String, String, RangeLimitOptions) use RedisClient.rxZrangebyscore(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.RangeLimitOptions) instead
io.vertx.rxjava.redis.client.RedisAPI.zrangeObservable(List<String>) use RedisAPI.rxZrange(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zrangeObservable(String, long, long) use RedisTransaction.rxZrange(java.lang.String, long, long) instead
io.vertx.rxjava.redis.RedisClient.zrangeObservable(String, long, long) use RedisClient.rxZrange(java.lang.String, long, long) instead
io.vertx.rxjava.redis.RedisTransaction.zrangeWithOptionsObservable(String, long, long, RangeOptions) use RedisTransaction.rxZrangeWithOptions(java.lang.String, long, long, io.vertx.redis.op.RangeOptions) instead
io.vertx.rxjava.redis.RedisClient.zrangeWithOptionsObservable(String, long, long, RangeOptions) use RedisClient.rxZrangeWithOptions(java.lang.String, long, long, io.vertx.redis.op.RangeOptions) instead
io.vertx.rxjava.redis.RedisTransaction.zrankObservable(String, String) use RedisTransaction.rxZrank(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.zrankObservable(String, String) use RedisClient.rxZrank(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zrankObservable(String, String) use RedisAPI.rxZrank(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.zremManyObservable(String, List<String>) use RedisTransaction.rxZremMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisClient.zremManyObservable(String, List<String>) use RedisClient.rxZremMany(java.lang.String, java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.client.RedisAPI.zremObservable(List<String>) use RedisAPI.rxZrem(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zremObservable(String, String) use RedisTransaction.rxZrem(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.zremObservable(String, String) use RedisClient.rxZrem(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.zremrangebylexObservable(String, String, String) use RedisTransaction.rxZremrangebylex(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.zremrangebylexObservable(String, String, String) use RedisClient.rxZremrangebylex(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zremrangebylexObservable(String, String, String) use RedisAPI.rxZremrangebylex(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.zremrangebyrankObservable(String, long, long) use RedisTransaction.rxZremrangebyrank(java.lang.String, long, long) instead
io.vertx.rxjava.redis.RedisClient.zremrangebyrankObservable(String, long, long) use RedisClient.rxZremrangebyrank(java.lang.String, long, long) instead
io.vertx.rxjava.redis.client.RedisAPI.zremrangebyrankObservable(String, String, String) use RedisAPI.rxZremrangebyrank(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisTransaction.zremrangebyscoreObservable(String, String, String) use RedisTransaction.rxZremrangebyscore(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.zremrangebyscoreObservable(String, String, String) use RedisClient.rxZremrangebyscore(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zremrangebyscoreObservable(String, String, String) use RedisAPI.rxZremrangebyscore(java.lang.String, java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zrevrangebylexObservable(List<String>) use RedisAPI.rxZrevrangebylex(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zrevrangebylexObservable(String, String, String, LimitOptions) use RedisTransaction.rxZrevrangebylex(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.LimitOptions) instead
io.vertx.rxjava.redis.RedisClient.zrevrangebylexObservable(String, String, String, LimitOptions) use RedisClient.rxZrevrangebylex(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.LimitOptions) instead
io.vertx.rxjava.redis.client.RedisAPI.zrevrangebyscoreObservable(List<String>) use RedisAPI.rxZrevrangebyscore(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zrevrangebyscoreObservable(String, String, String, RangeLimitOptions) use RedisTransaction.rxZrevrangebyscore(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.RangeLimitOptions) instead
io.vertx.rxjava.redis.RedisClient.zrevrangebyscoreObservable(String, String, String, RangeLimitOptions) use RedisClient.rxZrevrangebyscore(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.RangeLimitOptions) instead
io.vertx.rxjava.redis.client.RedisAPI.zrevrangeObservable(List<String>) use RedisAPI.rxZrevrange(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zrevrangeObservable(String, long, long, RangeOptions) use RedisTransaction.rxZrevrange(java.lang.String, long, long, io.vertx.redis.op.RangeOptions) instead
io.vertx.rxjava.redis.RedisClient.zrevrangeObservable(String, long, long, RangeOptions) use RedisClient.rxZrevrange(java.lang.String, long, long, io.vertx.redis.op.RangeOptions) instead
io.vertx.rxjava.redis.RedisTransaction.zrevrankObservable(String, String) use RedisTransaction.rxZrevrank(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.zrevrankObservable(String, String) use RedisClient.rxZrevrank(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zrevrankObservable(String, String) use RedisAPI.rxZrevrank(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zscanObservable(List<String>) use RedisAPI.rxZscan(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zscanObservable(String, String, ScanOptions) use RedisTransaction.rxZscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions) instead
io.vertx.rxjava.redis.RedisClient.zscanObservable(String, String, ScanOptions) use RedisClient.rxZscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions) instead
io.vertx.rxjava.redis.RedisTransaction.zscoreObservable(String, String) use RedisTransaction.rxZscore(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.RedisClient.zscoreObservable(String, String) use RedisClient.rxZscore(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zscoreObservable(String, String) use RedisAPI.rxZscore(java.lang.String, java.lang.String) instead
io.vertx.rxjava.redis.client.RedisAPI.zunionstoreObservable(List<String>) use RedisAPI.rxZunionstore(java.util.List<java.lang.String>) instead
io.vertx.rxjava.redis.RedisTransaction.zunionstoreObservable(String, List<String>, AggregateOptions) use RedisTransaction.rxZunionstore(java.lang.String, java.util.List<java.lang.String>, io.vertx.redis.op.AggregateOptions) instead
io.vertx.rxjava.redis.RedisClient.zunionstoreObservable(String, List<String>, AggregateOptions) use RedisClient.rxZunionstore(java.lang.String, java.util.List<java.lang.String>, io.vertx.redis.op.AggregateOptions) instead
io.vertx.rxjava.redis.RedisTransaction.zunionstoreWeighedObservable(String, Map<String, Double>, AggregateOptions) use RedisTransaction.rxZunionstoreWeighed(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>, io.vertx.redis.op.AggregateOptions) instead
io.vertx.rxjava.redis.RedisClient.zunionstoreWeighedObservable(String, Map<String, Double>, AggregateOptions) use RedisClient.rxZunionstoreWeighed(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>, io.vertx.redis.op.AggregateOptions) instead

Deprecated Constructors

Constructor and Description
io.vertx.ext.web.common.template.CachingTemplateEngine(String, int)
io.vertx.core.http.CaseInsensitiveHeaders() use MultiMap.caseInsensitiveMultiMap() instead
io.vertx.core.spi.launcher.DefaultCommandFactory(Class<C>) Please use DefaultCommandFactory(Class, Supplier)