Deprecated API

Contents

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

Deprecated Interfaces

Interface and Description
io.vertx.ext.web.handler.graphql.ApolloWSConnectionInitEvent the subscriptions-transport-ws protocol is no longer maintained
io.vertx.ext.web.handler.graphql.ApolloWSHandler the subscriptions-transport-ws protocol is no longer maintained
io.vertx.ext.web.handler.graphql.ApolloWSMessage the subscriptions-transport-ws protocol is no longer maintained
io.vertx.ext.auth.AuthOptions do not use this interface to create a provider, use the provider specific factory.
io.vertx.ext.auth.AuthProvider This interface was quite opionated. The new alternative is to use one of the specific interfaces: AuthenticationProvider or AuthorizationProvider
io.vertx.ext.web.api.validation.ContainerDeserializer You should use the new module vertx-web-openapi
io.vertx.ext.web.api.validation.CustomValidator You should use the new module vertx-web-openapi
io.vertx.db2client.DB2Pool
io.vertx.ext.web.client.predicate.ErrorConverter instead use HttpResponseExpectation
io.vertx.ext.auth.HashingAlgorithm this class should not be used directly
io.vertx.ext.auth.HashingStrategy this class should not be used directly
io.vertx.ext.auth.mongo.HashStrategy This strategy has been deprecated in favour of HashingStrategy. The new implementation is backend agnostic and follows a standard format that can be reused across different storages.
io.vertx.rxjava.ext.web.api.contract.HTTPOperationRequestValidationHandler
io.vertx.rxjava3.ext.web.api.contract.HTTPOperationRequestValidationHandler
io.vertx.ext.web.api.contract.HTTPOperationRequestValidationHandler You should use the new module vertx-web-openapi
io.vertx.reactivex.ext.web.api.contract.HTTPOperationRequestValidationHandler
io.vertx.ext.web.api.validation.HTTPRequestValidationHandler You should use the new module vertx-web-openapi
io.vertx.ext.web.templ.jade.JadeTemplateEngine Use PugTemplateEngine instead; jade4j has been renamed to pug4j.
io.vertx.ext.auth.jdbc.JDBCAuth This class has been replaced by the class JDBCAuthentication for authentication and JDBCAuthorization for authorization
io.vertx.ext.auth.jdbc.JDBCAuthentication Please use vertx-auth-sql-client instead. Factory interface for creating AuthenticationProvider instances that use the Vert.x JDBC client. By default the hashing strategy is SHA-512. If you're already running in production this is backwards compatible, however for new deployments or security upgrades it is recommended to use the PBKDF2 strategy as it is the current OWASP recommendation for password storage.
io.vertx.ext.auth.jdbc.JDBCAuthorization Please use vertx-auth-sql-client instead. Factory interface for creating AuthorizationProvider instances that use the Vert.x JDBC client.
io.vertx.ext.auth.jdbc.JDBCHashStrategy This strategy has been deprecated in favour of HashingStrategy. The new implementation is backend agnostic and follows a standard format that can be reused across different storages.
io.vertx.ext.auth.jdbc.JDBCUserUtil Please use vertx-auth-sql-client instead. Utility to create users/roles/permissions. This is a helper class and not intended to be a full user management utility. While the standard authentication and authorization interfaces will require usually read only access to the database, in order to use this API a full read/write access must be granted.
io.vertx.ext.auth.shiro.LDAPProviderConstants ShiroAuth has been replaced by io.vertx.ext.auth.properties.PropertyFileAuthentication and io.vertx.ext.auth.ldap.LdapAuthentication
io.vertx.ext.auth.mongo.MongoAuth This class has been replaced by the class MongoAuthentication for authentication and MongoAuthorization for authorization
io.vertx.mssqlclient.MSSQLPool
io.vertx.mysqlclient.MySQLPool
io.vertx.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler You should use the new module vertx-web-openapi
io.vertx.ext.web.api.contract.openapi3.OpenAPI3RouterFactory You should use the new module vertx-web-openapi
io.vertx.ext.web.api.validation.ParameterTypeValidator You should use the new module vertx-web-openapi
io.vertx.ext.web.api.validation.ParameterValidationRule You should use the new module vertx-web-openapi
io.vertx.pgclient.PgPool
io.vertx.ext.auth.shiro.PropertiesProviderConstants ShiroAuth has been replaced by io.vertx.ext.auth.properties.PropertyFileAuthentication and io.vertx.ext.auth.ldap.LdapAuthentication
io.vertx.core.streams.Pump instead use ReadStream.pipe() or ReadStream.pipeTo(WriteStream)
io.vertx.ext.web.api.RequestParameter You should use the new module vertx-web-openapi
io.vertx.ext.web.api.RequestParameters You should use the new module vertx-web-openapi
io.vertx.ext.web.client.predicate.ResponsePredicate instead use HttpResponseExpectation
io.vertx.ext.web.client.predicate.ResponsePredicateResult instead use HttpResponseExpectation
io.vertx.rxjava.ext.web.api.contract.RouterFactory
io.vertx.rxjava3.ext.web.api.contract.RouterFactory
io.vertx.ext.web.api.contract.RouterFactory You should use the new module vertx-web-openapi
io.vertx.reactivex.ext.web.api.contract.RouterFactory
io.vertx.json.schema.Schema users should migrate to the new validator
io.vertx.json.schema.SchemaParser users should migrate to the new validator
io.vertx.json.schema.common.SchemaParserInternal
io.vertx.json.schema.SchemaRouter users should migrate to the new validator
io.vertx.ext.auth.shiro.ShiroAuth ShiroAuth has been replaced by io.vertx.ext.auth.properties.PropertyFileAuthentication and io.vertx.ext.auth.ldap.LdapAuthentication
io.vertx.core.TimeoutStream use Vertx.setTimer(long, io.vertx.core.Handler<java.lang.Long>)/Vertx.setPeriodic(long, io.vertx.core.Handler<java.lang.Long>) instead. RxJava like integrations should use the Vert.x scheduler integration.
io.vertx.ext.web.handler.graphql.TriConsumer only useful in dataloader package which is now deprecated
io.vertx.rxjava.ext.web.api.validation.ValidationHandler
io.vertx.rxjava3.ext.web.api.validation.ValidationHandler
io.vertx.ext.web.api.validation.ValidationHandler You should use the new module vertx-web-openapi
io.vertx.reactivex.ext.web.api.validation.ValidationHandler
io.vertx.ext.web.handler.graphql.dataloader.VertxBatchLoader use Future.toCompletionStage() with a plain BatchLoaderWithContext
io.vertx.ext.auth.VertxContextPRNG instead use VertxContextPRNG
io.vertx.ext.web.handler.graphql.schema.VertxDataFetcher use VertxFutureAdapter instead
io.vertx.ext.web.handler.graphql.dataloader.VertxMappedBatchLoader use Future.toCompletionStage() with a plain MappedBatchLoaderWithContext
io.vertx.ext.web.handler.graphql.schema.VertxPropertyDataFetcher with GraphQL-Java 20 and later, use JsonObjectAdapter instead

Deprecated Classes

Class and Description
io.vertx.ext.consul.AclToken
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSConnectionInitEvent
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSConnectionInitEvent
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSConnectionInitEvent
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSMessage
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSMessage
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSMessage
io.vertx.ext.web.handler.graphql.ApolloWSOptions the subscriptions-transport-ws protocol is no longer maintained
io.vertx.rxjava.ext.auth.AuthProvider
io.vertx.rxjava3.ext.auth.AuthProvider
io.vertx.reactivex.ext.auth.AuthProvider
io.vertx.json.schema.common.BaseSchemaParser
io.vertx.rxjava.ext.web.api.validation.ContainerDeserializer
io.vertx.rxjava3.ext.web.api.validation.ContainerDeserializer
io.vertx.reactivex.ext.web.api.validation.ContainerDeserializer
io.vertx.rxjava.ext.web.api.validation.CustomValidator
io.vertx.rxjava3.ext.web.api.validation.CustomValidator
io.vertx.reactivex.ext.web.api.validation.CustomValidator
io.vertx.rxjava.db2client.DB2Pool
io.vertx.rxjava3.db2client.DB2Pool
io.vertx.reactivex.db2client.DB2Pool
io.vertx.json.schema.draft201909.Draft201909SchemaParser
io.vertx.json.schema.draft7.Draft7SchemaParser
io.vertx.rxjava.ext.web.client.predicate.ErrorConverter
io.vertx.rxjava3.ext.web.client.predicate.ErrorConverter
io.vertx.reactivex.ext.web.client.predicate.ErrorConverter
io.vertx.grpc.client.GrpcClientChannel instead use GrpcIoClientChannel
io.vertx.rxjava.ext.auth.HashingAlgorithm
io.vertx.rxjava3.ext.auth.HashingAlgorithm
io.vertx.reactivex.ext.auth.HashingAlgorithm
io.vertx.rxjava.ext.auth.HashingStrategy
io.vertx.rxjava3.ext.auth.HashingStrategy
io.vertx.reactivex.ext.auth.HashingStrategy
io.vertx.rxjava.ext.auth.mongo.HashStrategy
io.vertx.rxjava3.ext.auth.mongo.HashStrategy
io.vertx.reactivex.ext.auth.mongo.HashStrategy
io.vertx.ext.auth.HashString this class should not be used directly
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler
io.vertx.rxjava.ext.web.templ.jade.JadeTemplateEngine
io.vertx.rxjava3.ext.web.templ.jade.JadeTemplateEngine
io.vertx.reactivex.ext.web.templ.jade.JadeTemplateEngine
io.vertx.rxjava.ext.auth.jdbc.JDBCAuth
io.vertx.reactivex.ext.auth.jdbc.JDBCAuth
io.vertx.rxjava.ext.auth.jdbc.JDBCAuthentication
io.vertx.reactivex.ext.auth.jdbc.JDBCAuthentication
io.vertx.ext.auth.jdbc.JDBCAuthenticationOptions Please use vertx-auth-sql-client instead. Options configuring JDBC authentication.
io.vertx.ext.auth.jdbc.JDBCAuthOptions This class has been replaced by the class JDBCAuthenticationOptions for authentication and JDBCAuthorizationOptions for authorization
io.vertx.rxjava.ext.auth.jdbc.JDBCAuthorization
io.vertx.reactivex.ext.auth.jdbc.JDBCAuthorization
io.vertx.ext.auth.jdbc.JDBCAuthorizationOptions Please use vertx-auth-sql-client instead. Options configuring JDBC authentication.
io.vertx.rxjava.ext.auth.jdbc.JDBCHashStrategy
io.vertx.reactivex.ext.auth.jdbc.JDBCHashStrategy
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil
io.vertx.core.logging.Logger see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.LoggerFactory see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.ext.auth.mongo.MongoAuth
io.vertx.rxjava3.ext.auth.mongo.MongoAuth
io.vertx.reactivex.ext.auth.mongo.MongoAuth
io.vertx.ext.auth.mongo.MongoAuthOptions This class has been replaced by the class MongoAuthenticationOptions for authentication and MongoAuthorizationOptions for authorization
io.vertx.rxjava.mssqlclient.MSSQLPool
io.vertx.rxjava3.mssqlclient.MSSQLPool
io.vertx.reactivex.mssqlclient.MSSQLPool
io.vertx.rxjava.mysqlclient.MySQLPool
io.vertx.rxjava3.mysqlclient.MySQLPool
io.vertx.reactivex.mysqlclient.MySQLPool
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory
io.vertx.json.schema.openapi3.OpenAPI3SchemaParser
io.vertx.ext.web.api.OperationRequest You should use the new module vertx-web-openapi
io.vertx.ext.web.api.OperationResponse You should use the new module vertx-web-openapi
io.vertx.rxjava.oracleclient.OraclePool
io.vertx.rxjava3.oracleclient.OraclePool
io.vertx.reactivex.oracleclient.OraclePool
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator
io.vertx.rxjava.ext.web.api.validation.ParameterValidationRule
io.vertx.rxjava3.ext.web.api.validation.ParameterValidationRule
io.vertx.reactivex.ext.web.api.validation.ParameterValidationRule
io.vertx.rxjava.pgclient.PgPool
io.vertx.rxjava3.pgclient.PgPool
io.vertx.reactivex.pgclient.PgPool
io.vertx.ext.auth.PRNG this class should not be used directly and should be package private
io.vertx.serviceproxy.ProxyHelper for a more robust proxy creation see: ServiceBinder
io.vertx.rxjava.core.streams.Pump
io.vertx.rxjava3.core.streams.Pump
io.vertx.reactivex.core.streams.Pump
io.vertx.rxjava.ext.web.api.RequestParameter
io.vertx.rxjava3.ext.web.api.RequestParameter
io.vertx.reactivex.ext.web.api.RequestParameter
io.vertx.rxjava.ext.web.api.RequestParameters
io.vertx.rxjava3.ext.web.api.RequestParameters
io.vertx.reactivex.ext.web.api.RequestParameters
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicate
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicate
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicate
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicateResult
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicateResult
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicateResult
io.vertx.ext.web.api.contract.RouterFactoryOptions You should use the new module vertx-web-openapi
io.vertx.rxjava.json.schema.Schema
io.vertx.rxjava3.json.schema.Schema
io.vertx.reactivex.json.schema.Schema
io.vertx.rxjava.json.schema.SchemaParser
io.vertx.rxjava3.json.schema.SchemaParser
io.vertx.reactivex.json.schema.SchemaParser
io.vertx.rxjava.json.schema.SchemaRouter
io.vertx.rxjava3.json.schema.SchemaRouter
io.vertx.reactivex.json.schema.SchemaRouter
io.vertx.json.schema.SchemaRouterOptions users should migrate to the new validator
io.vertx.serviceproxy.ServiceAuthInterceptor use AuthenticationInterceptor, AuthorizationInterceptor instead
io.vertx.core.ServiceHelper this utility class is for internal usage of Vert.x and will be moved to an internal vertx package in Vert.x 5
io.vertx.serviceproxy.ServiceJWTInterceptor Use ServiceAuthInterceptor instead
io.vertx.rxjava.ext.auth.shiro.ShiroAuth
io.vertx.rxjava3.ext.auth.shiro.ShiroAuth
io.vertx.reactivex.ext.auth.shiro.ShiroAuth
io.vertx.ext.auth.shiro.ShiroAuthOptions ShiroAuth has been replaced by io.vertx.ext.auth.properties.PropertyFileAuthentication and io.vertx.ext.auth.ldap.LdapAuthentication
io.vertx.rxjava.core.TimeoutStream
io.vertx.rxjava3.core.TimeoutStream
io.vertx.reactivex.core.TimeoutStream
io.vertx.rxjava.ext.web.handler.graphql.dataloader.VertxBatchLoader
io.vertx.rxjava3.ext.web.handler.graphql.dataloader.VertxBatchLoader
io.vertx.reactivex.ext.web.handler.graphql.dataloader.VertxBatchLoader
io.vertx.rxjava.ext.auth.VertxContextPRNG
io.vertx.rxjava3.ext.auth.VertxContextPRNG
io.vertx.reactivex.ext.auth.VertxContextPRNG
io.vertx.rxjava.ext.web.handler.graphql.schema.VertxDataFetcher
io.vertx.rxjava3.ext.web.handler.graphql.schema.VertxDataFetcher
io.vertx.reactivex.ext.web.handler.graphql.schema.VertxDataFetcher
io.vertx.rxjava.ext.web.handler.graphql.dataloader.VertxMappedBatchLoader
io.vertx.rxjava3.ext.web.handler.graphql.dataloader.VertxMappedBatchLoader
io.vertx.reactivex.ext.web.handler.graphql.dataloader.VertxMappedBatchLoader
io.vertx.rxjava.ext.web.handler.graphql.schema.VertxPropertyDataFetcher
io.vertx.rxjava3.ext.web.handler.graphql.schema.VertxPropertyDataFetcher
io.vertx.reactivex.ext.web.handler.graphql.schema.VertxPropertyDataFetcher

Deprecated Enums

Enum and Description
io.vertx.ext.web.handler.graphql.ApolloWSMessageType the subscriptions-transport-ws protocol is no longer maintained
io.vertx.ext.web.api.validation.ContainerSerializationStyle You should use the new module vertx-web-openapi
io.vertx.ext.auth.mongo.HashAlgorithm
io.vertx.ext.auth.mongo.HashSaltStyle Please use the provided generic PHC strings at the column level
io.vertx.ext.web.api.validation.ParameterLocation You should use the new module vertx-web-openapi
io.vertx.ext.web.api.validation.ParameterType You should use the new module vertx-web-openapi
io.vertx.ext.auth.shiro.ShiroAuthRealmType ShiroAuth has been replaced by io.vertx.ext.auth.properties.PropertyFileAuthentication and io.vertx.ext.auth.ldap.LdapAuthentication

Deprecated Exceptions

Exceptions and Description
io.vertx.json.schema.NoSyncValidationException users should migrate to the new validator
io.vertx.ext.web.api.contract.RouterFactoryException You should use the new module vertx-web-openapi
io.vertx.ext.web.api.validation.SpecFeatureNotSupportedException You should use the new module vertx-web-openapi
io.vertx.ext.web.api.validation.ValidationException You should use the new module vertx-web-openapi

Deprecated Fields

Field and Description
io.vertx.redis.client.Command.BRPOPLPUSH since: 6.2.0, replaced by: BLMOVE with the RIGHT and LEFT arguments
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.core.dns.AddressResolverOptions.DEFAULT_SEACH_DOMAINS instead use AddressResolverOptions.DEFAULT_SEARCH_DOMAINS
io.vertx.core.http.HttpClientOptions.DEFAULT_TRY_USE_COMPRESSION as of 4.5, use HttpClientOptions.DEFAULT_DECOMPRESSION_SUPPORTED
io.vertx.core.http.HttpHeaders.DISABLE_HTTP_HEADERS_VALIDATION_PROP_NAME
io.vertx.redis.client.Command.GEORADIUS since: 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS argument
io.vertx.redis.client.Command.GEORADIUS_RO since: 6.2.0, replaced by: GEOSEARCH with the BYRADIUS argument
io.vertx.redis.client.Command.GEORADIUSBYMEMBER since: 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS and FROMMEMBER arguments
io.vertx.redis.client.Command.GEORADIUSBYMEMBER_RO since: 6.2.0, replaced by: GEOSEARCH with the BYRADIUS and FROMMEMBER arguments
io.vertx.redis.client.Command.GETSET since: 6.2.0, replaced by: SET with the !GET argument
io.vertx.redis.client.Command.HMSET since: 4.0.0, replaced by: HSET with multiple field-value pairs
io.vertx.maven.resolver.ResolverImpl.REMOTE_SNAPSHOT_POLICY_SYS_PROP use ResolverOptions.REMOTE_SNAPSHOT_POLICY_SYS_PROP instead.
io.vertx.ext.auth.mongo.MongoAuth.ROLE_PREFIX
io.vertx.redis.client.Command.RPOPLPUSH since: 6.2.0, replaced by: LMOVE with the RIGHT and LEFT arguments
io.vertx.redis.client.Command.SLAVEOF since: 5.0.0, replaced by: REPLICAOF
io.vertx.redis.client.Command.SUBSTR since: 2.0.0, replaced by: GETRANGE
io.vertx.redis.client.Command.ZRANGEBYLEX since: 6.2.0, replaced by: ZRANGE with the BYLEX argument
io.vertx.redis.client.Command.ZRANGEBYSCORE since: 6.2.0, replaced by: ZRANGE with the BYSCORE argument
io.vertx.redis.client.Command.ZREVRANGE since: 6.2.0, replaced by: ZRANGE with the REV argument
io.vertx.redis.client.Command.ZREVRANGEBYLEX since: 6.2.0, replaced by: ZRANGE with the REV and BYLEX arguments
io.vertx.redis.client.Command.ZREVRANGEBYSCORE since: 6.2.0, replaced by: ZRANGE with the REV and BYSCORE arguments

Deprecated Methods

Method and Description
io.vertx.rxjava.core.http.ServerWebSocket.accept()
io.vertx.rxjava3.core.http.ServerWebSocket.accept()
io.vertx.core.http.ServerWebSocket.accept() instead use ServerWebSocketHandshake.accept()
io.vertx.reactivex.core.http.ServerWebSocket.accept()
io.vertx.rxjava.ext.web.RoutingContext.addCookie(Cookie)
io.vertx.rxjava3.ext.web.RoutingContext.addCookie(Cookie)
io.vertx.ext.web.RoutingContext.addCookie(Cookie) Use HttpServerResponse.addCookie(Cookie) Add a cookie. This will be sent back to the client in the response.
io.vertx.reactivex.ext.web.RoutingContext.addCookie(Cookie)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addCustomValidatorFunction(CustomValidator)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addCustomValidatorFunction(CustomValidator)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addCustomValidatorFunction(CustomValidator)
io.vertx.redis.client.RedisOptions.addEndpoint(String) see RedisOptions.setConnectionString(String connectionString) for a better naming
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addExpectedContentType(String)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addExpectedContentType(String)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addExpectedContentType(String)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addFailureHandlerByOperationId(String, Handler<RoutingContext>)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addFailureHandlerByOperationId(String, Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addFailureHandlerByOperationId(String, Handler<RoutingContext>)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addFormParam(String, ParameterType, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addFormParam(String, ParameterType, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addFormParam(String, ParameterType, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamsArray(String, ParameterType, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamsArray(String, ParameterType, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamsArray(String, ParameterType, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamsArrayWithPattern(String, String, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamsArrayWithPattern(String, String, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamsArrayWithPattern(String, String, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamWithPattern(String, String, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamWithPattern(String, String, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addFormParamWithPattern(String, String, boolean)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addGlobalHandler(Handler<RoutingContext>)
io.vertx.rxjava.ext.web.api.contract.RouterFactory.addGlobalHandler(Handler<RoutingContext>)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addGlobalHandler(Handler<RoutingContext>)
io.vertx.rxjava3.ext.web.api.contract.RouterFactory.addGlobalHandler(Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addGlobalHandler(Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.RouterFactory.addGlobalHandler(Handler<RoutingContext>)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addHandlerByOperationId(String, Handler<RoutingContext>)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addHandlerByOperationId(String, Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addHandlerByOperationId(String, Handler<RoutingContext>)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addHeaderParam(String, ParameterType, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addHeaderParam(String, ParameterType, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addHeaderParam(String, ParameterType, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addHeaderParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addHeaderParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addHeaderParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addHeaderParamWithPattern(String, String, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addHeaderParamWithPattern(String, String, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addHeaderParamWithPattern(String, String, boolean)
io.vertx.serviceproxy.ServiceBinder.addInterceptor(Function<Message<JsonObject>, Future<Message<JsonObject>>>)
io.vertx.serviceproxy.ServiceBinder.addInterceptor(String, Function<Message<JsonObject>, Future<Message<JsonObject>>>)
io.vertx.rxjava.json.schema.SchemaRouter.addJson(String, JsonObject)
io.vertx.rxjava3.json.schema.SchemaRouter.addJson(String, JsonObject)
io.vertx.reactivex.json.schema.SchemaRouter.addJson(String, JsonObject)
io.vertx.rxjava.json.schema.SchemaRouter.addJson(URI, JsonObject)
io.vertx.rxjava3.json.schema.SchemaRouter.addJson(URI, JsonObject)
io.vertx.reactivex.json.schema.SchemaRouter.addJson(URI, JsonObject)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addJsonBodySchema(String)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addJsonBodySchema(String)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addJsonBodySchema(String)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addMultipartRequiredFile(String, String)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addMultipartRequiredFile(String, String)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addMultipartRequiredFile(String, String)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addPathParam(String, ParameterType)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addPathParam(String, ParameterType)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addPathParam(String, ParameterType)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addPathParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addPathParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addPathParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addPathParamWithPattern(String, String)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addPathParamWithPattern(String, String)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addPathParamWithPattern(String, String)
io.vertx.ext.auth.JWTOptions.addPermission(String) See JWTAuthorization for a correct way to handle permissions. Add a permission to this token.
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParam(String, ParameterType, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParam(String, ParameterType, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParam(String, ParameterType, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamsArray(String, ParameterType, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamsArray(String, ParameterType, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamsArray(String, ParameterType, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamsArrayWithPattern(String, String, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamsArrayWithPattern(String, String, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamsArrayWithPattern(String, String, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamWithCustomTypeValidator(String, ParameterTypeValidator, boolean, boolean)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamWithPattern(String, String, boolean)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamWithPattern(String, String, boolean)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addQueryParamWithPattern(String, String, boolean)
io.vertx.rxjava.ext.web.handler.CorsHandler.addRelativeOrigin(String)
io.vertx.rxjava3.ext.web.handler.CorsHandler.addRelativeOrigin(String)
io.vertx.ext.web.handler.CorsHandler.addRelativeOrigin(String) #addOriginsWithRegex(String) Add a relative origin to the list of allowed Origins. A relative origin is a regex that should match the format <scheme> "://" <hostname> [ ":" <port> ].
io.vertx.reactivex.ext.web.handler.CorsHandler.addRelativeOrigin(String)
io.vertx.rxjava.ext.web.handler.CorsHandler.addRelativeOrigins(List<String>)
io.vertx.rxjava3.ext.web.handler.CorsHandler.addRelativeOrigins(List<String>)
io.vertx.ext.web.handler.CorsHandler.addRelativeOrigins(List<String>) #addOriginsWithRegex(List) Set the list of allowed relative origins. A relative origin is a regex that should match the format <scheme> "://" <hostname> [ ":" <port> ].
io.vertx.reactivex.ext.web.handler.CorsHandler.addRelativeOrigins(List<String>)
io.vertx.rxjava.json.schema.SchemaRouter.addSchema(Schema, JsonPointer[])
io.vertx.rxjava3.json.schema.SchemaRouter.addSchema(Schema, JsonPointer[])
io.vertx.reactivex.json.schema.SchemaRouter.addSchema(Schema, JsonPointer[])
io.vertx.rxjava.json.schema.SchemaRouter.addSchemaAlias(Schema, String)
io.vertx.rxjava3.json.schema.SchemaRouter.addSchemaAlias(Schema, String)
io.vertx.reactivex.json.schema.SchemaRouter.addSchemaAlias(Schema, String)
io.vertx.rxjava.json.schema.SchemaRouter.addSchemaWithScope(Schema, JsonPointer)
io.vertx.rxjava3.json.schema.SchemaRouter.addSchemaWithScope(Schema, JsonPointer)
io.vertx.reactivex.json.schema.SchemaRouter.addSchemaWithScope(Schema, JsonPointer)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addSecurityHandler(String, Handler<RoutingContext>)
io.vertx.rxjava.ext.web.api.contract.RouterFactory.addSecurityHandler(String, Handler<RoutingContext>)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addSecurityHandler(String, Handler<RoutingContext>)
io.vertx.rxjava3.ext.web.api.contract.RouterFactory.addSecurityHandler(String, Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addSecurityHandler(String, Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.RouterFactory.addSecurityHandler(String, Handler<RoutingContext>)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addSecuritySchemaScopeValidator(String, String, Handler<RoutingContext>)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addSecuritySchemaScopeValidator(String, String, Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.addSecuritySchemaScopeValidator(String, String, Handler<RoutingContext>)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.addXMLBodySchema(String)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.addXMLBodySchema(String)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.addXMLBodySchema(String)
io.vertx.core.CompositeFuture.all(Future<T1>, Future<T2>) instead use Future.all(Future, Future)
io.vertx.core.CompositeFuture.all(Future<T1>, Future<T2>, Future<T3>) instead use Future.all(Future, Future, Future)
io.vertx.core.CompositeFuture.all(Future<T1>, Future<T2>, Future<T3>, Future<T4>) instead use Future.all(Future, Future, Future, Future)
io.vertx.core.CompositeFuture.all(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>) instead use Future.all(Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.all(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>, Future<T6>) instead use Future.all(Future, Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.all(List<Future>) instead use Future.all(List)
io.vertx.rxjava.ext.web.api.validation.ParameterValidationRule.allowEmptyValue()
io.vertx.rxjava3.ext.web.api.validation.ParameterValidationRule.allowEmptyValue()
io.vertx.reactivex.ext.web.api.validation.ParameterValidationRule.allowEmptyValue()
io.vertx.core.CompositeFuture.any(Future<T1>, Future<T2>) instead use Future.any(Future, Future)
io.vertx.core.CompositeFuture.any(Future<T1>, Future<T2>, Future<T3>) instead use Future.any(Future, Future, Future)
io.vertx.core.CompositeFuture.any(Future<T1>, Future<T2>, Future<T3>, Future<T4>) instead use Future.any(Future, Future, Future, Future)
io.vertx.core.CompositeFuture.any(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>) instead use Future.any(Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.any(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>, Future<T6>) instead use Future.any(Future, Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.any(List<Future>) instead use Future.any(List)
io.vertx.rxjava.ext.web.client.predicate.ErrorConverter.apply(ResponsePredicateResult)
io.vertx.rxjava3.ext.web.client.predicate.ErrorConverter.apply(ResponsePredicateResult)
io.vertx.reactivex.ext.web.client.predicate.ErrorConverter.apply(ResponsePredicateResult)
io.vertx.rxjava.ext.auth.authentication.AuthenticationProvider.authenticate(JsonObject)
io.vertx.rxjava3.ext.auth.authentication.AuthenticationProvider.authenticate(JsonObject)
io.vertx.ext.auth.authentication.AuthenticationProvider.authenticate(JsonObject) For type safety this method should be avoided and AuthenticationProvider.authenticate(Credentials) should be used instead.
io.vertx.reactivex.ext.auth.authentication.AuthenticationProvider.authenticate(JsonObject)
io.vertx.rxjava.ext.auth.authentication.AuthenticationProvider.authenticate(JsonObject, Handler<AsyncResult<User>>)
io.vertx.ext.auth.authentication.AuthenticationProvider.authenticate(JsonObject, Handler<AsyncResult<User>>) For type safety this method should be avoided and AuthenticationProvider.authenticate(Credentials, Handler) should be used instead.
io.vertx.reactivex.ext.auth.authentication.AuthenticationProvider.authenticate(JsonObject, Handler<AsyncResult<User>>)
io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth.authorizeURL(JsonObject)
io.vertx.rxjava3.ext.auth.oauth2.OAuth2Auth.authorizeURL(JsonObject)
io.vertx.ext.auth.oauth2.OAuth2Auth.authorizeURL(JsonObject) For type safety this method should be avoided and OAuth2Auth.authorizeURL(OAuth2AuthorizationURL) should be used instead.
io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth.authorizeURL(JsonObject)
io.vertx.rxjava.ext.shell.term.TermServer.authProvider(AuthProvider)
io.vertx.rxjava3.ext.shell.term.TermServer.authProvider(AuthProvider)
io.vertx.ext.shell.term.TermServer.authProvider(AuthProvider) See TermServer.authenticationProvider(AuthenticationProvider) Set an auth provider to use, any provider configured in options will override this provider. This should be used when a custom auth provider should be used.
io.vertx.reactivex.ext.shell.term.TermServer.authProvider(AuthProvider)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<ApolloWSMessage>>)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<ApolloWSMessage>>)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<ApolloWSMessage>>)
io.vertx.rxjava.ext.web.handler.graphql.ws.GraphQLWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>>)
io.vertx.rxjava3.ext.web.handler.graphql.ws.GraphQLWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>>)
io.vertx.ext.web.handler.graphql.ws.GraphQLWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>>) as of 4.5.1, use GraphQLWSHandler.builder(GraphQL) instead
io.vertx.reactivex.ext.web.handler.graphql.ws.GraphQLWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>>)
io.vertx.rxjava.ext.web.handler.graphql.GraphQLHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>>)
io.vertx.rxjava3.ext.web.handler.graphql.GraphQLHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>>)
io.vertx.ext.web.handler.graphql.GraphQLHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>>) as of 4.5.1, use GraphQLHandler.builder(GraphQL) instead
io.vertx.reactivex.ext.web.handler.graphql.GraphQLHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>>)
io.vertx.rxjava.ext.web.api.RequestParameters.body()
io.vertx.rxjava3.ext.web.api.RequestParameters.body()
io.vertx.reactivex.ext.web.api.RequestParameters.body()
io.vertx.rxjava3.ext.web.openapi.RouterBuilder.bodyHandler(BodyHandler)
io.vertx.ext.web.openapi.RouterBuilder.bodyHandler(BodyHandler) Use RouterBuilder.rootHandler(Handler) instead. The order matters, so adding the body handler should happen after any PLATFORM or SECURITY_POLICY handler(s).
io.vertx.reactivex.ext.web.openapi.RouterBuilder.bodyHandler(BodyHandler)
io.vertx.redis.client.RedisAPI.brpoplpush(String, String, String) since: 6.2.0, replaced by: BLMOVE with the RIGHT and LEFT arguments
io.vertx.rxjava.core.buffer.Buffer.buffer(ByteBuf)
io.vertx.rxjava3.core.buffer.Buffer.buffer(ByteBuf)
io.vertx.core.buffer.Buffer.buffer(ByteBuf) removed from public API in Vert.x 5
io.vertx.reactivex.core.buffer.Buffer.buffer(ByteBuf)
io.vertx.json.schema.common.dsl.SchemaBuilder.build(SchemaParser) This method creates an hard link to the parser which we want to avoid
io.vertx.rxjava.ext.web.validation.ValidationHandler.builder(SchemaParser)
io.vertx.rxjava3.ext.web.validation.ValidationHandler.builder(SchemaParser)
io.vertx.ext.web.validation.ValidationHandler.builder(SchemaParser) This method duplicates the behavior of ValidationHandlerBuilder.create(SchemaParser).
io.vertx.reactivex.ext.web.validation.ValidationHandler.builder(SchemaParser)
io.vertx.grpc.client.GrpcClient.call(SocketAddress, MethodDescriptor<Req, Resp>, Handler<GrpcClientRequest<Req, Resp>>, Function<GrpcClientResponse<Req, Resp>, Future<T>>) instead use GrpcIoClient.call(SocketAddress, MethodDescriptor, Handler, Function)
io.vertx.rxjava.grpc.client.GrpcClient.call(SocketAddress, MethodDescriptor<Req, Resp>, Handler<GrpcClientRequest<Req, Resp>>, Function<GrpcClientResponse<Req, Resp>, Future<T>>)
io.vertx.reactivex.grpc.client.GrpcClient.call(SocketAddress, MethodDescriptor<Req, Resp>, Handler<GrpcClientRequest<Req, Resp>>, Function<GrpcClientResponse<Req, Resp>, Future<T>>)
io.vertx.rxjava3.grpc.client.GrpcClient.call(SocketAddress, MethodDescriptor<Req, Resp>, Handler<GrpcClientRequest<Req, Resp>>, Function<GrpcClientResponse<Req, Resp>, Single<T>>)
io.vertx.reactivex.grpc.client.GrpcClient.call(SocketAddress, MethodDescriptor<Req, Resp>, Handler<GrpcClientRequest<Req, Resp>>, Function<GrpcClientResponse<Req, Resp>, Single<T>>)
io.vertx.grpc.server.GrpcServer.callHandler(MethodDescriptor<Req, Resp>, Handler<GrpcServerRequest<Req, Resp>>) use GrpcIoServer.callHandler(MethodDescriptor, Handler)
io.vertx.rxjava.grpc.server.GrpcServer.callHandler(MethodDescriptor<Req, Resp>, Handler<GrpcServerRequest<Req, Resp>>)
io.vertx.rxjava3.grpc.server.GrpcServer.callHandler(MethodDescriptor<Req, Resp>, Handler<GrpcServerRequest<Req, Resp>>)
io.vertx.reactivex.grpc.server.GrpcServer.callHandler(MethodDescriptor<Req, Resp>, Handler<GrpcServerRequest<Req, Resp>>)
io.vertx.rxjava.core.TimeoutStream.cancel()
io.vertx.rxjava3.core.TimeoutStream.cancel()
io.vertx.reactivex.core.TimeoutStream.cancel()
io.vertx.rxjava.ext.auth.User.clearCache()
io.vertx.rxjava3.ext.auth.User.clearCache()
io.vertx.ext.auth.User.clearCache() This method will be removed. Use Authorizations.clear()
io.vertx.reactivex.ext.auth.User.clearCache()
io.vertx.rxjava.ext.web.RoutingContext.clearUser()
io.vertx.rxjava3.ext.web.RoutingContext.clearUser()
io.vertx.ext.web.RoutingContext.clearUser() instead use UserContext.logout()
io.vertx.reactivex.ext.web.RoutingContext.clearUser()
io.vertx.rxjava.ext.consul.ConsulClient.cloneAclToken(String)
io.vertx.rxjava3.ext.consul.ConsulClient.cloneAclToken(String)
io.vertx.ext.consul.ConsulClient.cloneAclToken(String)
io.vertx.reactivex.ext.consul.ConsulClient.cloneAclToken(String)
io.vertx.rxjava.ext.consul.ConsulClient.cloneAclToken(String, Handler<AsyncResult<String>>)
io.vertx.ext.consul.ConsulClient.cloneAclToken(String, Handler<AsyncResult<String>>) Use ConsulClient.cloneAclToken(String, CloneAclTokenOptions) instead
io.vertx.reactivex.ext.consul.ConsulClient.cloneAclToken(String, Handler<AsyncResult<String>>)
io.vertx.rxjava.core.http.HttpServerResponse.close()
io.vertx.rxjava3.core.http.HttpServerResponse.close()
io.vertx.core.http.HttpServerResponse.close() instead use HttpConnection.close() or HttpServerResponse.reset(long), this method is removed in Vert.x 5
io.vertx.reactivex.core.http.HttpServerResponse.close()
io.vertx.config.spi.ConfigStore.close(Handler<Void>) implement ConfigStore.close() instead
io.vertx.rxjava.grpc.server.GrpcServerRequest.collecting(Collector<Req, A, R>)
io.vertx.rxjava3.grpc.server.GrpcServerRequest.collecting(Collector<Req, A, R>)
io.vertx.reactivex.grpc.server.GrpcServerRequest.collecting(Collector<Req, A, R>)
io.vertx.rxjava.grpc.client.GrpcClientResponse.collecting(Collector<Resp, A, R>)
io.vertx.rxjava3.grpc.client.GrpcClientResponse.collecting(Collector<Resp, A, R>)
io.vertx.reactivex.grpc.client.GrpcClientResponse.collecting(Collector<Resp, A, R>)
io.vertx.grpc.common.GrpcReadStream.collecting(Collector<T, A, R>) instead use ReadStream.collect(Collector)
io.vertx.rxjava.grpc.common.GrpcReadStream.collecting(Collector<T, A, R>)
io.vertx.rxjava3.grpc.common.GrpcReadStream.collecting(Collector<T, A, R>)
io.vertx.reactivex.grpc.common.GrpcReadStream.collecting(Collector<T, A, R>)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSConnectionInitEvent.complete(Object)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSConnectionInitEvent.complete(Object)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSConnectionInitEvent.complete(Object)
io.vertx.junit5.VertxTestContext.completing() Use VertxTestContext.succeedingThenComplete() instead.
io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.computeHash(String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuth.computeHash(String, String)
io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.computeHash(String, String, int)
io.vertx.rxjava.ext.auth.jdbc.JDBCHashStrategy.computeHash(String, String, int)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuth.computeHash(String, String, int)
io.vertx.reactivex.ext.auth.jdbc.JDBCHashStrategy.computeHash(String, String, int)
io.vertx.rxjava.ext.auth.mongo.HashStrategy.computeHash(String, User)
io.vertx.rxjava3.ext.auth.mongo.HashStrategy.computeHash(String, User)
io.vertx.reactivex.ext.auth.mongo.HashStrategy.computeHash(String, User)
io.vertx.rxjava.sqlclient.Pool.connectHandler(Handler<SqlConnection>)
io.vertx.rxjava3.sqlclient.Pool.connectHandler(Handler<SqlConnection>)
io.vertx.sqlclient.Pool.connectHandler(Handler<SqlConnection>) instead use ClientBuilder.withConnectHandler(Handler)
io.vertx.reactivex.sqlclient.Pool.connectHandler(Handler<SqlConnection>)
io.vertx.rxjava.core.http.HttpClient.connectionHandler(Handler<HttpConnection>)
io.vertx.rxjava3.core.http.HttpClient.connectionHandler(Handler<HttpConnection>)
io.vertx.core.http.HttpClient.connectionHandler(Handler<HttpConnection>) instead use HttpClientBuilder.withConnectHandler(Handler)
io.vertx.reactivex.core.http.HttpClient.connectionHandler(Handler<HttpConnection>)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.connectionHandler(Handler<ServerWebSocket>)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.connectionHandler(Handler<ServerWebSocket>)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.connectionHandler(Handler<ServerWebSocket>)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.connectionInitHandler(Handler<ApolloWSConnectionInitEvent>)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.connectionInitHandler(Handler<ApolloWSConnectionInitEvent>)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.connectionInitHandler(Handler<ApolloWSConnectionInitEvent>)
io.vertx.rxjava.ext.web.handler.graphql.ws.GraphQLWSHandler.connectionInitHandler(Handler<ConnectionInitEvent>)
io.vertx.rxjava3.ext.web.handler.graphql.ws.GraphQLWSHandler.connectionInitHandler(Handler<ConnectionInitEvent>)
io.vertx.ext.web.handler.graphql.ws.GraphQLWSHandler.connectionInitHandler(Handler<ConnectionInitEvent>) as of 4.5.1, use GraphQLWSHandler.builder(GraphQL) instead
io.vertx.reactivex.ext.web.handler.graphql.ws.GraphQLWSHandler.connectionInitHandler(Handler<ConnectionInitEvent>)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSMessage.connectionParams()
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSMessage.connectionParams()
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSMessage.connectionParams()
io.vertx.rxjava.sqlclient.Pool.connectionProvider(Function<Context, Future<SqlConnection>>)
io.vertx.sqlclient.Pool.connectionProvider(Function<Context, Future<SqlConnection>>) instead use ClientBuilder.connectingTo(Supplier)
io.vertx.reactivex.sqlclient.Pool.connectionProvider(Function<Context, Future<SqlConnection>>)
io.vertx.rxjava3.sqlclient.Pool.connectionProvider(Function<Context, Single<SqlConnection>>)
io.vertx.reactivex.sqlclient.Pool.connectionProvider(Function<Context, Single<SqlConnection>>)
io.vertx.rxjava.core.net.NetServer.connectStream()
io.vertx.rxjava3.core.net.NetServer.connectStream()
io.vertx.core.net.NetServer.connectStream() instead use NetServer.connectHandler(Handler)
io.vertx.reactivex.core.net.NetServer.connectStream()
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSMessage.content()
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSMessage.content()
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSMessage.content()
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicate.contentType(List<String>)
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicate.contentType(List<String>)
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicate.contentType(List<String>)
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicate.contentType(String)
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicate.contentType(String)
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicate.contentType(String)
io.vertx.rxjava.ext.web.RoutingContext.cookieCount()
io.vertx.rxjava3.ext.web.RoutingContext.cookieCount()
io.vertx.ext.web.RoutingContext.cookieCount() Use HttpServerRequest.cookieCount()
io.vertx.reactivex.ext.web.RoutingContext.cookieCount()
io.vertx.rxjava.ext.web.RoutingContext.cookieMap()
io.vertx.rxjava.core.http.HttpServerRequest.cookieMap()
io.vertx.rxjava3.ext.web.RoutingContext.cookieMap()
io.vertx.rxjava3.core.http.HttpServerRequest.cookieMap()
io.vertx.ext.web.RoutingContext.cookieMap() Use HttpServerRequest.cookieMap()
io.vertx.core.http.HttpServerRequest.cookieMap() the implementation made a wrong assumption that cookies could be identified only by their name. The RFC states that the tuple of <name, domain, path> is the unique identifier. When more than one cookie has the same name, the map will hold that lost one to be parsed and any previously parsed value will be silently overwritten.
io.vertx.reactivex.ext.web.RoutingContext.cookieMap()
io.vertx.reactivex.core.http.HttpServerRequest.cookieMap()
io.vertx.rxjava.ext.web.api.RequestParameters.cookieParameter(String)
io.vertx.rxjava3.ext.web.api.RequestParameters.cookieParameter(String)
io.vertx.reactivex.ext.web.api.RequestParameters.cookieParameter(String)
io.vertx.rxjava.ext.web.api.RequestParameters.cookieParametersNames()
io.vertx.rxjava3.ext.web.api.RequestParameters.cookieParametersNames()
io.vertx.reactivex.ext.web.api.RequestParameters.cookieParametersNames()
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.create()
io.vertx.rxjava.ext.web.handler.graphql.GraphiQLHandler.create()
io.vertx.rxjava.ext.web.handler.ChainAuthHandler.create()
io.vertx.rxjava.ext.auth.ChainAuth.create()
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.create()
io.vertx.rxjava3.ext.web.handler.graphql.GraphiQLHandler.create()
io.vertx.rxjava3.ext.web.handler.ChainAuthHandler.create()
io.vertx.rxjava3.ext.auth.ChainAuth.create()
io.vertx.ext.web.handler.graphql.GraphiQLHandler.create() as of 4.5.1, use GraphiQLHandler.create(Vertx), with GraphiQLHandler.router()
io.vertx.ext.web.handler.ChainAuthHandler.create() use ChainAuthHandler.any() instead.
io.vertx.ext.auth.ChainAuth.create()
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.create()
io.vertx.reactivex.ext.web.handler.graphql.GraphiQLHandler.create()
io.vertx.reactivex.ext.web.handler.ChainAuthHandler.create()
io.vertx.reactivex.ext.auth.ChainAuth.create()
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicate.create(Function<HttpResponse<Void>, ResponsePredicateResult>)
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicate.create(Function<HttpResponse<Void>, ResponsePredicateResult>)
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicate.create(Function<HttpResponse<Void>, ResponsePredicateResult>)
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicate.create(Function<HttpResponse<Void>, ResponsePredicateResult>, ErrorConverter)
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicate.create(Function<HttpResponse<Void>, ResponsePredicateResult>, ErrorConverter)
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicate.create(Function<HttpResponse<Void>, ResponsePredicateResult>, ErrorConverter)
io.vertx.rxjava.ext.web.client.predicate.ErrorConverter.create(Function<ResponsePredicateResult, Throwable>)
io.vertx.rxjava3.ext.web.client.predicate.ErrorConverter.create(Function<ResponsePredicateResult, Throwable>)
io.vertx.reactivex.ext.web.client.predicate.ErrorConverter.create(Function<ResponsePredicateResult, Throwable>)
io.vertx.rxjava.ext.web.handler.graphql.GraphiQLHandler.create(GraphiQLHandlerOptions)
io.vertx.rxjava3.ext.web.handler.graphql.GraphiQLHandler.create(GraphiQLHandlerOptions)
io.vertx.ext.web.handler.graphql.GraphiQLHandler.create(GraphiQLHandlerOptions) as of 4.5.1, use GraphiQLHandler.create(Vertx, GraphiQLHandlerOptions), with GraphiQLHandler.router()
io.vertx.reactivex.ext.web.handler.graphql.GraphiQLHandler.create(GraphiQLHandlerOptions)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.create(GraphQL)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.create(GraphQL)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.create(GraphQL)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.create(GraphQL, ApolloWSOptions)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.create(GraphQL, ApolloWSOptions)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.create(GraphQL, ApolloWSOptions)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.create(JDBCClient)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.create(JDBCClient)
io.vertx.rxjava.ext.auth.jdbc.JDBCAuthentication.create(JDBCClient, JDBCAuthenticationOptions)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuthentication.create(JDBCClient, JDBCAuthenticationOptions)
io.vertx.rxjava.ext.auth.jdbc.JDBCAuthentication.create(JDBCClient, JDBCHashStrategy, JDBCAuthenticationOptions)
io.vertx.ext.auth.jdbc.JDBCAuthentication.create(JDBCClient, JDBCHashStrategy, JDBCAuthenticationOptions) This factory is only for backwards compatibility
io.vertx.reactivex.ext.auth.jdbc.JDBCAuthentication.create(JDBCClient, JDBCHashStrategy, JDBCAuthenticationOptions)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.create(JDBCClient, String, String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.create(JDBCClient, String, String, String)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.create(MongoClient, JsonObject)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.create(MongoClient, JsonObject)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.create(MongoClient, JsonObject)
io.vertx.rxjava.ext.web.api.RequestParameter.create(Object)
io.vertx.rxjava3.ext.web.api.RequestParameter.create(Object)
io.vertx.reactivex.ext.web.api.RequestParameter.create(Object)
io.vertx.rxjava.ext.web.handler.graphql.schema.VertxPropertyDataFetcher.create(String)
io.vertx.rxjava.ext.web.handler.CorsHandler.create(String)
io.vertx.rxjava3.ext.web.handler.graphql.schema.VertxPropertyDataFetcher.create(String)
io.vertx.rxjava3.ext.web.handler.CorsHandler.create(String)
io.vertx.ext.web.handler.CorsHandler.create(String) patterns should use the relative origin method. Create a CORS handler using a regular expression to match origins. An origin follows rfc6454#section-7 and is expected to have the format: <scheme> "://" <hostname> [ ":" <port> ]
io.vertx.reactivex.ext.web.handler.graphql.schema.VertxPropertyDataFetcher.create(String)
io.vertx.reactivex.ext.web.handler.CorsHandler.create(String)
io.vertx.rxjava.ext.auth.jdbc.JDBCAuthorization.create(String, JDBCClient, JDBCAuthorizationOptions)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuthorization.create(String, JDBCClient, JDBCAuthorizationOptions)
io.vertx.rxjava.ext.web.api.RequestParameter.create(String, Object)
io.vertx.rxjava3.ext.web.api.RequestParameter.create(String, Object)
io.vertx.reactivex.ext.web.api.RequestParameter.create(String, Object)
io.vertx.rxjava.ext.web.templ.jade.JadeTemplateEngine.create(Vertx)
io.vertx.rxjava3.ext.web.templ.jade.JadeTemplateEngine.create(Vertx)
io.vertx.reactivex.ext.web.templ.jade.JadeTemplateEngine.create(Vertx)
io.vertx.rxjava.json.schema.SchemaRouter.create(Vertx, HttpClient, FileSystem, SchemaRouterOptions)
io.vertx.rxjava3.json.schema.SchemaRouter.create(Vertx, HttpClient, FileSystem, SchemaRouterOptions)
io.vertx.reactivex.json.schema.SchemaRouter.create(Vertx, HttpClient, FileSystem, SchemaRouterOptions)
io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.create(Vertx, JDBCClient)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuth.create(Vertx, JDBCClient)
io.vertx.rxjava.json.schema.SchemaRouter.create(Vertx, SchemaRouterOptions)
io.vertx.rxjava3.json.schema.SchemaRouter.create(Vertx, SchemaRouterOptions)
io.vertx.reactivex.json.schema.SchemaRouter.create(Vertx, SchemaRouterOptions)
io.vertx.rxjava.ext.auth.shiro.ShiroAuth.create(Vertx, ShiroAuthOptions)
io.vertx.rxjava3.ext.auth.shiro.ShiroAuth.create(Vertx, ShiroAuthOptions)
io.vertx.reactivex.ext.auth.shiro.ShiroAuth.create(Vertx, ShiroAuthOptions)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.create(Vertx, String)
io.vertx.rxjava.ext.web.templ.jade.JadeTemplateEngine.create(Vertx, String)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.create(Vertx, String)
io.vertx.rxjava3.ext.web.templ.jade.JadeTemplateEngine.create(Vertx, String)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.create(Vertx, String)
io.vertx.reactivex.ext.web.templ.jade.JadeTemplateEngine.create(Vertx, String)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.create(Vertx, String, Handler<AsyncResult<OpenAPI3RouterFactory>>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.create(Vertx, String, Handler<AsyncResult<OpenAPI3RouterFactory>>)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.create(Vertx, String, List<JsonObject>)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.create(Vertx, String, List<JsonObject>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.create(Vertx, String, List<JsonObject>)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.create(Vertx, String, List<JsonObject>, Handler<AsyncResult<OpenAPI3RouterFactory>>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.create(Vertx, String, List<JsonObject>, Handler<AsyncResult<OpenAPI3RouterFactory>>)
io.vertx.rxjava.ext.consul.ConsulClient.createAclToken(AclToken)
io.vertx.rxjava3.ext.consul.ConsulClient.createAclToken(AclToken)
io.vertx.ext.consul.ConsulClient.createAclToken(AclToken)
io.vertx.reactivex.ext.consul.ConsulClient.createAclToken(AclToken)
io.vertx.rxjava.ext.consul.ConsulClient.createAclToken(AclToken, Handler<AsyncResult<String>>)
io.vertx.ext.consul.ConsulClient.createAclToken(AclToken, Handler<AsyncResult<String>>) Use ConsulClient.createAclToken(io.vertx.ext.consul.token.AclToken) instead
io.vertx.reactivex.ext.consul.ConsulClient.createAclToken(AclToken, Handler<AsyncResult<String>>)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createArrayTypeValidator(ParameterTypeValidator)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createArrayTypeValidator(ParameterTypeValidator)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createArrayTypeValidator(ParameterTypeValidator)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createArrayTypeValidator(ParameterTypeValidator, String, Integer, Integer)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createArrayTypeValidator(ParameterTypeValidator, String, Integer, Integer)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createArrayTypeValidator(ParameterTypeValidator, String, Integer, Integer)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createBooleanTypeValidator(Object)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createBooleanTypeValidator(Object)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createBooleanTypeValidator(Object)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createDoubleTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createDoubleTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createDoubleTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createDoubleTypeValidator(Double)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createDoubleTypeValidator(Double)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createDoubleTypeValidator(Double)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createDoubleTypeValidator(Double, Double, Double, Double)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createDoubleTypeValidator(Double, Double, Double, Double)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createDoubleTypeValidator(Double, Double, Double, Double)
io.vertx.rxjava.json.schema.SchemaParser.createDraft201909SchemaParser(SchemaRouter)
io.vertx.rxjava3.json.schema.SchemaParser.createDraft201909SchemaParser(SchemaRouter)
io.vertx.reactivex.json.schema.SchemaParser.createDraft201909SchemaParser(SchemaRouter)
io.vertx.rxjava.json.schema.SchemaParser.createDraft7SchemaParser(SchemaRouter)
io.vertx.rxjava3.json.schema.SchemaParser.createDraft7SchemaParser(SchemaRouter)
io.vertx.reactivex.json.schema.SchemaParser.createDraft7SchemaParser(SchemaRouter)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createEnumTypeValidatorWithInnerValidator(List<Object>, ParameterTypeValidator)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createEnumTypeValidatorWithInnerValidator(List<Object>, ParameterTypeValidator)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createEnumTypeValidatorWithInnerValidator(List<Object>, ParameterTypeValidator)
io.vertx.json.schema.ValidationException.createException(String, String, Object) just use ValidationException.create(String, String, Object)
io.vertx.json.schema.ValidationException.createException(String, String, Object, Collection<Throwable>) just use ValidationException.create(String, String, Object, Collection)
io.vertx.json.schema.ValidationException.createException(String, String, Object, Throwable) just use ValidationException.create(String, String, Object, Throwable)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createFloatTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createFloatTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createFloatTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createFloatTypeValidator(Double, Double, Double, Float)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createFloatTypeValidator(Double, Double, Double, Float)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createFloatTypeValidator(Double, Double, Double, Float)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createFloatTypeValidator(Float)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createFloatTypeValidator(Float)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createFloatTypeValidator(Float)
io.vertx.rxjava.ext.web.client.predicate.ErrorConverter.createFullBody(Function<ResponsePredicateResult, Throwable>)
io.vertx.rxjava3.ext.web.client.predicate.ErrorConverter.createFullBody(Function<ResponsePredicateResult, Throwable>)
io.vertx.reactivex.ext.web.client.predicate.ErrorConverter.createFullBody(Function<ResponsePredicateResult, Throwable>)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.createHashedUser(String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.createHashedUser(String, String)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.createHashedUser(String, String, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.createHashedUser(String, String, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createIntegerTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createIntegerTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createIntegerTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createIntegerTypeValidator(Double, Double, Double, Integer)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createIntegerTypeValidator(Double, Double, Double, Integer)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createIntegerTypeValidator(Double, Double, Double, Integer)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createIntegerTypeValidator(Integer)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createIntegerTypeValidator(Integer)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createIntegerTypeValidator(Integer)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createLongTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createLongTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createLongTypeValidator(Boolean, Double, Boolean, Double, Double, Object)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createLongTypeValidator(Double, Double, Double, Long)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createLongTypeValidator(Double, Double, Double, Long)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createLongTypeValidator(Double, Double, Double, Long)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createLongTypeValidator(Long)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createLongTypeValidator(Long)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createLongTypeValidator(Long)
io.vertx.rxjava.json.schema.SchemaParser.createOpenAPI3SchemaParser(SchemaRouter)
io.vertx.rxjava3.json.schema.SchemaParser.createOpenAPI3SchemaParser(SchemaRouter)
io.vertx.reactivex.json.schema.SchemaParser.createOpenAPI3SchemaParser(SchemaRouter)
io.vertx.rxjava.ext.auth.jdbc.JDBCHashStrategy.createPBKDF2(Vertx)
io.vertx.reactivex.ext.auth.jdbc.JDBCHashStrategy.createPBKDF2(Vertx)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.createRolePermission(String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.createRolePermission(String, String)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.createRolePermission(String, String, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.createRolePermission(String, String, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.auth.jdbc.JDBCHashStrategy.createSHA512(Vertx)
io.vertx.reactivex.ext.auth.jdbc.JDBCHashStrategy.createSHA512(Vertx)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createStringEnumTypeValidator(List<String>)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createStringEnumTypeValidator(List<String>)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createStringEnumTypeValidator(List<String>)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createStringTypeValidator(Object)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createStringTypeValidator(Object)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createStringTypeValidator(Object)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createStringTypeValidator(String, Integer, Integer, Object)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createStringTypeValidator(String, Integer, Integer, Object)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createStringTypeValidator(String, Integer, Integer, Object)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.createStringTypeValidator(String, Object)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.createStringTypeValidator(String, Object)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.createStringTypeValidator(String, Object)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.createUser(String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.createUser(String, String)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.createUser(String, String, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.createUser(String, String, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.createUserRole(String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.createUserRole(String, String)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.createUserRole(String, String, Handler<AsyncResult<Void>>)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.createUserRole(String, String, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.auth.VertxContextPRNG.current()
io.vertx.rxjava3.ext.auth.VertxContextPRNG.current()
io.vertx.reactivex.ext.auth.VertxContextPRNG.current()
io.vertx.rxjava.ext.auth.VertxContextPRNG.current(Vertx)
io.vertx.rxjava3.ext.auth.VertxContextPRNG.current(Vertx)
io.vertx.reactivex.ext.auth.VertxContextPRNG.current(Vertx)
io.vertx.rxjava.ext.web.handler.LoggerHandler.customFormatter(Function<HttpServerRequest, String>)
io.vertx.rxjava3.ext.web.handler.LoggerHandler.customFormatter(Function<HttpServerRequest, String>)
io.vertx.ext.web.handler.LoggerHandler.customFormatter(Function<HttpServerRequest, String>) Superseded by LoggerHandler.customFormatter(LoggerFormatter)
io.vertx.reactivex.ext.web.handler.LoggerHandler.customFormatter(Function<HttpServerRequest, String>)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.dataLoaderRegistry(Function<ApolloWSMessage, DataLoaderRegistry>)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.dataLoaderRegistry(Function<ApolloWSMessage, DataLoaderRegistry>)
io.vertx.ext.web.handler.graphql.ApolloWSHandler.dataLoaderRegistry(Function<ApolloWSMessage, DataLoaderRegistry>) as of 4.2, use ApolloWSHandler.beforeExecute(Handler) instead
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.dataLoaderRegistry(Function<ApolloWSMessage, DataLoaderRegistry>)
io.vertx.rxjava.ext.web.handler.graphql.GraphQLHandler.dataLoaderRegistry(Function<RoutingContext, DataLoaderRegistry>)
io.vertx.rxjava3.ext.web.handler.graphql.GraphQLHandler.dataLoaderRegistry(Function<RoutingContext, DataLoaderRegistry>)
io.vertx.ext.web.handler.graphql.GraphQLHandler.dataLoaderRegistry(Function<RoutingContext, DataLoaderRegistry>) as of 4.2, use GraphQLHandler.beforeExecute(Handler) instead
io.vertx.reactivex.ext.web.handler.graphql.GraphQLHandler.dataLoaderRegistry(Function<RoutingContext, DataLoaderRegistry>)
io.vertx.core.logging.Logger.debug(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.debug(Object, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.debug(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.debug(Object, Throwable, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.core.file.FileSystem.deleteRecursive(String, boolean)
io.vertx.rxjava3.core.file.FileSystem.deleteRecursive(String, boolean)
io.vertx.core.file.FileSystem.deleteRecursive(String, boolean) instead use FileSystem.deleteRecursive(String) or FileSystem.delete(String)
io.vertx.reactivex.core.file.FileSystem.deleteRecursive(String, boolean)
io.vertx.rxjava.core.file.FileSystem.deleteRecursive(String, boolean, Handler<AsyncResult<Void>>)
io.vertx.core.file.FileSystem.deleteRecursive(String, boolean, Handler<AsyncResult<Void>>) instead use FileSystem.deleteRecursive(String, Handler) or FileSystem.delete(String, Handler)
io.vertx.reactivex.core.file.FileSystem.deleteRecursive(String, boolean, Handler<AsyncResult<Void>>)
io.vertx.rxjava.core.file.FileSystem.deleteRecursiveBlocking(String, boolean)
io.vertx.rxjava3.core.file.FileSystem.deleteRecursiveBlocking(String, boolean)
io.vertx.core.file.FileSystem.deleteRecursiveBlocking(String, boolean) instead use FileSystem.deleteRecursiveBlocking(String) or FileSystem.deleteBlocking(String)
io.vertx.reactivex.core.file.FileSystem.deleteRecursiveBlocking(String, boolean)
io.vertx.rxjava.ext.web.api.validation.ContainerDeserializer.deserializeArray(String)
io.vertx.rxjava3.ext.web.api.validation.ContainerDeserializer.deserializeArray(String)
io.vertx.reactivex.ext.web.api.validation.ContainerDeserializer.deserializeArray(String)
io.vertx.rxjava.ext.web.api.validation.ContainerDeserializer.deserializeObject(String)
io.vertx.rxjava3.ext.web.api.validation.ContainerDeserializer.deserializeObject(String)
io.vertx.reactivex.ext.web.api.validation.ContainerDeserializer.deserializeObject(String)
io.vertx.rxjava.ext.consul.ConsulClient.destroyAclToken(String)
io.vertx.rxjava3.ext.consul.ConsulClient.destroyAclToken(String)
io.vertx.ext.consul.ConsulClient.destroyAclToken(String)
io.vertx.reactivex.ext.consul.ConsulClient.destroyAclToken(String)
io.vertx.rxjava.ext.consul.ConsulClient.destroyAclToken(String, Handler<AsyncResult<Void>>)
io.vertx.ext.consul.ConsulClient.destroyAclToken(String, Handler<AsyncResult<Void>>) Use ConsulClient.deleteAclToken(String) instead
io.vertx.reactivex.ext.consul.ConsulClient.destroyAclToken(String, Handler<AsyncResult<Void>>)
io.vertx.rxjava.ext.web.handler.graphql.ws.GraphQLWSHandler.endHandler(Handler<ServerWebSocket>)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.endHandler(Handler<ServerWebSocket>)
io.vertx.rxjava3.ext.web.handler.graphql.ws.GraphQLWSHandler.endHandler(Handler<ServerWebSocket>)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.endHandler(Handler<ServerWebSocket>)
io.vertx.ext.web.handler.graphql.ws.GraphQLWSHandler.endHandler(Handler<ServerWebSocket>) as of 4.5.1, use GraphQLWSHandler.builder(GraphQL) instead
io.vertx.reactivex.ext.web.handler.graphql.ws.GraphQLWSHandler.endHandler(Handler<ServerWebSocket>)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.endHandler(Handler<ServerWebSocket>)
io.vertx.rxjava.core.datagram.DatagramSocket.endHandler(Handler<Void>)
io.vertx.rxjava.core.TimeoutStream.endHandler(Handler<Void>)
io.vertx.rxjava3.core.datagram.DatagramSocket.endHandler(Handler<Void>)
io.vertx.rxjava3.core.TimeoutStream.endHandler(Handler<Void>)
io.vertx.core.datagram.DatagramSocket.endHandler(Handler<Void>) removed in Vert.x 5
io.vertx.reactivex.core.datagram.DatagramSocket.endHandler(Handler<Void>)
io.vertx.reactivex.core.TimeoutStream.endHandler(Handler<Void>)
io.vertx.core.logging.Logger.error(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.error(Object, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.error(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.error(Object, Throwable, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicate.errorConverter()
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicate.errorConverter()
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicate.errorConverter()
io.vertx.core.Future.eventually(Function<Void, Future<U>>) instead use Future.eventually(Supplier), this method will be removed in Vert.x 5
io.vertx.rxjava.core.TimeoutStream.exceptionHandler(Handler<Throwable>)
io.vertx.rxjava3.core.TimeoutStream.exceptionHandler(Handler<Throwable>)
io.vertx.reactivex.core.TimeoutStream.exceptionHandler(Handler<Throwable>)
io.vertx.rxjava.core.Context.executeBlocking(Handler<Promise<T>>)
io.vertx.rxjava.core.Vertx.executeBlocking(Handler<Promise<T>>)
io.vertx.rxjava.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>)
io.vertx.rxjava3.core.Context.executeBlocking(Handler<Promise<T>>)
io.vertx.rxjava3.core.Vertx.executeBlocking(Handler<Promise<T>>)
io.vertx.rxjava3.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>)
io.vertx.core.Context.executeBlocking(Handler<Promise<T>>) instead use Context.executeBlocking(Callable)
io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>>) instead use Vertx.executeBlocking(Callable)
io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>) instead use WorkerExecutor.executeBlocking(Callable)
io.vertx.reactivex.core.Context.executeBlocking(Handler<Promise<T>>)
io.vertx.reactivex.core.Vertx.executeBlocking(Handler<Promise<T>>)
io.vertx.reactivex.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>)
io.vertx.rxjava.core.Context.executeBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava.core.Vertx.executeBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava3.core.Context.executeBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava3.core.Vertx.executeBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava3.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, boolean)
io.vertx.core.Context.executeBlocking(Handler<Promise<T>>, boolean) instead use Context.executeBlocking(Callable, boolean)
io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>>, boolean) instead use Vertx.executeBlocking(Callable, boolean)
io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, boolean) instead use WorkerExecutor.executeBlocking(Callable, boolean)
io.vertx.reactivex.core.Context.executeBlocking(Handler<Promise<T>>, boolean)
io.vertx.reactivex.core.Vertx.executeBlocking(Handler<Promise<T>>, boolean)
io.vertx.reactivex.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava.core.Context.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>)
io.vertx.rxjava.core.Vertx.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>)
io.vertx.rxjava.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>)
io.vertx.core.Context.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>) instead use Context.executeBlocking(Callable, boolean)
io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>) use instead Vertx.executeBlocking(Callable, boolean)
io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>) instead use WorkerExecutor.executeBlocking(Callable, boolean)
io.vertx.reactivex.core.Context.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>)
io.vertx.reactivex.core.Vertx.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>)
io.vertx.reactivex.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>)
io.vertx.rxjava.core.Context.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>)
io.vertx.rxjava.core.Vertx.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>)
io.vertx.rxjava.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>)
io.vertx.core.Context.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>) instead use Context.executeBlocking(Callable)
io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>) instead use Vertx.executeBlocking(Callable)
io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>) instead use WorkerExecutor.executeBlocking(Callable)
io.vertx.reactivex.core.Context.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>)
io.vertx.reactivex.core.Vertx.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>)
io.vertx.reactivex.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>)
io.vertx.rxjava.ext.web.client.HttpRequest.expect(Function<HttpResponse<Void>, ResponsePredicateResult>)
io.vertx.rxjava3.ext.web.client.HttpRequest.expect(Function<HttpResponse<Void>, ResponsePredicateResult>)
io.vertx.ext.web.client.HttpRequest.expect(Function<HttpResponse<Void>, ResponsePredicateResult>) instead use HttpResponseExpectation along with Future.expecting(Expectation)
io.vertx.reactivex.ext.web.client.HttpRequest.expect(Function<HttpResponse<Void>, ResponsePredicateResult>)
io.vertx.rxjava.ext.web.client.HttpRequest.expect(ResponsePredicate)
io.vertx.rxjava3.ext.web.client.HttpRequest.expect(ResponsePredicate)
io.vertx.ext.web.client.HttpRequest.expect(ResponsePredicate) instead use HttpResponseExpectation along with Future.expecting(Expectation)
io.vertx.reactivex.ext.web.client.HttpRequest.expect(ResponsePredicate)
io.vertx.rxjava.ext.web.client.HttpRequest.expectations()
io.vertx.rxjava3.ext.web.client.HttpRequest.expectations()
io.vertx.ext.web.client.HttpRequest.expectations()
io.vertx.reactivex.ext.web.client.HttpRequest.expectations()
io.vertx.junit5.VertxTestContext.failing() Use VertxTestContext.failingThenComplete() or VertxTestContext.failing(Handler), for example failing(e -> checkpoint.flag()), failing(e -> { more testing code }), or failing(e -> {}).
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicateResult.failure(String)
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicateResult.failure(String)
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicateResult.failure(String)
io.vertx.core.logging.Logger.fatal(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.fatal(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.core.datagram.DatagramSocket.fetch(long)
io.vertx.rxjava.core.TimeoutStream.fetch(long)
io.vertx.rxjava3.core.datagram.DatagramSocket.fetch(long)
io.vertx.rxjava3.core.TimeoutStream.fetch(long)
io.vertx.core.datagram.DatagramSocket.fetch(long) no replacement for back-pressure, instead ignore the packet or buffer it somewhere
io.vertx.reactivex.core.datagram.DatagramSocket.fetch(long)
io.vertx.reactivex.core.TimeoutStream.fetch(long)
io.vertx.rxjava.ext.web.api.RequestParameters.formParameter(String)
io.vertx.rxjava3.ext.web.api.RequestParameters.formParameter(String)
io.vertx.reactivex.ext.web.api.RequestParameters.formParameter(String)
io.vertx.rxjava.ext.web.api.RequestParameters.formParametersNames()
io.vertx.rxjava3.ext.web.api.RequestParameters.formParametersNames()
io.vertx.reactivex.ext.web.api.RequestParameters.formParametersNames()
io.vertx.ext.jdbc.spi.JDBCColumnDescriptorProvider.fromParameter(PreparedStatement) Implementations should prefer JDBCColumnDescriptorProvider.fromParameterMetaData(ParameterMetaData) Create provider by parameter statement
io.vertx.ext.jdbc.spi.JDBCColumnDescriptorProvider.fromResult(ResultSet) Implementations should prefer JDBCColumnDescriptorProvider.fromResultMetaData(ResultSetMetaData) Create provider by result set metadata
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSConnectionInitEvent.future()
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSConnectionInitEvent.future()
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSConnectionInitEvent.future()
io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.generateSalt()
io.vertx.rxjava.ext.auth.jdbc.JDBCHashStrategy.generateSalt()
io.vertx.reactivex.ext.auth.jdbc.JDBCAuth.generateSalt()
io.vertx.reactivex.ext.auth.jdbc.JDBCHashStrategy.generateSalt()
io.vertx.redis.client.RedisAPI.georadius(List<String>) since: 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS argument
io.vertx.redis.client.RedisAPI.georadiusbymember(List<String>) since: 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS and FROMMEMBER arguments
io.vertx.redis.client.RedisAPI.georadiusbymemberRo(List<String>) since: 6.2.0, replaced by: GEOSEARCH with the BYRADIUS and FROMMEMBER arguments
io.vertx.redis.client.RedisAPI.georadiusRo(List<String>) since: 6.2.0, replaced by: GEOSEARCH with the BYRADIUS argument
io.vertx.config.spi.ConfigStore.get(Handler<AsyncResult<Buffer>>) implement ConfigStore.get() instead
io.vertx.rxjava.ext.auth.HashingStrategy.get(String)
io.vertx.rxjava3.ext.auth.HashingStrategy.get(String)
io.vertx.reactivex.ext.auth.HashingStrategy.get(String)
io.vertx.rxjava.ext.web.api.RequestParameter.getArray()
io.vertx.rxjava3.ext.web.api.RequestParameter.getArray()
io.vertx.reactivex.ext.web.api.RequestParameter.getArray()
io.vertx.rxjava.ext.web.RoutingContext.getBody()
io.vertx.rxjava3.ext.web.RoutingContext.getBody()
io.vertx.ext.web.RoutingContext.getBody() Use RoutingContext.body() instead.
io.vertx.reactivex.ext.web.RoutingContext.getBody()
io.vertx.rxjava.ext.web.RoutingContext.getBodyAsJson()
io.vertx.rxjava3.ext.web.RoutingContext.getBodyAsJson()
io.vertx.ext.web.RoutingContext.getBodyAsJson() Use RoutingContext.body() instead.
io.vertx.reactivex.ext.web.RoutingContext.getBodyAsJson()
io.vertx.rxjava.ext.web.RoutingContext.getBodyAsJson(int)
io.vertx.rxjava3.ext.web.RoutingContext.getBodyAsJson(int)
io.vertx.ext.web.RoutingContext.getBodyAsJson(int) Use RoutingContext.body() instead. Gets the current body buffer as a JsonObject. If a positive limit is provided the parsing will only happen if the buffer length is smaller or equal to the limit. Otherwise an IllegalStateException is thrown. When the application is only handling uploads in JSON format, it is recommended to set a limit on BodyHandler.setBodyLimit(long) as this will avoid the upload to be parsed and loaded into the application memory.
io.vertx.reactivex.ext.web.RoutingContext.getBodyAsJson(int)
io.vertx.rxjava.ext.web.RoutingContext.getBodyAsJsonArray()
io.vertx.rxjava3.ext.web.RoutingContext.getBodyAsJsonArray()
io.vertx.ext.web.RoutingContext.getBodyAsJsonArray() Use RoutingContext.body() instead.
io.vertx.reactivex.ext.web.RoutingContext.getBodyAsJsonArray()
io.vertx.rxjava.ext.web.RoutingContext.getBodyAsJsonArray(int)
io.vertx.rxjava3.ext.web.RoutingContext.getBodyAsJsonArray(int)
io.vertx.ext.web.RoutingContext.getBodyAsJsonArray(int) Use RoutingContext.body() instead. Gets the current body buffer as a JsonArray. If a positive limit is provided the parsing will only happen if the buffer length is smaller or equal to the limit. Otherwise an IllegalStateException is thrown. When the application is only handling uploads in JSON format, it is recommended to set a limit on BodyHandler.setBodyLimit(long) as this will avoid the upload to be parsed and loaded into the application memory.
io.vertx.reactivex.ext.web.RoutingContext.getBodyAsJsonArray(int)
io.vertx.rxjava.ext.web.RoutingContext.getBodyAsString()
io.vertx.rxjava3.ext.web.RoutingContext.getBodyAsString()
io.vertx.ext.web.RoutingContext.getBodyAsString() Use RoutingContext.body() instead.
io.vertx.reactivex.ext.web.RoutingContext.getBodyAsString()
io.vertx.rxjava.ext.web.RoutingContext.getBodyAsString(String)
io.vertx.rxjava3.ext.web.RoutingContext.getBodyAsString(String)
io.vertx.ext.web.RoutingContext.getBodyAsString(String) Use RoutingContext.body() instead. Get the entire HTTP request body as a string, assuming the specified encoding. The context must have first been routed to a BodyHandler for this to be populated.
io.vertx.reactivex.ext.web.RoutingContext.getBodyAsString(String)
io.vertx.rxjava.ext.web.api.RequestParameter.getBoolean()
io.vertx.rxjava3.ext.web.api.RequestParameter.getBoolean()
io.vertx.reactivex.ext.web.api.RequestParameter.getBoolean()
io.vertx.rxjava.core.buffer.Buffer.getByteBuf()
io.vertx.rxjava3.core.buffer.Buffer.getByteBuf()
io.vertx.core.buffer.Buffer.getByteBuf() removed from public API in Vert.x 5
io.vertx.reactivex.core.buffer.Buffer.getByteBuf()
io.vertx.ext.auth.oauth2.OAuth2Options.getClientID() see OAuth2Options.getClientId()
io.vertx.pgclient.PgException.getCode() use PgException.getSqlState() instead
io.vertx.rxjava.ext.auth.mongo.MongoAuth.getCollectionName()
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.getCollectionName()
io.vertx.reactivex.ext.auth.mongo.MongoAuth.getCollectionName()
io.vertx.rxjava.ext.web.RoutingContext.getCookie(String)
io.vertx.rxjava3.ext.web.RoutingContext.getCookie(String)
io.vertx.ext.web.RoutingContext.getCookie(String) Use HttpServerRequest.getCookie(String) Get the cookie with the specified name.
io.vertx.reactivex.ext.web.RoutingContext.getCookie(String)
io.vertx.pgclient.data.Money.getDecimalPart() as of 4.5, use Money.bigDecimalValue() instead
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.getDefault()
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.getDefault()
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.getDefault()
io.vertx.core.logging.Logger.getDelegate() see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.ext.web.api.RequestParameter.getDouble()
io.vertx.rxjava3.ext.web.api.RequestParameter.getDouble()
io.vertx.reactivex.ext.web.api.RequestParameter.getDouble()
io.vertx.core.DeploymentOptions.getExtraClasspath()
io.vertx.rxjava.ext.web.api.RequestParameter.getFloat()
io.vertx.rxjava3.ext.web.api.RequestParameter.getFloat()
io.vertx.reactivex.ext.web.api.RequestParameter.getFloat()
io.vertx.ext.auth.oauth2.OAuth2Options.getFlow() see Oauth2Credentials.getFlow()
io.vertx.ext.web.templ.handlebars.HandlebarsTemplateEngine.getHandlebars() see TemplateEngine.unwrap() Get a reference to the internal Handlebars object so it can be configured.
io.vertx.rxjava.ext.auth.jdbc.JDBCHashStrategy.getHashedStoredPwd(JsonArray)
io.vertx.reactivex.ext.auth.jdbc.JDBCHashStrategy.getHashedStoredPwd(JsonArray)
io.vertx.redis.client.RedisClusterConnectOptions.getHashSlotCacheTTL() use RedisClusterConnectOptions.getTopologyCacheTTL()
io.vertx.rxjava.ext.auth.mongo.MongoAuth.getHashStrategy()
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.getHashStrategy()
io.vertx.reactivex.ext.auth.mongo.MongoAuth.getHashStrategy()
io.vertx.rxjava.core.http.HttpClientRequest.getHost()
io.vertx.rxjava3.core.http.HttpClientRequest.getHost()
io.vertx.core.http.HttpClientRequest.getHost()
io.vertx.reactivex.core.http.HttpClientRequest.getHost()
io.vertx.ext.auth.webauthn.RelyingParty.getIcon()
io.vertx.rxjava.ext.web.api.RequestParameter.getInteger()
io.vertx.rxjava3.ext.web.api.RequestParameter.getInteger()
io.vertx.reactivex.ext.web.api.RequestParameter.getInteger()
io.vertx.pgclient.data.Money.getIntegerPart() as of 4.5, use Money.bigDecimalValue() instead
io.vertx.core.DeploymentOptions.getIsolatedClasses()
io.vertx.core.DeploymentOptions.getIsolationGroup()
io.vertx.ext.web.templ.jade.JadeTemplateEngine.getJadeConfiguration() see TemplateEngine.unwrap() Get a reference to the internal JadeConfiguration object so it can be configured.
io.vertx.core.net.TCPSSLOptions.getJdkSslEngineOptions() instead use TCPSSLOptions.getSslEngineOptions()
io.vertx.rxjava.json.schema.Schema.getJson()
io.vertx.rxjava3.json.schema.Schema.getJson()
io.vertx.reactivex.json.schema.Schema.getJson()
io.vertx.rxjava.ext.web.api.RequestParameter.getJsonArray()
io.vertx.rxjava3.ext.web.api.RequestParameter.getJsonArray()
io.vertx.reactivex.ext.web.api.RequestParameter.getJsonArray()
io.vertx.rxjava.ext.web.api.RequestParameter.getJsonObject()
io.vertx.rxjava3.ext.web.api.RequestParameter.getJsonObject()
io.vertx.reactivex.ext.web.api.RequestParameter.getJsonObject()
io.vertx.spi.cluster.ignite.IgniteSslOptions.getKeyAlgorithm() Use vert.x ssl certificate options instead. It will be removed in vert.x 4.1
io.vertx.ext.mail.MailConfig.getKeyStore() use TCPSSLOptions.getTrustStoreOptions()
io.vertx.spi.cluster.ignite.IgniteSslOptions.getKeyStoreFilePath() Use vert.x jksKeyCertOptions.path instead. It will be removed in vert.x 4.1
io.vertx.core.net.TCPSSLOptions.getKeyStoreOptions() instead use TCPSSLOptions.getKeyCertOptions()
io.vertx.ext.mail.MailConfig.getKeyStorePassword() use TCPSSLOptions.getTrustStoreOptions()
io.vertx.spi.cluster.ignite.IgniteSslOptions.getKeyStorePassword() Use vert.x jksKeyCertOptions.password instead. It will be removed in vert.x 4.1
io.vertx.spi.cluster.ignite.IgniteSslOptions.getKeyStoreType() Use vert.x ssl certificate options instead. It will be removed in vert.x 4.1
io.vertx.core.logging.LoggerFactory.getLogger(Class<?>) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.LoggerFactory.getLogger(String) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.ext.web.api.RequestParameter.getLong()
io.vertx.rxjava3.ext.web.api.RequestParameter.getLong()
io.vertx.reactivex.ext.web.api.RequestParameter.getLong()
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.getMessage(GraphQLContext)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.getMessage(GraphQLContext)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.getMessage(GraphQLContext)
io.vertx.ext.dropwizard.DropwizardMetricsOptions.getMetricRegistry()
io.vertx.micrometer.MicrometerMetricsOptions.getMicrometerRegistry() see MicrometerMetricsOptions.setMicrometerRegistry(MeterRegistry)
io.vertx.rxjava.ext.web.api.RequestParameter.getName()
io.vertx.rxjava.ext.web.api.validation.ParameterValidationRule.getName()
io.vertx.rxjava3.ext.web.api.RequestParameter.getName()
io.vertx.rxjava3.ext.web.api.validation.ParameterValidationRule.getName()
io.vertx.reactivex.ext.web.api.RequestParameter.getName()
io.vertx.reactivex.ext.web.api.validation.ParameterValidationRule.getName()
io.vertx.ext.consul.Check.getNodeName()
io.vertx.micrometer.VertxInfluxDbOptions.getNumThreads() no longer used by Micrometer
io.vertx.rxjava.ext.web.api.RequestParameter.getObjectKeys()
io.vertx.rxjava3.ext.web.api.RequestParameter.getObjectKeys()
io.vertx.reactivex.ext.web.api.RequestParameter.getObjectKeys()
io.vertx.rxjava.ext.web.api.RequestParameter.getObjectValue(String)
io.vertx.rxjava3.ext.web.api.RequestParameter.getObjectValue(String)
io.vertx.reactivex.ext.web.api.RequestParameter.getObjectValue(String)
io.vertx.core.net.TCPSSLOptions.getOpenSslEngineOptions() instead use TCPSSLOptions.getSslEngineOptions()
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getOptions()
io.vertx.rxjava.ext.web.api.contract.RouterFactory.getOptions()
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getOptions()
io.vertx.rxjava3.ext.web.api.contract.RouterFactory.getOptions()
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getOptions()
io.vertx.reactivex.ext.web.api.contract.RouterFactory.getOptions()
io.vertx.rxjava.ext.auth.mongo.MongoAuth.getPasswordCredentialField()
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.getPasswordCredentialField()
io.vertx.reactivex.ext.auth.mongo.MongoAuth.getPasswordCredentialField()
io.vertx.rxjava.ext.auth.mongo.MongoAuth.getPasswordField()
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.getPasswordField()
io.vertx.reactivex.ext.auth.mongo.MongoAuth.getPasswordField()
io.vertx.core.net.TCPSSLOptions.getPemKeyCertOptions() instead use TCPSSLOptions.getKeyCertOptions()
io.vertx.core.net.TCPSSLOptions.getPemTrustOptions() instead use TCPSSLOptions.getTrustOptions()
io.vertx.rxjava.ext.auth.mongo.MongoAuth.getPermissionField()
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.getPermissionField()
io.vertx.reactivex.ext.auth.mongo.MongoAuth.getPermissionField()
io.vertx.ext.auth.JWTOptions.getPermissions()
io.vertx.ext.auth.jwt.JWTAuthOptions.getPermissionsClaimKey() AuthN and AuthZ have been split in vert.x 4.0.0 in order to specify where authorization will happen see JWTAuthorization.
io.vertx.core.net.TCPSSLOptions.getPfxKeyCertOptions() instead use TCPSSLOptions.getKeyCertOptions()
io.vertx.core.net.TCPSSLOptions.getPfxTrustOptions() instead use TCPSSLOptions.getTrustOptions()
io.vertx.rxjava.core.http.HttpClientRequest.getPort()
io.vertx.rxjava3.core.http.HttpClientRequest.getPort()
io.vertx.core.http.HttpClientRequest.getPort()
io.vertx.reactivex.core.http.HttpClientRequest.getPort()
io.vertx.ext.auth.PubSecKeyOptions.getPublicKey()
io.vertx.rxjava.core.cli.CommandLine.getRawValues(Option)
io.vertx.rxjava3.core.cli.CommandLine.getRawValues(Option)
io.vertx.core.cli.CommandLine.getRawValues(Option) use CommandLine.getRawValuesForOption(Option)
io.vertx.reactivex.core.cli.CommandLine.getRawValues(Option)
io.vertx.spi.cluster.ignite.IgniteCacheOptions.getRebalanceDelay() Use baseline topology feature instead. Please, be aware this API will be removed in the next releases.
io.vertx.micrometer.MicrometerMetricsOptions.getRequestsTagsProvider() use getServerRequestTagsProvider instead
io.vertx.ext.web.templ.handlebars.HandlebarsTemplateEngine.getResolvers() see TemplateEngine.unwrap() Return the array of configured handlebars context value resolvers.
io.vertx.rxjava.ext.auth.mongo.MongoAuth.getRoleField()
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.getRoleField()
io.vertx.reactivex.ext.auth.mongo.MongoAuth.getRoleField()
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getRouter()
io.vertx.rxjava.ext.web.api.contract.RouterFactory.getRouter()
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getRouter()
io.vertx.rxjava3.ext.web.api.contract.RouterFactory.getRouter()
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getRouter()
io.vertx.reactivex.ext.web.api.contract.RouterFactory.getRouter()
io.vertx.rxjava.ext.web.handler.graphql.GraphQLHandler.getRoutingContext(GraphQLContext)
io.vertx.rxjava3.ext.web.handler.graphql.GraphQLHandler.getRoutingContext(GraphQLContext)
io.vertx.ext.web.handler.graphql.GraphQLHandler.getRoutingContext(GraphQLContext) invoke GraphQLContext.get(Object) with RoutingContext class object instead.
io.vertx.reactivex.ext.web.handler.graphql.GraphQLHandler.getRoutingContext(GraphQLContext)
io.vertx.rxjava.ext.auth.jdbc.JDBCHashStrategy.getSalt(JsonArray)
io.vertx.reactivex.ext.auth.jdbc.JDBCHashStrategy.getSalt(JsonArray)
io.vertx.rxjava.ext.auth.mongo.HashStrategy.getSalt(User)
io.vertx.rxjava3.ext.auth.mongo.HashStrategy.getSalt(User)
io.vertx.reactivex.ext.auth.mongo.HashStrategy.getSalt(User)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.getSaltField()
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.getSaltField()
io.vertx.reactivex.ext.auth.mongo.MongoAuth.getSaltField()
io.vertx.rxjava.ext.auth.mongo.HashStrategy.getSaltStyle()
io.vertx.rxjava3.ext.auth.mongo.HashStrategy.getSaltStyle()
io.vertx.reactivex.ext.auth.mongo.HashStrategy.getSaltStyle()
io.vertx.rxjava3.ext.web.openapi.RouterBuilder.getSchemaParser()
io.vertx.ext.web.openapi.RouterBuilder.getSchemaParser() This method exposes the internal of the OpenAPI handler, it will be removed in the future. Users should configure the json schema module from the options.
io.vertx.reactivex.ext.web.openapi.RouterBuilder.getSchemaParser()
io.vertx.rxjava.json.schema.SchemaParser.getSchemaRouter()
io.vertx.rxjava3.ext.web.openapi.RouterBuilder.getSchemaRouter()
io.vertx.rxjava3.json.schema.SchemaParser.getSchemaRouter()
io.vertx.ext.web.openapi.RouterBuilder.getSchemaRouter() This method exposes the internal of the OpenAPI handler, it will be removed in the future. Users should configure the json schema module from the options.
io.vertx.reactivex.ext.web.openapi.RouterBuilder.getSchemaRouter()
io.vertx.reactivex.json.schema.SchemaParser.getSchemaRouter()
io.vertx.rxjava.json.schema.Schema.getScope()
io.vertx.rxjava3.json.schema.Schema.getScope()
io.vertx.reactivex.json.schema.Schema.getScope()
io.vertx.ext.auth.PubSecKeyOptions.getSecretKey()
io.vertx.redis.client.RedisAPI.getset(String, String) since: 6.2.0, replaced by: SET with the !GET argument
io.vertx.rxjava.ext.auth.mongo.HashStrategy.getStoredPwd(User)
io.vertx.rxjava3.ext.auth.mongo.HashStrategy.getStoredPwd(User)
io.vertx.reactivex.ext.auth.mongo.HashStrategy.getStoredPwd(User)
io.vertx.rxjava.ext.web.api.RequestParameter.getString()
io.vertx.rxjava3.ext.web.api.RequestParameter.getString()
io.vertx.reactivex.ext.web.api.RequestParameter.getString()
io.vertx.ext.web.templ.thymeleaf.ThymeleafTemplateEngine.getThymeleafTemplateEngine() see TemplateEngine.unwrap() Get a reference to the internal Thymeleaf TemplateEngine object so it can be configured.
io.vertx.spi.cluster.ignite.IgniteSslOptions.getTrustStoreFilePath() Use vert.x jksTrustOptions.path instead. It will be removed in vert.x 4.1
io.vertx.core.net.TCPSSLOptions.getTrustStoreOptions() instead use TCPSSLOptions.getTrustOptions()
io.vertx.spi.cluster.ignite.IgniteSslOptions.getTrustStorePassword() Use vert.x jksTrustOptions.password instead. It will be removed in vert.x 4.1
io.vertx.spi.cluster.ignite.IgniteSslOptions.getTrustStoreType() Use vert.x jksTrustOptions instead. It will be removed in vert.x 4.1
io.vertx.core.http.HttpClientOptions.getTryWebSocketDeflateFrameCompression() instead use HttpClientOptions.tryUsePerFrameWebSocketCompression
io.vertx.rxjava.ext.auth.mongo.MongoAuth.getUsernameCredentialField()
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.getUsernameCredentialField()
io.vertx.reactivex.ext.auth.mongo.MongoAuth.getUsernameCredentialField()
io.vertx.rxjava.ext.auth.mongo.MongoAuth.getUsernameField()
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.getUsernameField()
io.vertx.reactivex.ext.auth.mongo.MongoAuth.getUsernameField()
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getValidationFailureHandler()
io.vertx.rxjava.ext.web.api.contract.RouterFactory.getValidationFailureHandler()
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getValidationFailureHandler()
io.vertx.rxjava3.ext.web.api.contract.RouterFactory.getValidationFailureHandler()
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.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.getValidationFailureHandler()
io.vertx.reactivex.ext.web.api.contract.RouterFactory.getValidationFailureHandler()
io.vertx.ext.auth.KeyStoreOptions.getValue()
io.vertx.mqtt.MqttClientOptions.getWillMessage()
io.vertx.rxjava.ext.web.handler.graphql.GraphiQLHandler.graphiQLRequestHeaders(Function<RoutingContext, MultiMap>)
io.vertx.rxjava3.ext.web.handler.graphql.GraphiQLHandler.graphiQLRequestHeaders(Function<RoutingContext, MultiMap>)
io.vertx.ext.web.handler.graphql.GraphiQLHandler.graphiQLRequestHeaders(Function<RoutingContext, MultiMap>) as of 4.5.1, use GraphiQLHandler.builder(Vertx) instead
io.vertx.reactivex.ext.web.handler.graphql.GraphiQLHandler.graphiQLRequestHeaders(Function<RoutingContext, MultiMap>)
io.vertx.rxjava.ext.web.api.contract.HTTPOperationRequestValidationHandler.handle(RoutingContext)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler.handle(RoutingContext)
io.vertx.rxjava.ext.web.api.validation.ValidationHandler.handle(RoutingContext)
io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler.handle(RoutingContext)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.handle(RoutingContext)
io.vertx.rxjava.ext.web.handler.sockjs.SockJSHandler.handle(RoutingContext)
io.vertx.rxjava3.ext.web.api.contract.HTTPOperationRequestValidationHandler.handle(RoutingContext)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler.handle(RoutingContext)
io.vertx.rxjava3.ext.web.api.validation.ValidationHandler.handle(RoutingContext)
io.vertx.rxjava3.ext.web.api.validation.HTTPRequestValidationHandler.handle(RoutingContext)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.handle(RoutingContext)
io.vertx.rxjava3.ext.web.handler.sockjs.SockJSHandler.handle(RoutingContext)
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.reactivex.ext.web.api.contract.HTTPOperationRequestValidationHandler.handle(RoutingContext)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler.handle(RoutingContext)
io.vertx.reactivex.ext.web.api.validation.ValidationHandler.handle(RoutingContext)
io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler.handle(RoutingContext)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.handle(RoutingContext)
io.vertx.reactivex.ext.web.handler.sockjs.SockJSHandler.handle(RoutingContext)
io.vertx.rxjava.core.TimeoutStream.handler(Handler<Long>)
io.vertx.rxjava3.core.TimeoutStream.handler(Handler<Long>)
io.vertx.reactivex.core.TimeoutStream.handler(Handler<Long>)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.hasDefault()
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.hasDefault()
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.hasDefault()
io.vertx.rxjava.ext.auth.jdbc.JDBCAuthentication.hash(String, Map<String, String>, String, String)
io.vertx.rxjava.ext.auth.HashingStrategy.hash(String, Map<String, String>, String, String)
io.vertx.rxjava3.ext.auth.HashingStrategy.hash(String, Map<String, String>, String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuthentication.hash(String, Map<String, String>, String, String)
io.vertx.reactivex.ext.auth.HashingStrategy.hash(String, Map<String, String>, String, String)
io.vertx.rxjava.ext.auth.jdbc.JDBCAuthentication.hash(String, String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuthentication.hash(String, String, String)
io.vertx.rxjava.ext.web.api.RequestParameters.headerParameter(String)
io.vertx.rxjava3.ext.web.api.RequestParameters.headerParameter(String)
io.vertx.reactivex.ext.web.api.RequestParameters.headerParameter(String)
io.vertx.rxjava.ext.web.api.RequestParameters.headerParametersNames()
io.vertx.rxjava3.ext.web.api.RequestParameters.headerParametersNames()
io.vertx.reactivex.ext.web.api.RequestParameters.headerParametersNames()
io.vertx.redis.client.RedisAPI.hmset(List<String>) since: 4.0.0, replaced by: HSET with multiple field-value pairs
io.vertx.rxjava.core.http.HttpServerRequest.host()
io.vertx.rxjava.core.http.ServerWebSocket.host()
io.vertx.rxjava3.core.http.HttpServerRequest.host()
io.vertx.rxjava3.core.http.ServerWebSocket.host()
io.vertx.core.http.HttpServerRequest.host() instead use HttpServerRequest.authority()
io.vertx.core.http.ServerWebSocket.host() use ServerWebSocket.authority() instead
io.vertx.reactivex.core.http.HttpServerRequest.host()
io.vertx.reactivex.core.http.ServerWebSocket.host()
io.vertx.rxjava.ext.auth.HashingAlgorithm.id()
io.vertx.rxjava3.ext.auth.HashingAlgorithm.id()
io.vertx.reactivex.ext.auth.HashingAlgorithm.id()
io.vertx.core.logging.Logger.info(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.info(Object, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.info(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.info(Object, Throwable, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.ext.consul.ConsulClient.infoAclToken(String)
io.vertx.rxjava3.ext.consul.ConsulClient.infoAclToken(String)
io.vertx.ext.consul.ConsulClient.infoAclToken(String)
io.vertx.reactivex.ext.consul.ConsulClient.infoAclToken(String)
io.vertx.rxjava.ext.consul.ConsulClient.infoAclToken(String, Handler<AsyncResult<AclToken>>)
io.vertx.ext.consul.ConsulClient.infoAclToken(String, Handler<AsyncResult<AclToken>>) Use ConsulClient.readAclToken(String) instead
io.vertx.reactivex.ext.consul.ConsulClient.infoAclToken(String, Handler<AsyncResult<AclToken>>)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.insertUser(String, String, List<String>, List<String>)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.insertUser(String, String, List<String>, List<String>)
io.vertx.ext.auth.mongo.MongoAuth.insertUser(String, String, List<String>, List<String>) Please use MongoUserUtil instead. Insert a new user into mongo in the convenient way
io.vertx.reactivex.ext.auth.mongo.MongoAuth.insertUser(String, String, List<String>, List<String>)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.insertUser(String, String, List<String>, List<String>, Handler<AsyncResult<String>>)
io.vertx.ext.auth.mongo.MongoAuth.insertUser(String, String, List<String>, List<String>, Handler<AsyncResult<String>>) Please use MongoUserUtil instead. Insert a new user into mongo in the convenient way
io.vertx.reactivex.ext.auth.mongo.MongoAuth.insertUser(String, String, List<String>, List<String>, Handler<AsyncResult<String>>)
io.vertx.rxjava.ext.web.api.RequestParameter.isArray()
io.vertx.rxjava3.ext.web.api.RequestParameter.isArray()
io.vertx.reactivex.ext.web.api.RequestParameter.isArray()
io.vertx.rxjava.ext.auth.User.isAuthorized(Authorization)
io.vertx.rxjava3.ext.auth.User.isAuthorized(Authorization)
io.vertx.ext.auth.User.isAuthorized(Authorization)
io.vertx.reactivex.ext.auth.User.isAuthorized(Authorization)
io.vertx.rxjava.ext.auth.User.isAuthorized(Authorization, Handler<AsyncResult<Boolean>>)
io.vertx.ext.auth.User.isAuthorized(Authorization, Handler<AsyncResult<Boolean>>)
io.vertx.reactivex.ext.auth.User.isAuthorized(Authorization, Handler<AsyncResult<Boolean>>)
io.vertx.rxjava.ext.auth.User.isAuthorized(String)
io.vertx.rxjava3.ext.auth.User.isAuthorized(String)
io.vertx.ext.auth.User.isAuthorized(String) Use typed alternative User.isAuthorized(Authorization)
io.vertx.reactivex.ext.auth.User.isAuthorized(String)
io.vertx.rxjava.ext.auth.User.isAuthorized(String, Handler<AsyncResult<Boolean>>)
io.vertx.ext.auth.User.isAuthorized(String, Handler<AsyncResult<Boolean>>) Use typed alternative User.isAuthorized(Authorization, Handler)
io.vertx.reactivex.ext.auth.User.isAuthorized(String, Handler<AsyncResult<Boolean>>)
io.vertx.rxjava.ext.web.api.RequestParameter.isBoolean()
io.vertx.rxjava3.ext.web.api.RequestParameter.isBoolean()
io.vertx.reactivex.ext.web.api.RequestParameter.isBoolean()
io.vertx.ext.auth.PubSecKeyOptions.isCertificate()
io.vertx.core.logging.Logger.isDebugEnabled() see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.ext.web.api.RequestParameter.isDouble()
io.vertx.rxjava3.ext.web.api.RequestParameter.isDouble()
io.vertx.reactivex.ext.web.api.RequestParameter.isDouble()
io.vertx.rxjava.ext.web.api.RequestParameter.isEmpty()
io.vertx.rxjava3.ext.web.api.RequestParameter.isEmpty()
io.vertx.reactivex.ext.web.api.RequestParameter.isEmpty()
io.vertx.rxjava.ext.auth.jdbc.JDBCHashStrategy.isEqual(String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCHashStrategy.isEqual(String, String)
io.vertx.rxjava.ext.web.api.RequestParameter.isFloat()
io.vertx.rxjava3.ext.web.api.RequestParameter.isFloat()
io.vertx.reactivex.ext.web.api.RequestParameter.isFloat()
io.vertx.core.logging.Logger.isInfoEnabled() see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.ext.web.api.RequestParameter.isInteger()
io.vertx.rxjava3.ext.web.api.RequestParameter.isInteger()
io.vertx.reactivex.ext.web.api.RequestParameter.isInteger()
io.vertx.rxjava.ext.web.api.RequestParameter.isJsonArray()
io.vertx.rxjava3.ext.web.api.RequestParameter.isJsonArray()
io.vertx.reactivex.ext.web.api.RequestParameter.isJsonArray()
io.vertx.rxjava.ext.web.api.RequestParameter.isJsonObject()
io.vertx.rxjava3.ext.web.api.RequestParameter.isJsonObject()
io.vertx.reactivex.ext.web.api.RequestParameter.isJsonObject()
io.vertx.rxjava.ext.web.api.RequestParameter.isLong()
io.vertx.rxjava3.ext.web.api.RequestParameter.isLong()
io.vertx.reactivex.ext.web.api.RequestParameter.isLong()
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.rxjava.ext.web.api.RequestParameter.isNull()
io.vertx.rxjava3.ext.web.api.RequestParameter.isNull()
io.vertx.reactivex.ext.web.api.RequestParameter.isNull()
io.vertx.rxjava.ext.web.api.RequestParameter.isObject()
io.vertx.rxjava3.ext.web.api.RequestParameter.isObject()
io.vertx.reactivex.ext.web.api.RequestParameter.isObject()
io.vertx.rxjava.ext.web.api.validation.ParameterValidationRule.isOptional()
io.vertx.rxjava3.ext.web.api.validation.ParameterValidationRule.isOptional()
io.vertx.reactivex.ext.web.api.validation.ParameterValidationRule.isOptional()
io.vertx.ext.auth.oauth2.OAuth2Options.isRotateJWKs()
io.vertx.rxjava.ext.web.api.RequestParameter.isString()
io.vertx.rxjava3.ext.web.api.RequestParameter.isString()
io.vertx.reactivex.ext.web.api.RequestParameter.isString()
io.vertx.ext.auth.PubSecKeyOptions.isSymmetric()
io.vertx.rxjava.json.schema.Schema.isSync()
io.vertx.rxjava3.json.schema.Schema.isSync()
io.vertx.reactivex.json.schema.Schema.isSync()
io.vertx.core.logging.Logger.isTraceEnabled() see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.http.HttpClientOptions.isTryUseCompression() as of 4.5, use HttpClientOptions.isDecompressionSupported() instead
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.isValid(String)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.isValid(String)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.isValid(String)
io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator.isValidCollection(List<String>)
io.vertx.rxjava3.ext.web.api.validation.ParameterTypeValidator.isValidCollection(List<String>)
io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator.isValidCollection(List<String>)
io.vertx.core.logging.Logger.isWarnEnabled() see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.DeploymentOptions.isWorker() instead use DeploymentOptions.getThreadingModel()
io.vertx.core.CompositeFuture.join(Future<T1>, Future<T2>) instead use Future.join(Future, Future)
io.vertx.core.CompositeFuture.join(Future<T1>, Future<T2>, Future<T3>) instead use Future.join(Future, Future, Future)
io.vertx.core.CompositeFuture.join(Future<T1>, Future<T2>, Future<T3>, Future<T4>) instead use Future.join(Future, Future, Future, Future)
io.vertx.core.CompositeFuture.join(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>) instead use Future.join(Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.join(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>, Future<T6>) instead use Future.join(Future, Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.join(List<Future>) instead use Future.join(List)
io.vertx.core.net.KeyCertOptions.keyManagerMapper(Vertx) instead use KeyCertOptions.keyManagerFactoryMapper(Vertx)
io.vertx.rxjava.ext.consul.ConsulClient.listAclTokens()
io.vertx.rxjava3.ext.consul.ConsulClient.listAclTokens()
io.vertx.ext.consul.ConsulClient.listAclTokens()
io.vertx.reactivex.ext.consul.ConsulClient.listAclTokens()
io.vertx.rxjava.ext.consul.ConsulClient.listAclTokens(Handler<AsyncResult<List<AclToken>>>)
io.vertx.ext.consul.ConsulClient.listAclTokens(Handler<AsyncResult<List<AclToken>>>) Use ConsulClient.getAclTokens() instead
io.vertx.reactivex.ext.consul.ConsulClient.listAclTokens(Handler<AsyncResult<List<AclToken>>>)
io.vertx.rxjava.ext.auth.HashingStrategy.load()
io.vertx.rxjava3.ext.auth.HashingStrategy.load()
io.vertx.reactivex.ext.auth.HashingStrategy.load()
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.locale(Function<ApolloWSMessage, Locale>)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.locale(Function<ApolloWSMessage, Locale>)
io.vertx.ext.web.handler.graphql.ApolloWSHandler.locale(Function<ApolloWSMessage, Locale>) as of 4.2, use ApolloWSHandler.beforeExecute(Handler) instead
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.locale(Function<ApolloWSMessage, Locale>)
io.vertx.rxjava.ext.web.handler.graphql.GraphQLHandler.locale(Function<RoutingContext, Locale>)
io.vertx.rxjava3.ext.web.handler.graphql.GraphQLHandler.locale(Function<RoutingContext, Locale>)
io.vertx.ext.web.handler.graphql.GraphQLHandler.locale(Function<RoutingContext, Locale>) as of 4.2, use GraphQLHandler.beforeExecute(Handler) instead
io.vertx.reactivex.ext.web.handler.graphql.GraphQLHandler.locale(Function<RoutingContext, Locale>)
io.vertx.rxjava.ext.web.api.RequestParameter.merge(RequestParameter)
io.vertx.rxjava3.ext.web.api.RequestParameter.merge(RequestParameter)
io.vertx.reactivex.ext.web.api.RequestParameter.merge(RequestParameter)
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicateResult.message()
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSConnectionInitEvent.message()
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicateResult.message()
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSConnectionInitEvent.message()
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicateResult.message()
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSConnectionInitEvent.message()
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.messageHandler(Handler<ApolloWSMessage>)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.messageHandler(Handler<ApolloWSMessage>)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.messageHandler(Handler<ApolloWSMessage>)
io.vertx.rxjava.ext.web.handler.graphql.ws.GraphQLWSHandler.messageHandler(Handler<Message>)
io.vertx.rxjava3.ext.web.handler.graphql.ws.GraphQLWSHandler.messageHandler(Handler<Message>)
io.vertx.ext.web.handler.graphql.ws.GraphQLWSHandler.messageHandler(Handler<Message>) as of 4.5.1, use GraphQLWSHandler.builder(GraphQL) instead
io.vertx.reactivex.ext.web.handler.graphql.ws.GraphQLWSHandler.messageHandler(Handler<Message>)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.mountOperationToEventBus(String, String)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.mountOperationToEventBus(String, String)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.mountOperationToEventBus(String, String)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.mountServiceFromTag(String, String)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.mountServiceFromTag(String, String)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.mountServiceFromTag(String, String)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.mountServicesFromExtensions()
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.mountServicesFromExtensions()
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.mountServicesFromExtensions()
io.vertx.rxjava.ext.web.Router.mountSubRouter(String, Router)
io.vertx.rxjava3.ext.web.Router.mountSubRouter(String, Router)
io.vertx.ext.web.Router.mountSubRouter(String, Router) This method duplicates the sub router functionality from Route.subRouter(Router). Mount a sub router on this router
io.vertx.reactivex.ext.web.Router.mountSubRouter(String, Router)
io.vertx.grpc.VertxChannelBuilder.nameResolverFactory(NameResolver.Factory)
io.vertx.rxjava.ext.auth.HashingAlgorithm.needsSeparator()
io.vertx.rxjava3.ext.auth.HashingAlgorithm.needsSeparator()
io.vertx.reactivex.ext.auth.HashingAlgorithm.needsSeparator()
io.vertx.rxjava.core.Vertx.nettyEventLoopGroup()
io.vertx.rxjava3.core.Vertx.nettyEventLoopGroup()
io.vertx.core.Vertx.nettyEventLoopGroup() removed from public API in Vert.x 5
io.vertx.reactivex.core.Vertx.nettyEventLoopGroup()
io.vertx.rxjava.ext.web.RoutingContext.normalisedPath()
io.vertx.rxjava3.ext.web.RoutingContext.normalisedPath()
io.vertx.ext.web.RoutingContext.normalisedPath()
io.vertx.reactivex.ext.web.RoutingContext.normalisedPath()
io.vertx.rxjava.redis.client.Request.nullArg()
io.vertx.rxjava3.redis.client.Request.nullArg()
io.vertx.reactivex.redis.client.Request.nullArg()
io.vertx.redis.client.Request.nullArg() REDIS does not support null as a parameter, only as response. This was a deviation from the official protocol which should be avoided. Other clients explicitly do not allow this. Adds a null encoded string. Redis does not allow storing the null value by itself. This method will encode any null value as the four character long string "null". As a recommendation, this method should not be used directly unless this is the intented behavior. It is present to handle special cases such as encoding of JsonObject and JsonArray which may contain null values.
io.vertx.mssqlclient.MSSQLException.number() use DatabaseException.getErrorCode() instead
io.vertx.rxjava.core.streams.Pump.numberPumped()
io.vertx.rxjava3.core.streams.Pump.numberPumped()
io.vertx.reactivex.core.streams.Pump.numberPumped()
io.vertx.httpproxy.HttpProxy.originRequestProvider(BiFunction<HttpServerRequest, HttpClient, Future<HttpClientRequest>>) use HttpProxy.origin(OriginRequestProvider) instead
io.vertx.httpproxy.HttpProxy.originSelector(Function<HttpServerRequest, Future<SocketAddress>>) use HttpProxy.origin(OriginRequestProvider) instead
io.vertx.rxjava3.httpproxy.HttpProxy.originSelector(Function<HttpServerRequest, Single<SocketAddress>>)
io.vertx.rxjava.ext.web.api.validation.ParameterValidationRule.parameterTypeValidator()
io.vertx.rxjava3.ext.web.api.validation.ParameterValidationRule.parameterTypeValidator()
io.vertx.reactivex.ext.web.api.validation.ParameterValidationRule.parameterTypeValidator()
io.vertx.rxjava.ext.auth.HashingAlgorithm.params()
io.vertx.rxjava3.ext.auth.HashingAlgorithm.params()
io.vertx.reactivex.ext.auth.HashingAlgorithm.params()
io.vertx.rxjava.json.schema.SchemaParser.parse(Boolean)
io.vertx.rxjava3.json.schema.SchemaParser.parse(Boolean)
io.vertx.reactivex.json.schema.SchemaParser.parse(Boolean)
io.vertx.rxjava.json.schema.SchemaParser.parse(Boolean, JsonPointer)
io.vertx.rxjava3.json.schema.SchemaParser.parse(Boolean, JsonPointer)
io.vertx.reactivex.json.schema.SchemaParser.parse(Boolean, JsonPointer)
io.vertx.rxjava.json.schema.SchemaParser.parse(JsonObject)
io.vertx.rxjava3.json.schema.SchemaParser.parse(JsonObject)
io.vertx.reactivex.json.schema.SchemaParser.parse(JsonObject)
io.vertx.rxjava.json.schema.SchemaParser.parse(JsonObject, JsonPointer)
io.vertx.rxjava3.json.schema.SchemaParser.parse(JsonObject, JsonPointer)
io.vertx.reactivex.json.schema.SchemaParser.parse(JsonObject, JsonPointer)
io.vertx.rxjava.json.schema.SchemaParser.parseFromString(String)
io.vertx.rxjava3.json.schema.SchemaParser.parseFromString(String)
io.vertx.reactivex.json.schema.SchemaParser.parseFromString(String)
io.vertx.rxjava.json.schema.SchemaParser.parseFromString(String, JsonPointer)
io.vertx.rxjava3.json.schema.SchemaParser.parseFromString(String, JsonPointer)
io.vertx.reactivex.json.schema.SchemaParser.parseFromString(String, JsonPointer)
io.vertx.rxjava.ext.web.api.contract.HTTPOperationRequestValidationHandler.parseOperationSpec()
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler.parseOperationSpec()
io.vertx.rxjava3.ext.web.api.contract.HTTPOperationRequestValidationHandler.parseOperationSpec()
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler.parseOperationSpec()
io.vertx.reactivex.ext.web.api.contract.HTTPOperationRequestValidationHandler.parseOperationSpec()
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler.parseOperationSpec()
io.vertx.rxjava.ext.web.api.RequestParameters.pathParameter(String)
io.vertx.rxjava3.ext.web.api.RequestParameters.pathParameter(String)
io.vertx.reactivex.ext.web.api.RequestParameters.pathParameter(String)
io.vertx.rxjava.ext.web.api.RequestParameters.pathParametersNames()
io.vertx.rxjava3.ext.web.api.RequestParameters.pathParametersNames()
io.vertx.reactivex.ext.web.api.RequestParameters.pathParametersNames()
io.vertx.rxjava.core.datagram.DatagramSocket.pause()
io.vertx.rxjava.core.TimeoutStream.pause()
io.vertx.rxjava3.core.datagram.DatagramSocket.pause()
io.vertx.rxjava3.core.TimeoutStream.pause()
io.vertx.core.datagram.DatagramSocket.pause() no replacement for back-pressure, instead ignore the packet or buffer it somewhere
io.vertx.reactivex.core.datagram.DatagramSocket.pause()
io.vertx.reactivex.core.TimeoutStream.pause()
io.vertx.core.net.NetSocket.peerCertificateChain() instead use NetSocket.peerCertificates() or NetSocket.sslSession()
io.vertx.core.http.WebSocketBase.peerCertificateChain() instead use WebSocketBase.peerCertificates() or WebSocketBase.sslSession()
io.vertx.core.http.HttpConnection.peerCertificateChain() instead use HttpConnection.peerCertificates() or HttpConnection.sslSession()
io.vertx.rxjava.core.Vertx.periodicStream(long)
io.vertx.rxjava3.core.Vertx.periodicStream(long)
io.vertx.core.Vertx.periodicStream(long) use Vertx.setPeriodic(long, io.vertx.core.Handler<java.lang.Long>) instead. RxJava like integrations should use the Vert.x scheduler integration.
io.vertx.reactivex.core.Vertx.periodicStream(long)
io.vertx.rxjava.core.Vertx.periodicStream(long, long)
io.vertx.rxjava3.core.Vertx.periodicStream(long, long)
io.vertx.core.Vertx.periodicStream(long, long) use Vertx.setPeriodic(long, io.vertx.core.Handler<java.lang.Long>) instead. RxJava like integrations should use the Vert.x scheduler integration.
io.vertx.reactivex.core.Vertx.periodicStream(long, long)
io.vertx.rxjava.core.TimeoutStream.pipe()
io.vertx.rxjava3.core.TimeoutStream.pipe()
io.vertx.reactivex.core.TimeoutStream.pipe()
io.vertx.rxjava.core.TimeoutStream.pipeTo(WriteStream<Long>)
io.vertx.rxjava3.core.TimeoutStream.pipeTo(WriteStream<Long>)
io.vertx.reactivex.core.TimeoutStream.pipeTo(WriteStream<Long>)
io.vertx.rxjava.core.TimeoutStream.pipeTo(WriteStream<Long>, Handler<AsyncResult<Void>>)
io.vertx.reactivex.core.TimeoutStream.pipeTo(WriteStream<Long>, Handler<AsyncResult<Void>>)
io.vertx.rxjava.jdbcclient.JDBCPool.pool(Vertx, DataSource, JsonObject)
io.vertx.rxjava3.jdbcclient.JDBCPool.pool(Vertx, DataSource, JsonObject)
io.vertx.jdbcclient.JDBCPool.pool(Vertx, DataSource, JsonObject)
io.vertx.reactivex.jdbcclient.JDBCPool.pool(Vertx, DataSource, JsonObject)
io.vertx.rxjava.jdbcclient.JDBCPool.pool(Vertx, JsonObject)
io.vertx.rxjava3.jdbcclient.JDBCPool.pool(Vertx, JsonObject)
io.vertx.jdbcclient.JDBCPool.pool(Vertx, JsonObject) instead use JDBCPool.pool(Vertx, JDBCConnectOptions, PoolOptions)
io.vertx.reactivex.jdbcclient.JDBCPool.pool(Vertx, JsonObject)
io.vertx.core.json.jackson.DatabindCodec.prettyMapper() as of 4.5.2, use ObjectMapper.writerWithDefaultPrettyPrinter() instead
io.vertx.config.spi.ConfigProcessor.process(Vertx, JsonObject, Buffer, Handler<AsyncResult<JsonObject>>) implement ConfigProcessor.process(Vertx, JsonObject, Buffer) instead
io.vertx.rxjava3.core.streams.Pump.pump(Flowable<T>, WriteStream<T>)
io.vertx.reactivex.core.streams.Pump.pump(Flowable<T>, WriteStream<T>)
io.vertx.rxjava3.core.streams.Pump.pump(Flowable<T>, WriteStream<T>, int)
io.vertx.reactivex.core.streams.Pump.pump(Flowable<T>, WriteStream<T>, int)
io.vertx.rxjava.core.streams.Pump.pump(Observable<T>, WriteStream<T>)
io.vertx.rxjava.core.streams.Pump.pump(Observable<T>, WriteStream<T>, int)
io.vertx.rxjava.core.streams.Pump.pump(ReadStream<T>, WriteStream<T>)
io.vertx.reactivex.core.streams.Pump.pump(ReadStream<T>, WriteStream<T>)
io.vertx.rxjava.core.streams.Pump.pump(ReadStream<T>, WriteStream<T>, int)
io.vertx.reactivex.core.streams.Pump.pump(ReadStream<T>, WriteStream<T>, int)
io.vertx.rxjava.core.http.HttpServerResponse.push(HttpMethod, String, String)
io.vertx.rxjava3.core.http.HttpServerResponse.push(HttpMethod, String, String)
io.vertx.core.http.HttpServerResponse.push(HttpMethod, String, String) instead use HttpServerResponse.push(HttpMethod, HostAndPort, String)
io.vertx.reactivex.core.http.HttpServerResponse.push(HttpMethod, String, String)
io.vertx.rxjava.core.http.HttpServerResponse.push(HttpMethod, String, String, Handler<AsyncResult<HttpServerResponse>>)
io.vertx.core.http.HttpServerResponse.push(HttpMethod, String, String, Handler<AsyncResult<HttpServerResponse>>) instead use HttpServerResponse.push(HttpMethod, HostAndPort, String, Handler)
io.vertx.reactivex.core.http.HttpServerResponse.push(HttpMethod, String, String, Handler<AsyncResult<HttpServerResponse>>)
io.vertx.rxjava.core.http.HttpServerResponse.push(HttpMethod, String, String, MultiMap)
io.vertx.rxjava3.core.http.HttpServerResponse.push(HttpMethod, String, String, MultiMap)
io.vertx.core.http.HttpServerResponse.push(HttpMethod, String, String, MultiMap) instead use HttpServerResponse.push(HttpMethod, HostAndPort, String, MultiMap)
io.vertx.reactivex.core.http.HttpServerResponse.push(HttpMethod, String, String, MultiMap)
io.vertx.rxjava.core.http.HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler<AsyncResult<HttpServerResponse>>)
io.vertx.core.http.HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler<AsyncResult<HttpServerResponse>>)
io.vertx.reactivex.core.http.HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler<AsyncResult<HttpServerResponse>>)
io.vertx.rxjava.ext.auth.HashingStrategy.put(String, HashingAlgorithm)
io.vertx.rxjava3.ext.auth.HashingStrategy.put(String, HashingAlgorithm)
io.vertx.reactivex.ext.auth.HashingStrategy.put(String, HashingAlgorithm)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSHandler.queryContext(Function<ApolloWSMessage, Object>)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSHandler.queryContext(Function<ApolloWSMessage, Object>)
io.vertx.ext.web.handler.graphql.ApolloWSHandler.queryContext(Function<ApolloWSMessage, Object>) as of 4.2, use ApolloWSHandler.beforeExecute(Handler) instead
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSHandler.queryContext(Function<ApolloWSMessage, Object>)
io.vertx.rxjava.ext.web.handler.graphql.GraphQLHandler.queryContext(Function<RoutingContext, Object>)
io.vertx.rxjava3.ext.web.handler.graphql.GraphQLHandler.queryContext(Function<RoutingContext, Object>)
io.vertx.ext.web.handler.graphql.GraphQLHandler.queryContext(Function<RoutingContext, Object>) as of 4.2, use GraphQLHandler.beforeExecute(Handler) instead
io.vertx.reactivex.ext.web.handler.graphql.GraphQLHandler.queryContext(Function<RoutingContext, Object>)
io.vertx.rxjava.ext.web.api.RequestParameters.queryParameter(String)
io.vertx.rxjava3.ext.web.api.RequestParameters.queryParameter(String)
io.vertx.reactivex.ext.web.api.RequestParameters.queryParameter(String)
io.vertx.rxjava.ext.web.api.RequestParameters.queryParametersNames()
io.vertx.rxjava3.ext.web.api.RequestParameters.queryParametersNames()
io.vertx.reactivex.ext.web.api.RequestParameters.queryParametersNames()
io.vertx.core.http.HttpClient.redirectHandler()
io.vertx.rxjava.core.http.HttpClient.redirectHandler(Function<HttpClientResponse, Future<RequestOptions>>)
io.vertx.core.http.HttpClient.redirectHandler(Function<HttpClientResponse, Future<RequestOptions>>) instead use HttpClientBuilder.withRedirectHandler(Function)
io.vertx.reactivex.core.http.HttpClient.redirectHandler(Function<HttpClientResponse, Future<RequestOptions>>)
io.vertx.rxjava3.core.http.HttpClient.redirectHandler(Function<HttpClientResponse, Single<RequestOptions>>)
io.vertx.reactivex.core.http.HttpClient.redirectHandler(Function<HttpClientResponse, Single<RequestOptions>>)
io.vertx.rxjava.json.schema.SchemaRouter.registeredSchemas()
io.vertx.rxjava3.json.schema.SchemaRouter.registeredSchemas()
io.vertx.reactivex.json.schema.SchemaRouter.registeredSchemas()
io.vertx.rxjava.core.http.ServerWebSocket.reject()
io.vertx.rxjava3.core.http.ServerWebSocket.reject()
io.vertx.core.http.ServerWebSocket.reject() instead use ServerWebSocketHandshake.reject()
io.vertx.reactivex.core.http.ServerWebSocket.reject()
io.vertx.rxjava.core.http.ServerWebSocket.reject(int)
io.vertx.rxjava3.core.http.ServerWebSocket.reject(int)
io.vertx.core.http.ServerWebSocket.reject(int) instead use ServerWebSocketHandshake.reject(int)
io.vertx.reactivex.core.http.ServerWebSocket.reject(int)
io.vertx.rxjava.ext.web.RoutingContext.removeCookie(String)
io.vertx.rxjava3.ext.web.RoutingContext.removeCookie(String)
io.vertx.ext.web.RoutingContext.removeCookie(String) Use HttpServerResponse.removeCookie(String) Expire a cookie, notifying a User Agent to remove it from its cookie jar.
io.vertx.reactivex.ext.web.RoutingContext.removeCookie(String)
io.vertx.rxjava.ext.web.RoutingContext.removeCookie(String, boolean)
io.vertx.rxjava3.ext.web.RoutingContext.removeCookie(String, boolean)
io.vertx.ext.web.RoutingContext.removeCookie(String, boolean) Use HttpServerResponse.removeCookie(String, boolean) Remove a cookie from the cookie set. If invalidate is true then it will expire a cookie, notifying a User Agent to remove it from its cookie jar.
io.vertx.reactivex.ext.web.RoutingContext.removeCookie(String, boolean)
io.vertx.core.logging.LoggerFactory.removeLogger(String) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.grpc.client.GrpcClient.request(SocketAddress, MethodDescriptor<Req, Resp>) instead use GrpcClient.request(SocketAddress, MethodDescriptor)
io.vertx.rxjava.grpc.client.GrpcClient.request(SocketAddress, MethodDescriptor<Req, Resp>)
io.vertx.rxjava3.grpc.client.GrpcClient.request(SocketAddress, MethodDescriptor<Req, Resp>)
io.vertx.reactivex.grpc.client.GrpcClient.request(SocketAddress, MethodDescriptor<Req, Resp>)
io.vertx.rxjava.core.http.HttpServer.requestStream()
io.vertx.rxjava3.core.http.HttpServer.requestStream()
io.vertx.core.http.HttpServer.requestStream() instead use HttpServer.requestHandler(Handler)
io.vertx.reactivex.core.http.HttpServer.requestStream()
io.vertx.rxjava.ext.web.client.predicate.ErrorConverter.requiresBody()
io.vertx.rxjava3.ext.web.client.predicate.ErrorConverter.requiresBody()
io.vertx.reactivex.ext.web.client.predicate.ErrorConverter.requiresBody()
io.vertx.json.schema.JsonSchema.resolve() will be removed in Vert.x 5
io.vertx.json.schema.SchemaRepository.resolve(JsonSchema) will be removed in Vert.x 5
io.vertx.json.schema.SchemaRepository.resolve(String) will be removed in Vert.x 5
io.vertx.rxjava.json.schema.SchemaRouter.resolveCachedSchema(JsonPointer, JsonPointer, SchemaParser)
io.vertx.rxjava3.json.schema.SchemaRouter.resolveCachedSchema(JsonPointer, JsonPointer, SchemaParser)
io.vertx.reactivex.json.schema.SchemaRouter.resolveCachedSchema(JsonPointer, JsonPointer, SchemaParser)
io.vertx.rxjava.json.schema.SchemaRouter.resolveRef(JsonPointer, JsonPointer, SchemaParser)
io.vertx.rxjava3.json.schema.SchemaRouter.resolveRef(JsonPointer, JsonPointer, SchemaParser)
io.vertx.reactivex.json.schema.SchemaRouter.resolveRef(JsonPointer, JsonPointer, SchemaParser)
io.vertx.rxjava.json.schema.SchemaRouter.resolveRef(JsonPointer, JsonPointer, SchemaParser, Handler<AsyncResult<Schema>>)
io.vertx.reactivex.json.schema.SchemaRouter.resolveRef(JsonPointer, JsonPointer, SchemaParser, Handler<AsyncResult<Schema>>)
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicateResult.response()
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicateResult.response()
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicateResult.response()
io.vertx.rxjava.core.datagram.DatagramSocket.resume()
io.vertx.rxjava.core.TimeoutStream.resume()
io.vertx.rxjava3.core.datagram.DatagramSocket.resume()
io.vertx.rxjava3.core.TimeoutStream.resume()
io.vertx.core.datagram.DatagramSocket.resume() no replacement for back-pressure, instead ignore the packet or buffer it somewhere
io.vertx.reactivex.core.datagram.DatagramSocket.resume()
io.vertx.reactivex.core.TimeoutStream.resume()
io.vertx.rxjava.circuitbreaker.CircuitBreaker.retryPolicy(Function<Integer, Long>)
io.vertx.rxjava3.circuitbreaker.CircuitBreaker.retryPolicy(Function<Integer, Long>)
io.vertx.circuitbreaker.CircuitBreaker.retryPolicy(Function<Integer, Long>) use CircuitBreaker.retryPolicy(RetryPolicy) instead
io.vertx.reactivex.circuitbreaker.CircuitBreaker.retryPolicy(Function<Integer, Long>)
io.vertx.redis.client.RedisAPI.rpoplpush(String, String) since: 6.2.0, replaced by: LMOVE with the RIGHT and LEFT arguments
io.vertx.rxjava.ext.auth.authentication.AuthenticationProvider.rxAuthenticate(JsonObject)
io.vertx.rxjava3.ext.auth.authentication.AuthenticationProvider.rxAuthenticate(JsonObject)
io.vertx.reactivex.ext.auth.authentication.AuthenticationProvider.rxAuthenticate(JsonObject)
io.vertx.rxjava.grpc.client.GrpcClient.rxCall(SocketAddress, MethodDescriptor<Req, Resp>, Handler<GrpcClientRequest<Req, Resp>>, Function<GrpcClientResponse<Req, Resp>, Future<T>>)
io.vertx.reactivex.grpc.client.GrpcClient.rxCall(SocketAddress, MethodDescriptor<Req, Resp>, Handler<GrpcClientRequest<Req, Resp>>, Function<GrpcClientResponse<Req, Resp>, Future<T>>)
io.vertx.rxjava3.grpc.client.GrpcClient.rxCall(SocketAddress, MethodDescriptor<Req, Resp>, Handler<GrpcClientRequest<Req, Resp>>, Function<GrpcClientResponse<Req, Resp>, Single<T>>)
io.vertx.reactivex.grpc.client.GrpcClient.rxCall(SocketAddress, MethodDescriptor<Req, Resp>, Handler<GrpcClientRequest<Req, Resp>>, Function<GrpcClientResponse<Req, Resp>, Single<T>>)
io.vertx.rxjava.ext.consul.ConsulClient.rxCloneAclToken(String)
io.vertx.rxjava3.ext.consul.ConsulClient.rxCloneAclToken(String)
io.vertx.reactivex.ext.consul.ConsulClient.rxCloneAclToken(String)
io.vertx.rxjava.grpc.server.GrpcServerRequest.rxCollecting(Collector<Req, A, R>)
io.vertx.rxjava3.grpc.server.GrpcServerRequest.rxCollecting(Collector<Req, A, R>)
io.vertx.reactivex.grpc.server.GrpcServerRequest.rxCollecting(Collector<Req, A, R>)
io.vertx.rxjava.grpc.client.GrpcClientResponse.rxCollecting(Collector<Resp, A, R>)
io.vertx.rxjava3.grpc.client.GrpcClientResponse.rxCollecting(Collector<Resp, A, R>)
io.vertx.reactivex.grpc.client.GrpcClientResponse.rxCollecting(Collector<Resp, A, R>)
io.vertx.rxjava.grpc.common.GrpcReadStream.rxCollecting(Collector<T, A, R>)
io.vertx.rxjava3.grpc.common.GrpcReadStream.rxCollecting(Collector<T, A, R>)
io.vertx.reactivex.grpc.common.GrpcReadStream.rxCollecting(Collector<T, A, R>)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.rxCreate(Vertx, String)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.rxCreate(Vertx, String)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.rxCreate(Vertx, String)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.rxCreate(Vertx, String, List<JsonObject>)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.rxCreate(Vertx, String, List<JsonObject>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.rxCreate(Vertx, String, List<JsonObject>)
io.vertx.rxjava.ext.consul.ConsulClient.rxCreateAclToken(AclToken)
io.vertx.rxjava3.ext.consul.ConsulClient.rxCreateAclToken(AclToken)
io.vertx.reactivex.ext.consul.ConsulClient.rxCreateAclToken(AclToken)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.rxCreateHashedUser(String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.rxCreateHashedUser(String, String)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.rxCreateRolePermission(String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.rxCreateRolePermission(String, String)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.rxCreateUser(String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.rxCreateUser(String, String)
io.vertx.rxjava.ext.auth.jdbc.JDBCUserUtil.rxCreateUserRole(String, String)
io.vertx.reactivex.ext.auth.jdbc.JDBCUserUtil.rxCreateUserRole(String, String)
io.vertx.rxjava.core.file.FileSystem.rxDeleteRecursive(String, boolean)
io.vertx.rxjava3.core.file.FileSystem.rxDeleteRecursive(String, boolean)
io.vertx.reactivex.core.file.FileSystem.rxDeleteRecursive(String, boolean)
io.vertx.rxjava.ext.consul.ConsulClient.rxDestroyAclToken(String)
io.vertx.rxjava3.ext.consul.ConsulClient.rxDestroyAclToken(String)
io.vertx.reactivex.ext.consul.ConsulClient.rxDestroyAclToken(String)
io.vertx.rxjava.core.Context.rxExecuteBlocking(Handler<Promise<T>>)
io.vertx.rxjava.core.Vertx.rxExecuteBlocking(Handler<Promise<T>>)
io.vertx.rxjava.core.WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>>)
io.vertx.rxjava3.core.Context.rxExecuteBlocking(Handler<Promise<T>>)
io.vertx.rxjava3.core.Vertx.rxExecuteBlocking(Handler<Promise<T>>)
io.vertx.rxjava3.core.WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>>)
io.vertx.reactivex.core.Context.rxExecuteBlocking(Handler<Promise<T>>)
io.vertx.reactivex.core.Vertx.rxExecuteBlocking(Handler<Promise<T>>)
io.vertx.reactivex.core.WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>>)
io.vertx.rxjava.core.Context.rxExecuteBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava.core.Vertx.rxExecuteBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava.core.WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava3.core.Context.rxExecuteBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava3.core.Vertx.rxExecuteBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava3.core.WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>>, boolean)
io.vertx.reactivex.core.Context.rxExecuteBlocking(Handler<Promise<T>>, boolean)
io.vertx.reactivex.core.Vertx.rxExecuteBlocking(Handler<Promise<T>>, boolean)
io.vertx.reactivex.core.WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>>, boolean)
io.vertx.rxjava.ext.consul.ConsulClient.rxInfoAclToken(String)
io.vertx.rxjava3.ext.consul.ConsulClient.rxInfoAclToken(String)
io.vertx.reactivex.ext.consul.ConsulClient.rxInfoAclToken(String)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.rxInsertUser(String, String, List<String>, List<String>)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.rxInsertUser(String, String, List<String>, List<String>)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.rxInsertUser(String, String, List<String>, List<String>)
io.vertx.rxjava.ext.auth.User.rxIsAuthorized(Authorization)
io.vertx.rxjava3.ext.auth.User.rxIsAuthorized(Authorization)
io.vertx.reactivex.ext.auth.User.rxIsAuthorized(Authorization)
io.vertx.rxjava.ext.auth.User.rxIsAuthorized(String)
io.vertx.rxjava3.ext.auth.User.rxIsAuthorized(String)
io.vertx.reactivex.ext.auth.User.rxIsAuthorized(String)
io.vertx.rxjava.ext.consul.ConsulClient.rxListAclTokens()
io.vertx.rxjava3.ext.consul.ConsulClient.rxListAclTokens()
io.vertx.reactivex.ext.consul.ConsulClient.rxListAclTokens()
io.vertx.rxjava.core.TimeoutStream.rxPipeTo(WriteStream<Long>)
io.vertx.rxjava3.core.TimeoutStream.rxPipeTo(WriteStream<Long>)
io.vertx.reactivex.core.TimeoutStream.rxPipeTo(WriteStream<Long>)
io.vertx.rxjava.core.http.HttpServerResponse.rxPush(HttpMethod, String, String)
io.vertx.rxjava3.core.http.HttpServerResponse.rxPush(HttpMethod, String, String)
io.vertx.reactivex.core.http.HttpServerResponse.rxPush(HttpMethod, String, String)
io.vertx.rxjava.core.http.HttpServerResponse.rxPush(HttpMethod, String, String, MultiMap)
io.vertx.rxjava3.core.http.HttpServerResponse.rxPush(HttpMethod, String, String, MultiMap)
io.vertx.reactivex.core.http.HttpServerResponse.rxPush(HttpMethod, String, String, MultiMap)
io.vertx.rxjava.grpc.client.GrpcClient.rxRequest(SocketAddress, MethodDescriptor<Req, Resp>)
io.vertx.rxjava3.grpc.client.GrpcClient.rxRequest(SocketAddress, MethodDescriptor<Req, Resp>)
io.vertx.reactivex.grpc.client.GrpcClient.rxRequest(SocketAddress, MethodDescriptor<Req, Resp>)
io.vertx.rxjava.json.schema.SchemaRouter.rxResolveRef(JsonPointer, JsonPointer, SchemaParser)
io.vertx.rxjava3.json.schema.SchemaRouter.rxResolveRef(JsonPointer, JsonPointer, SchemaParser)
io.vertx.reactivex.json.schema.SchemaRouter.rxResolveRef(JsonPointer, JsonPointer, SchemaParser)
io.vertx.rxjava.core.http.ServerWebSocket.rxSetHandshake(Future<Integer>)
io.vertx.reactivex.core.http.ServerWebSocket.rxSetHandshake(Future<Integer>)
io.vertx.rxjava3.core.http.ServerWebSocket.rxSetHandshake(Single<Integer>)
io.vertx.reactivex.core.http.ServerWebSocket.rxSetHandshake(Single<Integer>)
io.vertx.rxjava.core.http.HttpConnection.rxShutdown(long)
io.vertx.rxjava3.core.http.HttpConnection.rxShutdown(long)
io.vertx.reactivex.core.http.HttpConnection.rxShutdown(long)
io.vertx.rxjava.ext.consul.ConsulClient.rxUpdateAclToken(AclToken)
io.vertx.rxjava3.ext.consul.ConsulClient.rxUpdateAclToken(AclToken)
io.vertx.reactivex.ext.consul.ConsulClient.rxUpdateAclToken(AclToken)
io.vertx.rxjava.core.http.HttpClient.rxWebSocket(int, String, String)
io.vertx.rxjava3.core.http.HttpClient.rxWebSocket(int, String, String)
io.vertx.reactivex.core.http.HttpClient.rxWebSocket(int, String, String)
io.vertx.rxjava.core.http.HttpClient.rxWebSocket(String)
io.vertx.rxjava3.core.http.HttpClient.rxWebSocket(String)
io.vertx.reactivex.core.http.HttpClient.rxWebSocket(String)
io.vertx.rxjava.core.http.HttpClient.rxWebSocket(String, String)
io.vertx.rxjava3.core.http.HttpClient.rxWebSocket(String, String)
io.vertx.reactivex.core.http.HttpClient.rxWebSocket(String, String)
io.vertx.rxjava.core.http.HttpClient.rxWebSocket(WebSocketConnectOptions)
io.vertx.rxjava3.core.http.HttpClient.rxWebSocket(WebSocketConnectOptions)
io.vertx.reactivex.core.http.HttpClient.rxWebSocket(WebSocketConnectOptions)
io.vertx.rxjava.core.http.HttpClient.rxWebSocketAbs(String, MultiMap, WebsocketVersion, List<String>)
io.vertx.rxjava3.core.http.HttpClient.rxWebSocketAbs(String, MultiMap, WebsocketVersion, List<String>)
io.vertx.reactivex.core.http.HttpClient.rxWebSocketAbs(String, MultiMap, WebsocketVersion, List<String>)
io.vertx.json.schema.ValidationException.scope() use ValidationException.schema() and then Schema.getScope() instead
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSMessage.serverWebSocket()
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSMessage.serverWebSocket()
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSMessage.serverWebSocket()
io.vertx.rxjava.ext.auth.mongo.HashStrategy.setAlgorithm(HashAlgorithm)
io.vertx.rxjava3.ext.auth.mongo.HashStrategy.setAlgorithm(HashAlgorithm)
io.vertx.reactivex.ext.auth.mongo.HashStrategy.setAlgorithm(HashAlgorithm)
io.vertx.rxjava.ext.web.handler.StaticHandler.setAllowRootFileSystemAccess(boolean)
io.vertx.rxjava3.ext.web.handler.StaticHandler.setAllowRootFileSystemAccess(boolean)
io.vertx.ext.web.handler.StaticHandler.setAllowRootFileSystemAccess(boolean)
io.vertx.reactivex.ext.web.handler.StaticHandler.setAllowRootFileSystemAccess(boolean)
io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.setAuthenticationQuery(String)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuth.setAuthenticationQuery(String)
io.vertx.rxjava.ext.auth.User.setAuthProvider(AuthProvider)
io.vertx.rxjava3.ext.auth.User.setAuthProvider(AuthProvider)
io.vertx.ext.auth.User.setAuthProvider(AuthProvider)
io.vertx.reactivex.ext.auth.User.setAuthProvider(AuthProvider)
io.vertx.rxjava.ext.web.RoutingContext.setBody(Buffer)
io.vertx.rxjava3.ext.web.RoutingContext.setBody(Buffer)
io.vertx.ext.web.RoutingContext.setBody(Buffer) This method is internal. Users that really need to use it should refer to RoutingContextInternal.setBody(Buffer) Set the body. Used by the BodyHandler. You will not normally call this method.
io.vertx.reactivex.ext.web.RoutingContext.setBody(Buffer)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setBodyHandler(BodyHandler)
io.vertx.rxjava.ext.web.api.contract.RouterFactory.setBodyHandler(BodyHandler)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setBodyHandler(BodyHandler)
io.vertx.rxjava3.ext.web.api.contract.RouterFactory.setBodyHandler(BodyHandler)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setBodyHandler(BodyHandler)
io.vertx.reactivex.ext.web.api.contract.RouterFactory.setBodyHandler(BodyHandler)
io.vertx.ext.auth.PubSecKeyOptions.setCertificate(boolean)
io.vertx.ext.auth.oauth2.OAuth2Options.setClientID(String) see OAuth2Options.setClientId(String)
io.vertx.core.VertxOptions.setClusterManager(ClusterManager) instead use VertxBuilder.withClusterManager(ClusterManager)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.setCollectionName(String)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.setCollectionName(String)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.setCollectionName(String)
io.vertx.pgclient.data.Money.setDecimalPart(int) as of 4.5, create another instance instead
io.vertx.redis.client.RedisOptions.setEndpoint(String) see RedisOptions.setConnectionString(String connectionString) for a better naming
io.vertx.rxjava.ext.auth.mongo.HashStrategy.setExternalSalt(String)
io.vertx.rxjava3.ext.auth.mongo.HashStrategy.setExternalSalt(String)
io.vertx.reactivex.ext.auth.mongo.HashStrategy.setExternalSalt(String)
io.vertx.core.DeploymentOptions.setExtraClasspath(List<String>)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setExtraOperationContextPayloadMapper(Function<RoutingContext, JsonObject>)
io.vertx.rxjava.ext.web.api.contract.RouterFactory.setExtraOperationContextPayloadMapper(Function<RoutingContext, JsonObject>)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setExtraOperationContextPayloadMapper(Function<RoutingContext, JsonObject>)
io.vertx.rxjava3.ext.web.api.contract.RouterFactory.setExtraOperationContextPayloadMapper(Function<RoutingContext, JsonObject>)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setExtraOperationContextPayloadMapper(Function<RoutingContext, JsonObject>)
io.vertx.reactivex.ext.web.api.contract.RouterFactory.setExtraOperationContextPayloadMapper(Function<RoutingContext, JsonObject>)
io.vertx.core.metrics.MetricsOptions.setFactory(VertxMetricsFactory) instead use VertxBuilder.withMetrics(VertxMetricsFactory)
io.vertx.core.tracing.TracingOptions.setFactory(VertxTracerFactory) instead use VertxBuilder.withTracer(VertxTracerFactory)
io.vertx.ext.auth.oauth2.OAuth2Options.setFlow(OAuth2FlowType) see Oauth2Credentials.setFlow(OAuth2FlowType)
io.vertx.rxjava.core.http.ServerWebSocket.setHandshake(Future<Integer>)
io.vertx.core.http.ServerWebSocket.setHandshake(Future<Integer>) instead use ServerWebSocketHandshake
io.vertx.reactivex.core.http.ServerWebSocket.setHandshake(Future<Integer>)
io.vertx.rxjava.core.http.ServerWebSocket.setHandshake(Future<Integer>, Handler<AsyncResult<Integer>>)
io.vertx.core.http.ServerWebSocket.setHandshake(Future<Integer>, Handler<AsyncResult<Integer>>) instead use ServerWebSocketHandshake
io.vertx.reactivex.core.http.ServerWebSocket.setHandshake(Future<Integer>, Handler<AsyncResult<Integer>>)
io.vertx.rxjava3.core.http.ServerWebSocket.setHandshake(Single<Integer>)
io.vertx.reactivex.core.http.ServerWebSocket.setHandshake(Single<Integer>)
io.vertx.reactivex.core.http.ServerWebSocket.setHandshake(Single<Integer>, Handler<AsyncResult<Integer>>)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.setHashAlgorithm(HashAlgorithm)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.setHashAlgorithm(HashAlgorithm)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.setHashAlgorithm(HashAlgorithm)
io.vertx.redis.client.RedisClusterConnectOptions.setHashSlotCacheTTL(long) use RedisClusterConnectOptions.setTopologyCacheTTL(long)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.setHashStrategy(HashStrategy)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.setHashStrategy(HashStrategy)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.setHashStrategy(HashStrategy)
io.vertx.rxjava.core.http.HttpClientRequest.setHost(String)
io.vertx.rxjava3.core.http.HttpClientRequest.setHost(String)
io.vertx.core.http.HttpClientRequest.setHost(String) instead use HttpClientRequest.authority(HostAndPort)
io.vertx.reactivex.core.http.HttpClientRequest.setHost(String)
io.vertx.ext.auth.webauthn.RelyingParty.setIcon(String)
io.vertx.mqtt.MqttClientOptions.setIdleTimeout(int)
io.vertx.pgclient.data.Money.setIntegerPart(long) as of 4.5, create another instance instead
io.vertx.core.DeploymentOptions.setIsolatedClasses(List<String>)
io.vertx.core.DeploymentOptions.setIsolationGroup(String)
io.vertx.core.eventbus.EventBusOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.net.NetClientOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.net.TCPSSLOptions.setJdkSslEngineOptions(JdkSSLEngineOptions) instead use TCPSSLOptions.setSslEngineOptions(SSLEngineOptions)
io.vertx.core.net.NetServerOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.net.ClientOptionsBase.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.http.HttpClientOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.http.WebSocketClientOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.http.HttpServerOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.spi.cluster.ignite.IgniteSslOptions.setKeyAlgorithm(String) Use vert.x ssl certificate options instead. It will be removed in vert.x 4.1
io.vertx.ext.mail.MailConfig.setKeyStore(String) use TCPSSLOptions.getTrustStoreOptions()
io.vertx.spi.cluster.ignite.IgniteSslOptions.setKeyStoreFilePath(String) Use vert.x jksKeyCertOptions.path instead. It will be removed in vert.x 4.1
io.vertx.core.eventbus.EventBusOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.net.NetClientOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.net.TCPSSLOptions.setKeyStoreOptions(JksOptions) instead use TCPSSLOptions.setKeyCertOptions(KeyCertOptions)
io.vertx.core.net.NetServerOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.net.ClientOptionsBase.setKeyStoreOptions(JksOptions)
io.vertx.core.http.HttpClientOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.http.WebSocketClientOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.http.HttpServerOptions.setKeyStoreOptions(JksOptions)
io.vertx.ext.mail.MailConfig.setKeyStorePassword(String) use TCPSSLOptions.getTrustStoreOptions()
io.vertx.spi.cluster.ignite.IgniteSslOptions.setKeyStorePassword(String) Use vert.x jksKeyCertOptions.password instead. It will be removed in vert.x 4.1
io.vertx.spi.cluster.ignite.IgniteSslOptions.setKeyStoreType(String) Use vert.x ssl certificate options instead. It will be removed in vert.x 4.1
io.vertx.rxjava.core.eventbus.MessageConsumer.setMaxBufferedMessages(int)
io.vertx.rxjava3.core.eventbus.MessageConsumer.setMaxBufferedMessages(int)
io.vertx.core.eventbus.MessageConsumer.setMaxBufferedMessages(int) for removal, instead use MessageConsumerOptions.setMaxBufferedMessages(int)
io.vertx.reactivex.core.eventbus.MessageConsumer.setMaxBufferedMessages(int)
io.vertx.ext.dropwizard.DropwizardMetricsOptions.setMetricRegistry(MetricRegistry) instead use DropwizardVertxMetricsFactory(MetricRegistry
io.vertx.micrometer.MicrometerMetricsOptions.setMicrometerRegistry(MeterRegistry) instead use MicrometerMetricsFactory(MeterRegistry)
io.vertx.rxjava.ext.web.templ.thymeleaf.ThymeleafTemplateEngine.setMode(TemplateMode)
io.vertx.rxjava3.ext.web.templ.thymeleaf.ThymeleafTemplateEngine.setMode(TemplateMode)
io.vertx.ext.web.templ.thymeleaf.ThymeleafTemplateEngine.setMode(TemplateMode) see TemplateEngine.unwrap() Set the mode for the engine
io.vertx.reactivex.ext.web.templ.thymeleaf.ThymeleafTemplateEngine.setMode(TemplateMode)
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.rxjava.ext.web.api.RequestParameter.setName(String)
io.vertx.rxjava3.ext.web.api.RequestParameter.setName(String)
io.vertx.reactivex.ext.web.api.RequestParameter.setName(String)
io.vertx.ext.consul.Check.setNodeName(String)
io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.setNonces(JsonArray)
io.vertx.rxjava.ext.auth.jdbc.JDBCHashStrategy.setNonces(JsonArray)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuth.setNonces(JsonArray)
io.vertx.reactivex.ext.auth.jdbc.JDBCHashStrategy.setNonces(JsonArray)
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.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext>)
io.vertx.rxjava3.ext.web.api.contract.RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext>)
io.vertx.ext.web.api.contract.RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext>) You must use Router.errorHandler(int, Handler) with 501 error
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.micrometer.VertxInfluxDbOptions.setNumThreads(int) no longer used by Micrometer
io.vertx.core.eventbus.EventBusOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.net.NetClientOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.net.TCPSSLOptions.setOpenSslEngineOptions(OpenSSLEngineOptions) instead use TCPSSLOptions.setSslEngineOptions(SSLEngineOptions)
io.vertx.core.net.NetServerOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.net.ClientOptionsBase.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.http.HttpClientOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.http.WebSocketClientOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.http.HttpServerOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setOptions(RouterFactoryOptions)
io.vertx.rxjava.ext.web.api.contract.RouterFactory.setOptions(RouterFactoryOptions)
io.vertx.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setOptions(RouterFactoryOptions)
io.vertx.rxjava3.ext.web.api.contract.RouterFactory.setOptions(RouterFactoryOptions)
io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setOptions(RouterFactoryOptions)
io.vertx.reactivex.ext.web.api.contract.RouterFactory.setOptions(RouterFactoryOptions)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.setPasswordCredentialField(String)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.setPasswordCredentialField(String)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.setPasswordCredentialField(String)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.setPasswordField(String)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.setPasswordField(String)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.setPasswordField(String)
io.vertx.core.eventbus.EventBusOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.net.NetClientOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.net.TCPSSLOptions.setPemKeyCertOptions(PemKeyCertOptions) instead use TCPSSLOptions.setKeyCertOptions(KeyCertOptions)
io.vertx.core.net.NetServerOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.net.ClientOptionsBase.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.http.HttpClientOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.http.WebSocketClientOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.http.HttpServerOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.eventbus.EventBusOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.net.NetClientOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.net.TCPSSLOptions.setPemTrustOptions(PemTrustOptions) instead use TCPSSLOptions.setTrustOptions(TrustOptions)
io.vertx.core.net.NetServerOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.net.ClientOptionsBase.setPemTrustOptions(PemTrustOptions)
io.vertx.core.http.HttpClientOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.http.WebSocketClientOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.http.HttpServerOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.setPermissionField(String)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.setPermissionField(String)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.setPermissionField(String)
io.vertx.ext.auth.JWTOptions.setPermissions(List<String>) See JWTAuthorization for a correct way to handle permissions. The permissions of this token.
io.vertx.ext.auth.jwt.JWTAuthOptions.setPermissionsClaimKey(String) AuthN and AuthZ have been split in vert.x 4.0.0 in order to specify where authorization will happen see JWTAuthorization.
io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.setPermissionsQuery(String)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuth.setPermissionsQuery(String)
io.vertx.core.eventbus.EventBusOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.net.NetClientOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.net.TCPSSLOptions.setPfxKeyCertOptions(PfxOptions) instead use TCPSSLOptions.setKeyCertOptions(KeyCertOptions)
io.vertx.core.net.NetServerOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.net.ClientOptionsBase.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.http.HttpClientOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.http.WebSocketClientOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.http.HttpServerOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.eventbus.EventBusOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.net.NetClientOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.net.TCPSSLOptions.setPfxTrustOptions(PfxOptions) instead use TCPSSLOptions.setTrustOptions(TrustOptions)
io.vertx.core.net.NetServerOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.net.ClientOptionsBase.setPfxTrustOptions(PfxOptions)
io.vertx.core.http.HttpClientOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.http.WebSocketClientOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.http.HttpServerOptions.setPfxTrustOptions(PfxOptions)
io.vertx.db2client.DB2ConnectOptions.setPipeliningLimit(int) UNSTABLE FEATURE: Current default value is 1, anything higher than 1 will result in errors currently.
io.vertx.rxjava.core.http.HttpClientRequest.setPort(int)
io.vertx.rxjava3.core.http.HttpClientRequest.setPort(int)
io.vertx.core.http.HttpClientRequest.setPort(int) instead use HttpClientRequest.authority(HostAndPort)
io.vertx.reactivex.core.http.HttpClientRequest.setPort(int)
io.vertx.ext.auth.PubSecKeyOptions.setPublicKey(String) This setter ignored the PEM prefix and suffix which would assume the key to be RSA. Use PubSecKeyOptions.setBuffer(String) with the full content of your OpenSSL pem file. A PEM file must contain at least 3 lines: -----BEGIN PUBLIC KEY---- ... -----END PUBLIC KEY---
io.vertx.rxjava.ext.sql.SQLConnection.setQueryTimeout(int)
io.vertx.ext.sql.SQLConnection.setQueryTimeout(int) instead use SQLConnection.setOptions(SQLOptions) with SQLOptions.setQueryTimeout(int)
io.vertx.reactivex.ext.sql.SQLConnection.setQueryTimeout(int)
io.vertx.spi.cluster.ignite.IgniteCacheOptions.setRebalanceDelay(long) Use baseline topology feature instead. Please, be aware this API will be removed in the next releases.
io.vertx.micrometer.MicrometerMetricsOptions.setRequestsTagsProvider(Function<HttpRequest, Iterable<Tag>>) use setServerRequestTagsProvider instead
io.vertx.ext.web.templ.handlebars.HandlebarsTemplateEngine.setResolvers(ValueResolver...) see TemplateEngine.unwrap() Set the array of handlebars context value resolvers.
io.vertx.rxjava.ext.auth.mongo.MongoAuth.setRoleField(String)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.setRoleField(String)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.setRoleField(String)
io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.setRolePrefix(String)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuth.setRolePrefix(String)
io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.setRolesQuery(String)
io.vertx.reactivex.ext.auth.jdbc.JDBCAuth.setRolesQuery(String)
io.vertx.ext.auth.oauth2.OAuth2Options.setRotateJWKs(boolean) use OAuth2Options.setJwkMaxAgeInSeconds(long) instead
io.vertx.rxjava.ext.auth.mongo.MongoAuth.setSaltField(String)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.setSaltField(String)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.setSaltField(String)
io.vertx.rxjava.ext.auth.mongo.HashStrategy.setSaltStyle(HashSaltStyle)
io.vertx.rxjava3.ext.auth.mongo.HashStrategy.setSaltStyle(HashSaltStyle)
io.vertx.reactivex.ext.auth.mongo.HashStrategy.setSaltStyle(HashSaltStyle)
io.vertx.ext.auth.PubSecKeyOptions.setSecretKey(String) This setter ignored the PEM prefix and suffix which would assume the key to be RSA. Use PubSecKeyOptions.setBuffer(String) with the full content of your OpenSSL pem file. A PEM file must contain at least 3 lines: -----BEGIN PRIVATE KEY---- ... -----END PRIVATE KEY---
io.vertx.rxjava.ext.web.RoutingContext.setSession(Session)
io.vertx.rxjava3.ext.web.RoutingContext.setSession(Session)
io.vertx.ext.web.RoutingContext.setSession(Session) This method is internal. Users that really need to use it should refer to RoutingContextInternal.setSession(Session) Set the session. Used by the SessionHandler. You will not normally call this method.
io.vertx.reactivex.ext.web.RoutingContext.setSession(Session)
io.vertx.ext.auth.PubSecKeyOptions.setSymmetric(boolean)
io.vertx.rxjava.core.http.HttpClientRequest.setTimeout(long)
io.vertx.rxjava3.core.http.HttpClientRequest.setTimeout(long)
io.vertx.core.http.HttpClientRequest.setTimeout(long) instead use HttpClientRequest.idleTimeout(long)
io.vertx.reactivex.core.http.HttpClientRequest.setTimeout(long)
io.vertx.spi.cluster.ignite.IgniteSslOptions.setTrustStoreFilePath(String) Use vert.x jksTrustOptions.path instead. It will be removed in vert.x 4.1
io.vertx.core.eventbus.EventBusOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.net.NetClientOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.net.TCPSSLOptions.setTrustStoreOptions(JksOptions) instead use TCPSSLOptions.setTrustOptions(TrustOptions)
io.vertx.core.net.NetServerOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.net.ClientOptionsBase.setTrustStoreOptions(JksOptions)
io.vertx.core.http.HttpClientOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.http.WebSocketClientOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.http.HttpServerOptions.setTrustStoreOptions(JksOptions)
io.vertx.spi.cluster.ignite.IgniteSslOptions.setTrustStorePassword(String) Use vert.x jksTrustOptions.password instead. It will be removed in vert.x 4.1
io.vertx.spi.cluster.ignite.IgniteSslOptions.setTrustStoreType(String) Use vert.x jksTrustOptions instead. It will be removed in vert.x 4.1
io.vertx.ext.web.client.WebClientOptions.setTryUseCompression(boolean)
io.vertx.ext.web.client.CachingWebClientOptions.setTryUseCompression(boolean)
io.vertx.tracing.zipkin.HttpSenderOptions.setTryUseCompression(boolean)
io.vertx.core.http.HttpClientOptions.setTryUseCompression(boolean) as of 4.5, use HttpClientOptions.setDecompressionSupported(boolean) instead
io.vertx.rxjava.ext.web.RoutingContext.setUser(User)
io.vertx.rxjava3.ext.web.RoutingContext.setUser(User)
io.vertx.ext.web.RoutingContext.setUser(User) this method should not be called, application authentication should rely on AuthenticationHandler implementations.
io.vertx.reactivex.ext.web.RoutingContext.setUser(User)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.setUsernameCredentialField(String)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.setUsernameCredentialField(String)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.setUsernameCredentialField(String)
io.vertx.rxjava.ext.auth.mongo.MongoAuth.setUsernameField(String)
io.vertx.rxjava3.ext.auth.mongo.MongoAuth.setUsernameField(String)
io.vertx.reactivex.ext.auth.mongo.MongoAuth.setUsernameField(String)
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.rxjava3.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setValidationFailureHandler(Handler<RoutingContext>)
io.vertx.rxjava3.ext.web.api.contract.RouterFactory.setValidationFailureHandler(Handler<RoutingContext>)
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.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory.setValidationFailureHandler(Handler<RoutingContext>)
io.vertx.reactivex.ext.web.api.contract.RouterFactory.setValidationFailureHandler(Handler<RoutingContext>)
io.vertx.ext.auth.KeyStoreOptions.setValue(Buffer)
io.vertx.rxjava.ext.web.api.RequestParameter.setValue(Object)
io.vertx.rxjava3.ext.web.api.RequestParameter.setValue(Object)
io.vertx.reactivex.ext.web.api.RequestParameter.setValue(Object)
io.vertx.rxjava.ext.web.handler.StaticHandler.setWebRoot(String)
io.vertx.rxjava3.ext.web.handler.StaticHandler.setWebRoot(String)
io.vertx.ext.web.handler.StaticHandler.setWebRoot(String)
io.vertx.reactivex.ext.web.handler.StaticHandler.setWebRoot(String)
io.vertx.mqtt.MqttClientOptions.setWillMessage(String)
io.vertx.core.DeploymentOptions.setWorker(boolean) instead use DeploymentOptions.setThreadingModel(ThreadingModel)
io.vertx.rxjava.core.streams.Pump.setWriteQueueMaxSize(int)
io.vertx.rxjava3.core.streams.Pump.setWriteQueueMaxSize(int)
io.vertx.reactivex.core.streams.Pump.setWriteQueueMaxSize(int)
io.vertx.rxjava.core.http.HttpConnection.shutdown(long)
io.vertx.rxjava3.core.http.HttpConnection.shutdown(long)
io.vertx.core.http.HttpConnection.shutdown(long) instead use HttpConnection.shutdown(long, TimeUnit)
io.vertx.reactivex.core.http.HttpConnection.shutdown(long)
io.vertx.rxjava.core.http.HttpConnection.shutdown(long, Handler<AsyncResult<Void>>)
io.vertx.core.http.HttpConnection.shutdown(long, Handler<AsyncResult<Void>>) instead use HttpConnection.shutdown(long, TimeUnit, Handler)
io.vertx.reactivex.core.http.HttpConnection.shutdown(long, Handler<AsyncResult<Void>>)
io.vertx.redis.client.RedisAPI.slaveof(String, String) since: 5.0.0, replaced by: REPLICAOF
io.vertx.rxjava.core.streams.Pump.start()
io.vertx.rxjava3.core.streams.Pump.start()
io.vertx.reactivex.core.streams.Pump.start()
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicate.status(int)
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicate.status(int)
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicate.status(int)
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicate.status(int, int)
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicate.status(int, int)
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicate.status(int, int)
io.vertx.rxjava.core.streams.Pump.stop()
io.vertx.rxjava3.core.streams.Pump.stop()
io.vertx.reactivex.core.streams.Pump.stop()
io.vertx.redis.client.RedisAPI.substr(String, String, String) since: 2.0.0, replaced by: GETRANGE
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicateResult.succeeded()
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicateResult.succeeded()
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicateResult.succeeded()
io.vertx.junit5.VertxTestContext.succeeding() Use VertxTestContext.succeedingThenComplete() or VertxTestContext.succeeding(Handler), for example succeeding(value -> checkpoint.flag()), succeeding(value -> { more testing code }), or succeeding(value -> {}).
io.vertx.rxjava.ext.web.client.predicate.ResponsePredicateResult.success()
io.vertx.rxjava3.ext.web.client.predicate.ResponsePredicateResult.success()
io.vertx.reactivex.ext.web.client.predicate.ResponsePredicateResult.success()
io.vertx.rxjava.core.Vertx.timerStream(long)
io.vertx.rxjava3.core.Vertx.timerStream(long)
io.vertx.core.Vertx.timerStream(long) use Vertx.setTimer(long, io.vertx.core.Handler<java.lang.Long>) instead. RxJava like integrations should use the Vert.x scheduler integration.
io.vertx.reactivex.core.Vertx.timerStream(long)
io.vertx.config.spi.utils.JsonObjectHelper.toBuffer(JsonObject) use JsonObject.toBuffer() instead
io.vertx.rxjava.ext.web.api.RequestParameter.toJson()
io.vertx.rxjava.ext.web.api.RequestParameters.toJson()
io.vertx.rxjava.core.buffer.Buffer.toJson()
io.vertx.rxjava3.ext.web.api.RequestParameter.toJson()
io.vertx.rxjava3.ext.web.api.RequestParameters.toJson()
io.vertx.rxjava3.core.buffer.Buffer.toJson()
io.vertx.core.buffer.Buffer.toJson() instead use Buffer.toJsonValue()
io.vertx.reactivex.ext.web.api.RequestParameter.toJson()
io.vertx.reactivex.ext.web.api.RequestParameters.toJson()
io.vertx.reactivex.core.buffer.Buffer.toJson()
io.vertx.core.logging.Logger.trace(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.trace(Object, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.trace(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.trace(Object, Throwable, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSConnectionInitEvent.tryComplete(Object)
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSConnectionInitEvent.tryComplete(Object)
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSConnectionInitEvent.tryComplete(Object)
io.vertx.rxjava.ext.web.handler.graphql.ApolloWSMessage.type()
io.vertx.rxjava3.ext.web.handler.graphql.ApolloWSMessage.type()
io.vertx.reactivex.ext.web.handler.graphql.ApolloWSMessage.type()
io.vertx.rxjava.ext.consul.ConsulClient.updateAclToken(AclToken)
io.vertx.rxjava3.ext.consul.ConsulClient.updateAclToken(AclToken)
io.vertx.ext.consul.ConsulClient.updateAclToken(AclToken)
io.vertx.reactivex.ext.consul.ConsulClient.updateAclToken(AclToken)
io.vertx.rxjava.ext.consul.ConsulClient.updateAclToken(AclToken, Handler<AsyncResult<String>>)
io.vertx.ext.consul.ConsulClient.updateAclToken(AclToken, Handler<AsyncResult<String>>) Use ConsulClient.updateAclToken(String, io.vertx.ext.consul.token.AclToken) instead
io.vertx.reactivex.ext.consul.ConsulClient.updateAclToken(AclToken, Handler<AsyncResult<String>>)
io.vertx.rxjava.ext.web.Route.useNormalisedPath(boolean)
io.vertx.rxjava3.ext.web.Route.useNormalisedPath(boolean)
io.vertx.ext.web.Route.useNormalisedPath(boolean)
io.vertx.reactivex.ext.web.Route.useNormalisedPath(boolean)
io.vertx.rxjava.ext.web.api.validation.CustomValidator.validate(RoutingContext)
io.vertx.rxjava3.ext.web.api.validation.CustomValidator.validate(RoutingContext)
io.vertx.reactivex.ext.web.api.validation.CustomValidator.validate(RoutingContext)
io.vertx.rxjava.ext.web.api.validation.ParameterValidationRule.validateArrayParam(List<String>)
io.vertx.rxjava3.ext.web.api.validation.ParameterValidationRule.validateArrayParam(List<String>)
io.vertx.reactivex.ext.web.api.validation.ParameterValidationRule.validateArrayParam(List<String>)
io.vertx.rxjava.json.schema.Schema.validateAsync(Object)
io.vertx.rxjava3.json.schema.Schema.validateAsync(Object)
io.vertx.reactivex.json.schema.Schema.validateAsync(Object)
io.vertx.rxjava.ext.web.api.validation.ParameterValidationRule.validateSingleParam(String)
io.vertx.rxjava3.ext.web.api.validation.ParameterValidationRule.validateSingleParam(String)
io.vertx.reactivex.ext.web.api.validation.ParameterValidationRule.validateSingleParam(String)
io.vertx.rxjava.json.schema.Schema.validateSync(Object)
io.vertx.rxjava3.json.schema.Schema.validateSync(Object)
io.vertx.reactivex.json.schema.Schema.validateSync(Object)
io.vertx.rxjava.ext.auth.HashingStrategy.verify(String, String)
io.vertx.rxjava3.ext.auth.HashingStrategy.verify(String, String)
io.vertx.reactivex.ext.auth.HashingStrategy.verify(String, String)
io.vertx.core.logging.Logger.warn(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.warn(Object, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.warn(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.warn(Object, Throwable, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.rxjava.core.http.HttpClient.webSocket(int, String, String)
io.vertx.rxjava3.core.http.HttpClient.webSocket(int, String, String)
io.vertx.core.http.HttpClient.webSocket(int, String, String) instead use WebSocketClient.connect(int, String, String)
io.vertx.reactivex.core.http.HttpClient.webSocket(int, String, String)
io.vertx.rxjava.core.http.HttpClient.webSocket(int, String, String, Handler<AsyncResult<WebSocket>>)
io.vertx.core.http.HttpClient.webSocket(int, String, String, Handler<AsyncResult<WebSocket>>) instead use WebSocketClient.connect(int, String, String, Handler)
io.vertx.reactivex.core.http.HttpClient.webSocket(int, String, String, Handler<AsyncResult<WebSocket>>)
io.vertx.rxjava.core.http.HttpClient.webSocket(String)
io.vertx.rxjava3.core.http.HttpClient.webSocket(String)
io.vertx.core.http.HttpClient.webSocket(String) instead use WebSocketClient.connect(int, String, String)
io.vertx.reactivex.core.http.HttpClient.webSocket(String)
io.vertx.rxjava.core.http.HttpClient.webSocket(String, Handler<AsyncResult<WebSocket>>)
io.vertx.core.http.HttpClient.webSocket(String, Handler<AsyncResult<WebSocket>>) instead use WebSocketClient.connect(int, String, String, Handler)
io.vertx.reactivex.core.http.HttpClient.webSocket(String, Handler<AsyncResult<WebSocket>>)
io.vertx.rxjava.core.http.HttpClient.webSocket(String, String)
io.vertx.rxjava3.core.http.HttpClient.webSocket(String, String)
io.vertx.core.http.HttpClient.webSocket(String, String) instead use WebSocketClient.connect(int, String, String)
io.vertx.reactivex.core.http.HttpClient.webSocket(String, String)
io.vertx.rxjava.core.http.HttpClient.webSocket(String, String, Handler<AsyncResult<WebSocket>>)
io.vertx.core.http.HttpClient.webSocket(String, String, Handler<AsyncResult<WebSocket>>) instead use WebSocketClient.connect(int, String, String, Handler)
io.vertx.reactivex.core.http.HttpClient.webSocket(String, String, Handler<AsyncResult<WebSocket>>)
io.vertx.rxjava.core.http.HttpClient.webSocket(WebSocketConnectOptions)
io.vertx.rxjava3.core.http.HttpClient.webSocket(WebSocketConnectOptions)
io.vertx.core.http.HttpClient.webSocket(WebSocketConnectOptions) instead use WebSocketClient.connect(WebSocketConnectOptions)
io.vertx.reactivex.core.http.HttpClient.webSocket(WebSocketConnectOptions)
io.vertx.rxjava.core.http.HttpClient.webSocket(WebSocketConnectOptions, Handler<AsyncResult<WebSocket>>)
io.vertx.core.http.HttpClient.webSocket(WebSocketConnectOptions, Handler<AsyncResult<WebSocket>>) instead use WebSocketClient.connect(WebSocketConnectOptions, Handler)
io.vertx.reactivex.core.http.HttpClient.webSocket(WebSocketConnectOptions, Handler<AsyncResult<WebSocket>>)
io.vertx.rxjava.core.http.HttpClient.webSocketAbs(String, MultiMap, WebsocketVersion, List<String>)
io.vertx.rxjava3.core.http.HttpClient.webSocketAbs(String, MultiMap, WebsocketVersion, List<String>)
io.vertx.core.http.HttpClient.webSocketAbs(String, MultiMap, WebsocketVersion, List<String>) instead use WebSocketClient.connect(WebSocketConnectOptions)
io.vertx.reactivex.core.http.HttpClient.webSocketAbs(String, MultiMap, WebsocketVersion, List<String>)
io.vertx.rxjava.core.http.HttpClient.webSocketAbs(String, MultiMap, WebsocketVersion, List<String>, Handler<AsyncResult<WebSocket>>)
io.vertx.core.http.HttpClient.webSocketAbs(String, MultiMap, WebsocketVersion, List<String>, Handler<AsyncResult<WebSocket>>) instead use WebSocketClient.connect(WebSocketConnectOptions, Handler)
io.vertx.reactivex.core.http.HttpClient.webSocketAbs(String, MultiMap, WebsocketVersion, List<String>, Handler<AsyncResult<WebSocket>>)
io.vertx.rxjava.core.http.HttpServer.webSocketStream()
io.vertx.rxjava3.core.http.HttpServer.webSocketStream()
io.vertx.core.http.HttpServer.webSocketStream() instead use HttpServer.webSocketHandler(Handler)
io.vertx.reactivex.core.http.HttpServer.webSocketStream()
io.vertx.rxjava.json.schema.SchemaParser.withStringFormatValidator(String, Predicate<String>)
io.vertx.rxjava3.json.schema.SchemaParser.withStringFormatValidator(String, Predicate<String>)
io.vertx.reactivex.json.schema.SchemaParser.withStringFormatValidator(String, Predicate<String>)
io.vertx.rxjava.json.schema.SchemaParser.withValidatorFactory(ValidatorFactory)
io.vertx.rxjava3.json.schema.SchemaParser.withValidatorFactory(ValidatorFactory)
io.vertx.reactivex.json.schema.SchemaParser.withValidatorFactory(ValidatorFactory)
io.vertx.redis.client.RedisAPI.zrangebylex(List<String>) since: 6.2.0, replaced by: ZRANGE with the BYLEX argument
io.vertx.redis.client.RedisAPI.zrangebyscore(List<String>) since: 6.2.0, replaced by: ZRANGE with the BYSCORE argument
io.vertx.redis.client.RedisAPI.zrevrange(List<String>) since: 6.2.0, replaced by: ZRANGE with the REV argument
io.vertx.redis.client.RedisAPI.zrevrangebylex(List<String>) since: 6.2.0, replaced by: ZRANGE with the REV and BYLEX arguments
io.vertx.redis.client.RedisAPI.zrevrangebyscore(List<String>) since: 6.2.0, replaced by: ZRANGE with the REV and BYSCORE arguments

Deprecated Constructors

Constructor and Description
io.vertx.core.spi.launcher.DefaultCommandFactory(Class<C>) Please use DefaultCommandFactory(Class, Supplier)
io.vertx.core.logging.Logger(LogDelegate) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.pgclient.data.Money(long, int) as of 4.5, use Money(Number) instead
io.vertx.tracing.opentelemetry.OpenTelemetryOptions(OpenTelemetry) instead use VertxBuilder.withTracer(VertxTracerFactory) and OpenTelemetryTracer(OpenTelemetry).
io.vertx.tracing.opentracing.OpenTracingOptions(Tracer) instead use VertxBuilder.withTracer(VertxTracerFactory) and OpenTracingTracer(boolean, Tracer).
io.vertx.tracing.zipkin.ZipkinTracingOptions(HttpTracing) instead use VertxBuilder.withTracer(VertxTracerFactory) and ZipkinTracerFactory(HttpTracing).
io.vertx.tracing.zipkin.ZipkinTracingOptions(Tracing) instead use VertxBuilder.withTracer(VertxTracerFactory) and ZipkinTracerFactory(Tracing).

Deprecated Enum Constants

Enum Constant and Description
io.vertx.json.schema.common.dsl.SchemaType.INT