All Types

io.vertx.servicediscovery.types.AbstractServiceReference

A class to simplify the implementation of service reference. It stores the service object once retrieved. This class handles the synchronization, so callbacks are called with the monitor lock to avoid concurrent accesses.

io.vertx.ext.auth.AbstractUser

Useful base class for implementing a User object.

This class handles the caching logic so you can concentrate on the actual authorisation logic.

Just implement the abstract methods in your concrete sub-class.

io.vertx.rxjava.core.AbstractVerticle
io.vertx.reactivex.core.AbstractVerticle
io.vertx.ext.stomp.Acknowledgement

Structure passed to acknowledgement handler called when a ACK or NACK frame is received. The handler receives an instance of Acknowledgement with the subscription Frame and the impacted messages. The list of messages depends on the type of acknowledgment used by the subscription. Subscriptions using the client mode receives all messages that were waiting for acknowledgment that were sent before the acknowledged messages. The list also contains the acknowledged message. This is a cumulative acknowledgement. Subscriptions using the client-individual mode receives a singleton list containing only the acknowledged message.

io.vertx.rxjava.ext.stomp.Acknowledgement

Structure passed to acknowledgement handler called when a ACK or NACK frame is received. The handler receives an instance of io.vertx.rxjava.ext.stomp.Acknowledgement with the subscription io.vertx.ext.stomp.Frame and the impacted messages. The list of messages depends on the type of acknowledgment used by the subscription. Subscriptions using the client mode receives all messages that were waiting for acknowledgment that were sent before the acknowledged messages. The list also contains the acknowledged message. This is a cumulative acknowledgement. Subscriptions using the client-individual mode receives a singleton list containing only the acknowledged message. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.Acknowledgement non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.stomp.Acknowledgement

Structure passed to acknowledgement handler called when a ACK or NACK frame is received. The handler receives an instance of io.vertx.reactivex.ext.stomp.Acknowledgement with the subscription io.vertx.ext.stomp.Frame and the impacted messages. The list of messages depends on the type of acknowledgment used by the subscription. Subscriptions using the client mode receives all messages that were waiting for acknowledgment that were sent before the acknowledged messages. The list also contains the acknowledged message. This is a cumulative acknowledgement. Subscriptions using the client-individual mode receives a singleton list containing only the acknowledged message. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.Acknowledgement non RX-ified interface using Vert.x codegen.

io.vertx.kafka.admin.AdminUtils

Provides a wrapper around important methods in Kafka's AdminUtils, namely

io.vertx.rxjava.kafka.admin.AdminUtils

Provides a wrapper around important methods in Kafka's AdminUtils, namely NOTE: This class has been automatically generated from the io.vertx.kafka.admin.AdminUtils non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.kafka.admin.AdminUtils

Provides a wrapper around important methods in Kafka's AdminUtils, namely NOTE: This class has been automatically generated from the io.vertx.kafka.admin.AdminUtils non RX-ified interface using Vert.x codegen.

io.vertx.redis.op.AggregateOptions
io.vertx.core.cli.AmbiguousOptionException

Exception thrown when the command line is ambiguous meaning it cannot determine exactly which option has to be set.

io.vertx.amqpbridge.AmqpBridge

Vert.x AMQP Bridge. Facilitates sending and receiving AMQP 1.0 messages.

io.vertx.rxjava.amqpbridge.AmqpBridge

Vert.x AMQP Bridge. Facilitates sending and receiving AMQP 1.0 messages. NOTE: This class has been automatically generated from the io.vertx.amqpbridge.AmqpBridge non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.amqpbridge.AmqpBridge

Vert.x AMQP Bridge. Facilitates sending and receiving AMQP 1.0 messages. NOTE: This class has been automatically generated from the io.vertx.amqpbridge.AmqpBridge non RX-ified interface using Vert.x codegen.

io.vertx.amqpbridge.AmqpBridgeOptionsConverter

Converter for io.vertx.amqpbridge.AmqpBridgeOptions. NOTE: This class has been automatically generated from the io.vertx.amqpbridge.AmqpBridgeOptions original class using Vert.x codegen.

io.vertx.amqpbridge.AmqpConstants

Helpful constants for dealing with the various sections/elements forming the JsonObject representation of the AMQP message.

io.vertx.core.cli.Argument

Defines a command line argument. Unlike options, argument don't have names and are identified using an index. The first index is 0 (because we are in the computer world).

io.vertx.core.cli.annotations.Argument

Annotates a setter to be called with the value of a command line argument.

io.vertx.ext.unit.Async

An asynchronous exit point for a test.

io.vertx.rxjava.ext.unit.Async

An asynchronous exit point for a test. NOTE: This class has been automatically generated from the io.vertx.ext.unit.Async non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.Async

An asynchronous exit point for a test. NOTE: This class has been automatically generated from the io.vertx.ext.unit.Async non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.file.AsyncFile

Represents a file on the file-system which can be read from, or written to asynchronously.

This class also implements io.vertx.reactivex.core.streams.ReadStream and io.vertx.reactivex.core.streams.WriteStream. This allows the data to be pumped to and from other streams, e.g. an io.vertx.reactivex.core.http.HttpClientRequest instance, using the io.vertx.reactivex.core.streams.Pump class

NOTE: This class has been automatically generated from the io.vertx.core.file.AsyncFile non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.shareddata.AsyncMap

An asynchronous map.

NOTE: This class has been automatically generated from the io.vertx.core.shareddata.AsyncMap non RX-ified interface using Vert.x codegen.

io.vertx.core.spi.cluster.AsyncMultiMap

An asynchronous multi-map. A multi-map holds a Set of values against each key as opposed to a single value, as with a Map. A value appears only once for a key (no duplicated values for the same key). The cluster implementation should ensure that any entries placed in the map from any node are available on any node of the cluster.

io.vertx.config.vault.client.Auth

Represents Auth result.

io.vertx.ext.web.handler.AuthHandler

Base interface for auth handlers.

An auth handler allows your application to provide authentication/authorisation support.

Auth handler requires a SessionHandler to be on the routing chain before it.

io.vertx.rxjava.ext.web.handler.AuthHandler

Base interface for auth handlers.

An auth handler allows your application to provide authentication/authorisation support.

Auth handler requires a io.vertx.rxjava.ext.web.handler.SessionHandler to be on the routing chain before it.

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.AuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.AuthHandler

Base interface for auth handlers.

An auth handler allows your application to provide authentication/authorisation support.

Auth handler requires a io.vertx.reactivex.ext.web.handler.SessionHandler to be on the routing chain before it.

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.AuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.mongo.AuthenticationException

Signals an error inside the authentication process

io.vertx.ext.hawkular.AuthenticationOptionsConverter

Converter for io.vertx.ext.hawkular.AuthenticationOptions. NOTE: This class has been automatically generated from the io.vertx.ext.hawkular.AuthenticationOptions original class using Vert.x codegen.

io.vertx.ext.auth.oauth2.providers.AzureADAuth

Simplified factory to create an OAuth2Auth for Azure AD.

io.vertx.rxjava.ext.auth.oauth2.providers.AzureADAuth

Simplified factory to create an for Azure AD. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.AzureADAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.AzureADAuth

Simplified factory to create an for Azure AD. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.AzureADAuth non RX-ified interface using Vert.x codegen.

io.vertx.micrometer.backends.BackendRegistries

BackendRegistries is responsible for managing registries related to particular micrometer backends (influxdb, prometheus...) It contains a store of BackendRegistry objects, each of whose encapsulating a micrometer's MeterRegistry

io.vertx.micrometer.backends.BackendRegistry
io.vertx.ext.bridge.BaseBridgeEvent

Represents an event that occurs on the event bus bridge.

Please consult the documentation for a full explanation.

io.vertx.rxjava.ext.bridge.BaseBridgeEvent

Represents an event that occurs on the event bus bridge.

Please consult the documentation for a full explanation.

NOTE: This class has been automatically generated from the io.vertx.ext.bridge.BaseBridgeEvent non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.bridge.BaseBridgeEvent

Represents an event that occurs on the event bus bridge.

Please consult the documentation for a full explanation.

NOTE: This class has been automatically generated from the io.vertx.ext.bridge.BaseBridgeEvent non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.command.base.BaseCommandPack
io.vertx.ext.web.handler.BasicAuthHandler

An auth handler that provides HTTP Basic Authentication support.

io.vertx.rxjava.ext.web.handler.BasicAuthHandler

An auth handler that provides HTTP Basic Authentication support. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.BasicAuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.BasicAuthHandler

An auth handler that provides HTTP Basic Authentication support. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.BasicAuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.redis.op.BitFieldOverflowOptions
io.vertx.redis.op.BitOperation
io.vertx.ext.consul.BlockingQueryOptionsConverter

Converter for io.vertx.ext.consul.BlockingQueryOptions. NOTE: This class has been automatically generated from the io.vertx.ext.consul.BlockingQueryOptions original class using Vert.x codegen.

io.vertx.grpc.BlockingServerInterceptor

Wraps the ServerInterceptor and executes it on worker thread. All incoming events will be deferred until the interception is completed.

io.vertx.ext.web.codec.BodyCodec

A codec for encoding and decoding HTTP bodies.

io.vertx.rxjava.ext.web.codec.BodyCodec

A codec for encoding and decoding HTTP bodies. NOTE: This class has been automatically generated from the io.vertx.ext.web.codec.BodyCodec non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.codec.BodyCodec

A codec for encoding and decoding HTTP bodies. NOTE: This class has been automatically generated from the io.vertx.ext.web.codec.BodyCodec non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.ext.web.handler.BodyHandler

A handler which gathers the entire request body and sets it on the .

It also handles HTTP file uploads and can be used to limit body sizes.

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.BodyHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.BodyHandler

A handler which gathers the entire request body and sets it on the .

It also handles HTTP file uploads and can be used to limit body sizes.

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.BodyHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.codec.spi.BodyStream

The body stream decodes a < into the a T instance.

io.vertx.core.cli.converters.BooleanConverter

A converter for boolean. This converter considered as 'true' : "true", "on", "1", "yes". All other values are considered as 'false' (as a consequence, 'null' is considered as 'false').

io.vertx.ext.auth.oauth2.providers.BoxAuth

Simplified factory to create an OAuth2Auth for box.com.

io.vertx.rxjava.ext.auth.oauth2.providers.BoxAuth

Simplified factory to create an for box.com. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.BoxAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.BoxAuth

Simplified factory to create an for box.com. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.BoxAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.bridge.BridgeEventType

Bridge Event Types.

io.vertx.ext.groovy.eventbus.bridge.tcp.BridgeEvent_GroovyExtension
io.vertx.ext.bridge.BridgeOptionsConverter

Converter for io.vertx.ext.bridge.BridgeOptions. NOTE: This class has been automatically generated from the io.vertx.ext.bridge.BridgeOptions original class using Vert.x codegen.

io.vertx.core.buffer.Buffer (extensions in package io.vertx.kotlin.core.buffer)
io.vertx.reactivex.core.buffer.Buffer

Most data is shuffled around inside Vert.x using buffers.

A buffer is a sequence of zero or more bytes that can read from or written to and which expands automatically as necessary to accommodate any bytes written to it. You can perhaps think of a buffer as smart byte array.

Please consult the documentation for more information on buffers.

NOTE: This class has been automatically generated from the io.vertx.core.buffer.Buffer non RX-ified interface using Vert.x codegen.

io.vertx.kafka.client.serialization.BufferDeserializer

Kafka deserializer for raw bytes in a buffer

io.vertx.core.spi.BufferFactory
io.vertx.kafka.client.serialization.BufferSerializer

Kafka serializer for raw bytes in a buffer

io.vertx.ext.shell.command.base.BusSend
io.vertx.ext.shell.command.base.BusTail
io.vertx.reactivex.core.cli.CLI

Interface defining a command-line interface (in other words a command such as 'run', 'ls'...). This interface is polyglot to ease reuse such as in Vert.x Shell. A command line interface has a name, and defines a set of options and arguments. Options are key-value pair such as -foo=bar or -flag. The supported formats depend on the used parser. Arguments are unlike options raw values. Options are defined using io.vertx.core.cli.Option, while argument are defined using io.vertx.core.cli.Argument. Command line interfaces also define a summary and a description. These attributes are used in the usage generation . To disable the help generation, set the hidden attribute to true. Command Line Interface object does not contains "value", it's a model. It must be evaluated by a parser that returns a io.vertx.reactivex.core.cli.CommandLine object containing the argument and option values. NOTE: This class has been automatically generated from the io.vertx.core.cli.CLI non RX-ified interface using Vert.x codegen.

io.vertx.core.cli.annotations.CLIConfigurator

Class responsible for defining CLI using annotations and injecting values extracted by the parser.

io.vertx.core.cli.CLIException

High level exception thrown when an issue in the command line processing occurs.

io.vertx.ext.web.handler.CSRFHandler

This handler adds a CSRF token to requests which mutate state. In order change the state a (XSRF-TOKEN) cookie is set with a unique token, that is expected to be sent back in a (X-XSRF-TOKEN) header. The behavior is to check the request body header and cookie for validity. This Handler requires session support, thus should be added somewhere below Session and Body handlers.

io.vertx.rxjava.ext.web.handler.CSRFHandler

This handler adds a CSRF token to requests which mutate state. In order change the state a (XSRF-TOKEN) cookie is set with a unique token, that is expected to be sent back in a (X-XSRF-TOKEN) header. The behavior is to check the request body header and cookie for validity. This Handler requires session support, thus should be added somewhere below Session and Body handlers. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.CSRFHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.CSRFHandler

This handler adds a CSRF token to requests which mutate state. In order change the state a (XSRF-TOKEN) cookie is set with a unique token, that is expected to be sent back in a (X-XSRF-TOKEN) header. The behavior is to check the request body header and cookie for validity. This Handler requires session support, thus should be added somewhere below Session and Body handlers. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.CSRFHandler non RX-ified interface using Vert.x codegen.

io.vertx.camel.CamelBridge

Camel Bridge facade.

io.vertx.camel.CamelBridgeOptions

Camel bridge configuration.

io.vertx.camel.CamelMapping

Parent class for mapping between Vert.x event bus and Camel endpoints.

io.vertx.core.http.CaseInsensitiveHeaders

This multi-map implementation has case insensitive keys, and can be used to hold some HTTP headers prior to making an HTTP request.

io.vertx.ext.auth.ChainAuth

Chain several auth providers as if they were one. This is useful for cases where one want to authenticate across several providers, for example, database and fallback to passwd file.

io.vertx.rxjava.ext.auth.ChainAuth

Chain several auth providers as if they were one. This is useful for cases where one want to authenticate across several providers, for example, database and fallback to passwd file. NOTE: This class has been automatically generated from the io.vertx.ext.auth.ChainAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.ChainAuth

Chain several auth providers as if they were one. This is useful for cases where one want to authenticate across several providers, for example, database and fallback to passwd file. NOTE: This class has been automatically generated from the io.vertx.ext.auth.ChainAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.handler.ChainAuthHandler

An auth handler that chains to a sequence of handlers.

io.vertx.rxjava.ext.web.handler.ChainAuthHandler

An auth handler that chains to a sequence of handlers. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.ChainAuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.ChainAuthHandler

An auth handler that chains to a sequence of handlers. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.ChainAuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.core.cli.converters.CharacterConverter

A converter for character. Unlike other primitive types, characters cannot be created using 'valueOf'. Notice that only input having a length of 1 can be converted to characters. Other inputs are rejected.

io.vertx.ext.consul.CheckConverter

Converter for io.vertx.ext.consul.Check. NOTE: This class has been automatically generated from the io.vertx.ext.consul.Check original class using Vert.x codegen.

io.vertx.ext.consul.CheckListConverter

Converter for io.vertx.ext.consul.CheckList. NOTE: This class has been automatically generated from the io.vertx.ext.consul.CheckList original class using Vert.x codegen.

io.vertx.ext.consul.CheckOptionsConverter

Converter for io.vertx.ext.consul.CheckOptions. NOTE: This class has been automatically generated from the io.vertx.ext.consul.CheckOptions original class using Vert.x codegen.

io.vertx.ext.consul.CheckQueryOptionsConverter

Converter for io.vertx.ext.consul.CheckQueryOptions. NOTE: This class has been automatically generated from the io.vertx.ext.consul.CheckQueryOptions original class using Vert.x codegen.

io.vertx.junit5.Checkpoint

A test completion checkpoint, flagging it advances towards the test context completion.

io.vertx.core.spi.cluster.ChoosableIterable

An extension of Iterable which allows keeps track of an iterator internally to allow the next element to be chosen

io.vertx.rxjava.circuitbreaker.CircuitBreaker

An implementation of the circuit breaker pattern for Vert.x NOTE: This class has been automatically generated from the io.vertx.circuitbreaker.CircuitBreaker non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.circuitbreaker.CircuitBreaker

An implementation of the circuit breaker pattern for Vert.x NOTE: This class has been automatically generated from the io.vertx.circuitbreaker.CircuitBreaker non RX-ified interface using Vert.x codegen.

io.vertx.circuitbreaker.CircuitBreakerOptionsConverter

Converter for io.vertx.circuitbreaker.CircuitBreakerOptions. NOTE: This class has been automatically generated from the io.vertx.circuitbreaker.CircuitBreakerOptions original class using Vert.x codegen.

io.vertx.servicediscovery.utils.ClassLoaderUtils
io.vertx.redis.op.ClientReplyOptions
io.vertx.core.Closeable
io.vertx.ext.auth.oauth2.providers.CloudFoundryAuth

Simplified factory to create an OAuth2Auth for CloudFoundry UAA.

io.vertx.rxjava.ext.auth.oauth2.providers.CloudFoundryAuth

Simplified factory to create an for CloudFoundry UAA. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.CloudFoundryAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.CloudFoundryAuth

Simplified factory to create an for CloudFoundry UAA. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.CloudFoundryAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.sstore.ClusteredSessionStore

A session store which stores sessions in a distributed map so they are available across the cluster.

io.vertx.rxjava.ext.web.sstore.ClusteredSessionStore

A session store which stores sessions in a distributed map so they are available across the cluster. NOTE: This class has been automatically generated from the io.vertx.ext.web.sstore.ClusteredSessionStore non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.sstore.ClusteredSessionStore

A session store which stores sessions in a distributed map so they are available across the cluster. NOTE: This class has been automatically generated from the io.vertx.ext.web.sstore.ClusteredSessionStore non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.command.Command

A Vert.x Shell command, it can be created from any language using the CommandBuilder#command or from a Java class using Command#create

io.vertx.rxjava.ext.shell.command.Command

A Vert.x Shell command, it can be created from any language using the io.vertx.rxjava.ext.shell.command.CommandBuilder#command or from a Java class using io.vertx.rxjava.ext.shell.command.Command#create NOTE: This class has been automatically generated from the io.vertx.ext.shell.command.Command non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.command.Command

A Vert.x Shell command, it can be created from any language using the io.vertx.reactivex.ext.shell.command.CommandBuilder#command or from a Java class using io.vertx.reactivex.ext.shell.command.Command#create NOTE: This class has been automatically generated from the io.vertx.ext.shell.command.Command non RX-ified interface using Vert.x codegen.

io.vertx.core.spi.launcher.CommandFactoryLookup

The interface to implement to look for commands.

io.vertx.core.cli.CommandLine

The parser transforms a CLI (a model) into an CommandLine. This CommandLine has stored the argument and option values. Only instance of parser should create objects of this type.

io.vertx.rxjava.core.cli.CommandLine

The parser transforms a CLI (a model) into an io.vertx.rxjava.core.cli.CommandLine. This io.vertx.rxjava.core.cli.CommandLine has stored the argument and option values. Only instance of parser should create objects of this type. NOTE: This class has been automatically generated from the io.vertx.core.cli.CommandLine non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.cli.CommandLine

The parser transforms a CLI (a model) into an io.vertx.reactivex.core.cli.CommandLine. This io.vertx.reactivex.core.cli.CommandLine has stored the argument and option values. Only instance of parser should create objects of this type. NOTE: This class has been automatically generated from the io.vertx.core.cli.CommandLine non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.command.CommandProcess

The command process provides interaction with the process of the command provided by Vert.x Shell.

io.vertx.rxjava.ext.shell.command.CommandProcess

The command process provides interaction with the process of the command provided by Vert.x Shell. NOTE: This class has been automatically generated from the io.vertx.ext.shell.command.CommandProcess non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.command.CommandProcess

The command process provides interaction with the process of the command provided by Vert.x Shell. NOTE: This class has been automatically generated from the io.vertx.ext.shell.command.CommandProcess non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.command.CommandRegistry

A registry that contains the commands known by a shell. It is a mutable command resolver.

io.vertx.rxjava.ext.shell.command.CommandRegistry

A registry that contains the commands known by a shell. It is a mutable command resolver. NOTE: This class has been automatically generated from the io.vertx.ext.shell.command.CommandRegistry non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.command.CommandRegistry

A registry that contains the commands known by a shell. It is a mutable command resolver. NOTE: This class has been automatically generated from the io.vertx.ext.shell.command.CommandRegistry non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.spi.CommandResolverFactory

The SPI interface for discovering commands.

io.vertx.reactivex.CompletableHelper
io.vertx.ext.unit.Completion

A completion object that emits completion notifications either succeeded or failed.

io.vertx.ext.shell.cli.Completion

The completion object

io.vertx.rxjava.ext.unit.Completion

A completion object that emits completion notifications either succeeded or failed. NOTE: This class has been automatically generated from the io.vertx.ext.unit.Completion non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.ext.shell.cli.Completion

The completion object NOTE: This class has been automatically generated from the io.vertx.ext.shell.cli.Completion non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.Completion

A completion object that emits completion notifications either succeeded or failed. NOTE: This class has been automatically generated from the io.vertx.ext.unit.Completion non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.cli.Completion

The completion object NOTE: This class has been automatically generated from the io.vertx.ext.shell.cli.Completion non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.core.CompositeFuture

The composite future wraps a list of io.vertx.rxjava.core.Future, it is useful when several futures needs to be coordinated. The handlers set for the coordinated futures are overridden by the handler of the composite future. NOTE: This class has been automatically generated from the io.vertx.core.CompositeFuture non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.CompositeFuture

The composite future wraps a list of io.vertx.reactivex.core.Future, it is useful when several futures needs to be coordinated. The handlers set for the coordinated futures are overridden by the handler of the composite future. NOTE: This class has been automatically generated from the io.vertx.core.CompositeFuture non RX-ified interface using Vert.x codegen.

io.vertx.codegen.extra.ConcreteInheritsToString
io.vertx.codegen.extra.ConcreteOverridesToString
io.vertx.config.kubernetes.ConfigMapStore

An implementation of configuration store reading config map from Kubernetes.

io.vertx.config.kubernetes.ConfigMapStoreFactory
io.vertx.config.ConfigRetriever

Defines a configuration retriever that read configuration from ConfigStore and tracks changes periodically.

io.vertx.rxjava.config.ConfigRetriever

Defines a configuration retriever that read configuration from and tracks changes periodically. NOTE: This class has been automatically generated from the io.vertx.config.ConfigRetriever non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.config.ConfigRetriever

Defines a configuration retriever that read configuration from and tracks changes periodically. NOTE: This class has been automatically generated from the io.vertx.config.ConfigRetriever non RX-ified interface using Vert.x codegen.

io.vertx.config.ConfigRetrieverOptionsConverter

Converter for io.vertx.config.ConfigRetrieverOptions. NOTE: This class has been automatically generated from the io.vertx.config.ConfigRetrieverOptions original class using Vert.x codegen.

io.vertx.core.http.ConnectionPoolTooBusyException

Represents a failure to add a HttpClientRequest to the wait queue on an ConnectionManager.

If an HttpClient receives a request but is already handling maxPoolSize requests it will attempt to put the new request on it's wait queue. If the maxWaitQueueSize is set and the new request would cause the wait queue to exceed that size then the request will receive this exception.

io.vertx.core.cli.converters.ConstructorBasedConverter

This 'default' converter tries to create objects using a constructor taking a single String argument. Be aware that implementation must also handle the case where the input is null.

io.vertx.rxjava.ext.consul.ConsulClient

A Vert.x service used to interact with Consul. NOTE: This class has been automatically generated from the io.vertx.ext.consul.ConsulClient non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.consul.ConsulClient

A Vert.x service used to interact with Consul. NOTE: This class has been automatically generated from the io.vertx.ext.consul.ConsulClient non RX-ified interface using Vert.x codegen.

io.vertx.ext.consul.ConsulClientOptionsConverter

Converter for io.vertx.ext.consul.ConsulClientOptions. NOTE: This class has been automatically generated from the io.vertx.ext.consul.ConsulClientOptions original class using Vert.x codegen.

io.vertx.config.consul.ConsulConfigStore
io.vertx.config.consul.ConsulConfigStoreFactory
io.vertx.servicediscovery.consul.ConsulServiceImporter

A discovery bridge importing services from Consul.

io.vertx.ext.web.api.validation.ContainerDeserializer

Interface that define methods for deserialization of array and objects

io.vertx.rxjava.ext.web.api.validation.ContainerDeserializer

Interface that define methods for deserialization of array and objects NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.ContainerDeserializer non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.validation.ContainerDeserializer

Interface that define methods for deserialization of array and objects NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.ContainerDeserializer non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.api.validation.ContainerSerializationStyle

This enum contains supported object and arrays serialization styles. Every style has a enum value, and an array of strings to refeer to it.

io.vertx.core.Context (extensions in package io.vertx.kotlin.coroutines)
io.vertx.reactivex.core.Context

The execution context of a io.vertx.reactivex.core.Handler execution.

When Vert.x provides an event to a handler or calls the start or stop methods of a io.vertx.reactivex.core.Verticle, the execution is associated with a Context.

Usually a context is an *event-loop context* and is tied to a specific event loop thread. So executions for that context always occur on that exact same event loop thread.

In the case of worker verticles and running inline blocking code a worker context will be associated with the execution which will use a thread from the worker thread pool.

When a handler is set by a thread associated with a specific context, the Vert.x will guarantee that when that handler is executed, that execution will be associated with the same context.

If a handler is set by a thread not associated with a context (i.e. a non Vert.x thread). Then a new context will be created for that handler.

In other words, a context is propagated.

This means that when a verticle is deployed, any handlers it sets will be associated with the same context - the context of the verticle.

This means (in the case of a standard verticle) that the verticle code will always be executed with the exact same thread, so you don't have to worry about multi-threaded acccess to the verticle state and you can code your application as single threaded.

This class also allows arbitrary data to be io.vertx.reactivex.core.Context#put and io.vertx.reactivex.core.Context#get on the context so it can be shared easily amongst different handlers of, for example, a verticle instance.

This class also provides io.vertx.reactivex.core.Context#runOnContext which allows an action to be executed asynchronously using the same context.

NOTE: This class has been automatically generated from the io.vertx.core.Context non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ContextScheduler
io.vertx.core.cli.annotations.ConvertedBy

Annotates Option setters to indicate how the value is converted to the argument type.

io.vertx.core.cli.converters.Converters

Entry point to the converter system.

io.vertx.ext.web.Cookie

Represents an HTTP Cookie.

All cookies must have a name and a value and can optionally have other fields set such as path, domain, etc.

(Derived from io.netty.handler.codec.http.Cookie)

io.vertx.rxjava.ext.web.Cookie

Represents an HTTP Cookie.

All cookies must have a name and a value and can optionally have other fields set such as path, domain, etc.

(Derived from io.netty.handler.codec.http.Cookie)

NOTE: This class has been automatically generated from the io.vertx.ext.web.Cookie non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.Cookie

Represents an HTTP Cookie.

All cookies must have a name and a value and can optionally have other fields set such as path, domain, etc.

(Derived from io.netty.handler.codec.http.Cookie)

NOTE: This class has been automatically generated from the io.vertx.ext.web.Cookie non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.handler.CookieHandler

A handler which decodes cookies from the request, makes them available in the RoutingContext and writes them back in the response.

io.vertx.rxjava.ext.web.handler.CookieHandler

A handler which decodes cookies from the request, makes them available in the and writes them back in the response. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.CookieHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.CookieHandler

A handler which decodes cookies from the request, makes them available in the and writes them back in the response. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.CookieHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.consul.CoordinateConverter

Converter for io.vertx.ext.consul.Coordinate. NOTE: This class has been automatically generated from the io.vertx.ext.consul.Coordinate original class using Vert.x codegen.

io.vertx.ext.consul.CoordinateListConverter

Converter for io.vertx.ext.consul.CoordinateList. NOTE: This class has been automatically generated from the io.vertx.ext.consul.CoordinateList original class using Vert.x codegen.

io.vertx.kotlin.coroutines.CoroutineVerticle

A Verticle which run its start and stop methods in coroutine. You should subclass this class instead of AbstractVerticle to create any verticles that use vertx-kotlin-coroutine.

io.vertx.ext.web.handler.CorsHandler

A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.

io.vertx.rxjava.ext.web.handler.CorsHandler

A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.CorsHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.CorsHandler

A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.CorsHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.shareddata.Counter

An asynchronous counter that can be used to across the cluster to maintain a consistent count.

NOTE: This class has been automatically generated from the io.vertx.core.shareddata.Counter non RX-ified interface using Vert.x codegen.

groovy.runtime.metaclass.CustomMetaClassCreationHandle
io.vertx.ext.web.api.validation.CustomValidator

This interface is used to add custom synchronous functions inside validation process. You can add it in HTTPRequestValidationHandler.

io.vertx.rxjava.ext.web.api.validation.CustomValidator

This interface is used to add custom synchronous functions inside validation process. You can add it in io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler. NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.CustomValidator non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.validation.CustomValidator

This interface is used to add custom synchronous functions inside validation process. You can add it in io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler. NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.CustomValidator non RX-ified interface using Vert.x codegen.

io.vertx.ext.jdbc.spi.DataSourceProvider
io.vertx.rxjava.core.datagram.DatagramPacket

A received datagram packet (UDP) which contains the data and information about the sender of the data itself. NOTE: This class has been automatically generated from the io.vertx.core.datagram.DatagramPacket non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.datagram.DatagramPacket

A received datagram packet (UDP) which contains the data and information about the sender of the data itself. NOTE: This class has been automatically generated from the io.vertx.core.datagram.DatagramPacket non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.core.datagram.DatagramSocket

A datagram socket can be used to send io.vertx.rxjava.core.datagram.DatagramPacket's to remote datagram servers and receive io.vertx.rxjava.core.datagram.DatagramPackets .

Usually you use a datagram socket to send UDP over the wire. UDP is connection-less which means you are not connected to the remote peer in a persistent way. Because of this you have to supply the address and port of the remote peer when sending data.

You can send data to ipv4 or ipv6 addresses, which also include multicast addresses.

Please consult the documentation for more information on datagram sockets.

NOTE: This class has been automatically generated from the io.vertx.core.datagram.DatagramSocket non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.datagram.DatagramSocket

A datagram socket can be used to send io.vertx.reactivex.core.datagram.DatagramPacket's to remote datagram servers and receive io.vertx.reactivex.core.datagram.DatagramPackets .

Usually you use a datagram socket to send UDP over the wire. UDP is connection-less which means you are not connected to the remote peer in a persistent way. Because of this you have to supply the address and port of the remote peer when sending data.

You can send data to ipv4 or ipv6 addresses, which also include multicast addresses.

Please consult the documentation for more information on datagram sockets.

NOTE: This class has been automatically generated from the io.vertx.core.datagram.DatagramSocket non RX-ified interface using Vert.x codegen.

io.vertx.ext.consul.DcCoordinatesConverter

Converter for io.vertx.ext.consul.DcCoordinates. NOTE: This class has been automatically generated from the io.vertx.ext.consul.DcCoordinates original class using Vert.x codegen.

io.vertx.core.json.DecodeException

Instances of this Exception are thrown if failed to decode a JSON string, because of invalid JSON.

io.vertx.ext.stomp.DefaultAbortHandler

STOMP compliant actions executed when receiving a ABORT frame. This handler is thread safe.

io.vertx.ext.stomp.DefaultAckHandler

STOMP compliant actions executed when receiving a ACK frame. It removes the acknowledges messages from the list of messages waiting for acknowledgment. If the ACK frame specifies a transaction id, the acknowledgment is delayed until the transaction commit. This handler is thread safe.

io.vertx.ext.stomp.DefaultBeginHandler

STOMP compliant actions executed when receiving a BEGIN frame. This handler is thread safe.

io.vertx.core.spi.launcher.DefaultCommand

Default implementation of Command using annotation to define itself. It is highly recommended to extend this class when implementing a command. It defines two hidden Options to create system properties (-Dkey=value) and a way to configure the current working directory.

io.vertx.core.spi.launcher.DefaultCommandFactory

Default implementation of CommandFactory. This implementation defines the CLI from the given Command implementation (by reading the annotation). Then, Command instance are created by calling an empty constructor on the given Command implementation.

io.vertx.ext.stomp.DefaultCommitHandler

STOMP compliant actions executed when receiving a COMMIT frame. All frames that are part of the transactions are processed (ACK/NACK and SEND frames). If the COMMIT frame defines a receipt, the RECEIPT frame is sent once all frames have been replayed. This handler is thread safe.

io.vertx.ext.stomp.DefaultConnectHandler

STOMP compliant actions executed when receiving a CONNECT frame. It may also be called when receiving a STOMP frame depending on the io.vertx.ext.stomp.StompServerHandler configuration. This handler manages the STOMP version negotiation and authentication (if enabled). Once all the checks have been passed, the CONNECTED frame is sent to the client. This handler is thread safe.

io.vertx.ext.stomp.DefaultNackHandler

STOMP compliant actions executed when receiving a NACK sf.frame(). It removes the acknowledges messages from the list of messages waiting for acknowledgment and trigger an StompServerHandler#onNack(Subscription, List) calls. If the NACK frame specifies a transaction id, the acknowledgment is delayed until the transaction commit. This handler is thread safe.

io.vertx.ext.stomp.DefaultSendHandler

STOMP compliant actions executed when receiving a SEND sf.frame(). If the SEND frame specifies a transaction, the message delivery is postponed until the transaction commit. The handler computes the MESSAGE frame from the SEND sf.frame(). It computes a message-id and ack id if needed. If requested the RECEIPT frame is sent once the MESSAGE frame has been sent to all matching subscriptions. If the SEND frame requires an acknowledgment, the message-id is added to the list of messages waiting for acknowledgment. This handler is thread safe.

io.vertx.ext.stomp.DefaultSubscribeHandler

STOMP compliant actions executed when receiving a SUBSCRIBE frame. This handler is thread safe.

io.vertx.ext.stomp.DefaultUnsubscribeHandler

STOMP compliant actions executed when receiving a UNSUBSCRIBE frame. This handler is thread safe.

io.vertx.core.cli.annotations.DefaultValue

Annotation to set a default value to an option.

io.vertx.core.cli.annotations.Description

Annotation used to write the option or command documentation.

io.vertx.ext.stomp.Destination

Represents a STOMP destination. Depending on the implementation, the message delivery is different. Queue are sending message to only one subscribers, while topics are broadcasting the message to all subscribers. Implementations must be thread-safe.

io.vertx.rxjava.ext.stomp.Destination

Represents a STOMP destination. Depending on the implementation, the message delivery is different. Queue are sending message to only one subscribers, while topics are broadcasting the message to all subscribers. Implementations must be thread-safe. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.Destination non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.stomp.Destination

Represents a STOMP destination. Depending on the implementation, the message delivery is different. Queue are sending message to only one subscribers, while topics are broadcasting the message to all subscribers. Implementations must be thread-safe. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.Destination non RX-ified interface using Vert.x codegen.

io.vertx.ext.stomp.DestinationFactory

Interface implemented to customize the destination creation.

io.vertx.rxjava.ext.stomp.DestinationFactory

Interface implemented to customize the destination creation. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.DestinationFactory non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.stomp.DestinationFactory

Interface implemented to customize the destination creation. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.DestinationFactory non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.handler.DigestAuthHandler

An auth handler that provides HTTP Basic Authentication support.

io.vertx.rxjava.ext.web.handler.DigestAuthHandler

An auth handler that provides HTTP Basic Authentication support. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.DigestAuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.DigestAuthHandler

An auth handler that provides HTTP Basic Authentication support. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.DigestAuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.core.dns.DnsClient

Provides a way to asynchronously lookup information from DNS servers.

Please consult the documentation for more information on DNS clients.

io.vertx.rxjava.core.dns.DnsClient

Provides a way to asynchronously lookup information from DNS servers.

Please consult the documentation for more information on DNS clients.

NOTE: This class has been automatically generated from the io.vertx.core.dns.DnsClient non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.dns.DnsClient

Provides a way to asynchronously lookup information from DNS servers.

Please consult the documentation for more information on DNS clients.

NOTE: This class has been automatically generated from the io.vertx.core.dns.DnsClient non RX-ified interface using Vert.x codegen.

io.vertx.core.dns.DnsClientOptions

Configuration options for Vert.x DNS client.

io.vertx.core.dns.DnsClientOptionsConverter

Converter for io.vertx.core.dns.DnsClientOptions. NOTE: This class has been automatically generated from the io.vertx.core.dns.DnsClientOptions original class using Vert.x codegen.

io.vertx.core.dns.DnsException

Exception which is used to notify the io.vertx.core.AsyncResult if the DNS query returns a DnsResponseCode which indicates and error.

io.vertx.core.dns.DnsResponseCode

Represents the possible response codes a server may send after receiving a query. A response code of 0 indicates no error.

io.vertx.servicediscovery.docker.DockerLinksServiceImporter

A discovery bridge analyzing environment variables to detect Docker links. It imports found links as services in the discovery infrastructure. As they are mapped from environment variable the set of imported service does not change after the initialization.

io.vertx.ext.auth.oauth2.providers.DropboxAuth

Simplified factory to create an OAuth2Auth for Dropbox.

io.vertx.rxjava.ext.auth.oauth2.providers.DropboxAuth

Simplified factory to create an for Dropbox. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.DropboxAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.DropboxAuth

Simplified factory to create an for Dropbox. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.DropboxAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.sockjs.proxy.Dummy

This class is just there to enable the javadoc generation.

io.vertx.ext.shell.command.base.Echo
io.vertx.ext.mail.mailencoder.EmailAddress

represent a mail address with an email address part and an optional full name e.g. user@example.com user@example.com (This User) Another User <other@example.net>

the constructor will validate the address catching format errors like excess spaces, newlines the test is not very strict, for example an IDN address will be considered valid, even though SMTP doesn't work with that yet

io.vertx.core.json.EncodeException
io.vertx.ext.web.handler.ErrorHandler

A pretty error handler for rendering error pages.

io.vertx.rxjava.ext.web.handler.ErrorHandler

A pretty error handler for rendering error pages. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.ErrorHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.ErrorHandler

A pretty error handler for rendering error pages. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.ErrorHandler non RX-ified interface using Vert.x codegen.

io.vertx.core.eventbus.EventBus

A Vert.x event-bus is a light-weight distributed messaging system which allows different parts of your application, or different applications and services to communicate with each in a loosely coupled way.

An event-bus supports publish-subscribe messaging, point-to-point messaging and request-response messaging.

Message delivery is best-effort and messages can be lost if failure of all or part of the event bus occurs.

Please refer to the documentation for more information on the event bus.

io.vertx.rxjava.core.eventbus.EventBus

A Vert.x event-bus is a light-weight distributed messaging system which allows different parts of your application, or different applications and services to communicate with each in a loosely coupled way.

An event-bus supports publish-subscribe messaging, point-to-point messaging and request-response messaging.

Message delivery is best-effort and messages can be lost if failure of all or part of the event bus occurs.

Please refer to the documentation for more information on the event bus.

NOTE: This class has been automatically generated from the io.vertx.core.eventbus.EventBus non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.eventbus.EventBus

A Vert.x event-bus is a light-weight distributed messaging system which allows different parts of your application, or different applications and services to communicate with each in a loosely coupled way.

An event-bus supports publish-subscribe messaging, point-to-point messaging and request-response messaging.

Message delivery is best-effort and messages can be lost if failure of all or part of the event bus occurs.

Please refer to the documentation for more information on the event bus.

NOTE: This class has been automatically generated from the io.vertx.core.eventbus.EventBus non RX-ified interface using Vert.x codegen.

io.vertx.ext.unit.collect.EventBusCollector

The event bus collector listen to events on the Vert.x event bus and translate them into reports.

io.vertx.rxjava.ext.unit.collect.EventBusCollector

The event bus collector listen to events on the Vert.x event bus and translate them into reports. NOTE: This class has been automatically generated from the io.vertx.ext.unit.collect.EventBusCollector non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.collect.EventBusCollector

The event bus collector listen to events on the Vert.x event bus and translate them into reports. NOTE: This class has been automatically generated from the io.vertx.ext.unit.collect.EventBusCollector non RX-ified interface using Vert.x codegen.

io.vertx.core.spi.metrics.EventBusMetrics

The event bus metrics SPI which Vert.x will use to call when each event occurs.

io.vertx.rxjava.servicediscovery.types.EventBusService

for event bus services (service proxies). Consumers receive a service proxy to use the service. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.EventBusService non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.servicediscovery.types.EventBusService

for event bus services (service proxies). Consumers receive a service proxy to use the service. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.EventBusService non RX-ified interface using Vert.x codegen.

io.vertx.ext.consul.EventConverter

Converter for io.vertx.ext.consul.Event. NOTE: This class has been automatically generated from the io.vertx.ext.consul.Event original class using Vert.x codegen.

io.vertx.ext.consul.EventListConverter

Converter for io.vertx.ext.consul.EventList. NOTE: This class has been automatically generated from the io.vertx.ext.consul.EventList original class using Vert.x codegen.

io.vertx.ext.consul.EventListOptionsConverter

Converter for io.vertx.ext.consul.EventListOptions. NOTE: This class has been automatically generated from the io.vertx.ext.consul.EventListOptions original class using Vert.x codegen.

io.vertx.ext.consul.EventOptionsConverter

Converter for io.vertx.ext.consul.EventOptions. NOTE: This class has been automatically generated from the io.vertx.ext.consul.EventOptions original class using Vert.x codegen.

example.Examples

Created by stream.

io.vertx.ext.auth.oauth2.providers.FacebookAuth

Simplified factory to create an OAuth2Auth for Facebook.

io.vertx.rxjava.ext.auth.oauth2.providers.FacebookAuth

Simplified factory to create an for Facebook. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.FacebookAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.FacebookAuth

Simplified factory to create an for Facebook. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.FacebookAuth non RX-ified interface using Vert.x codegen.

io.vertx.redis.op.FailoverOptions
io.vertx.ext.unit.report.Failure

A failure provides the details of a failure that happened during the execution of a test case. The failure can be:

  • an assertion failure: an assertion failed
  • an error failure: an expected error occured

io.vertx.rxjava.ext.unit.report.Failure

A failure provides the details of a failure that happened during the execution of a test case. The failure can be:

  • an assertion failure: an assertion failed
  • an error failure: an expected error occured
NOTE: This class has been automatically generated from the io.vertx.ext.unit.report.Failure non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.report.Failure

A failure provides the details of a failure that happened during the execution of a test case. The failure can be:

  • an assertion failure: an assertion failed
  • an error failure: an expected error occured
NOTE: This class has been automatically generated from the io.vertx.ext.unit.report.Failure non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.handler.FaviconHandler

A handler that serves favicons.

If no file system path is specified it will attempt to serve a resource called `favicon.ico` from the classpath.

io.vertx.rxjava.ext.web.handler.FaviconHandler

A handler that serves favicons.

If no file system path is specified it will attempt to serve a resource called `favicon.ico` from the classpath.

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.FaviconHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.FaviconHandler

A handler that serves favicons.

If no file system path is specified it will attempt to serve a resource called `favicon.ico` from the classpath.

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.FaviconHandler non RX-ified interface using Vert.x codegen.

io.vertx.core.file.FileProps

Represents properties of a file on the file system.

io.vertx.rxjava.core.file.FileProps

Represents properties of a file on the file system.

NOTE: This class has been automatically generated from the io.vertx.core.file.FileProps non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.file.FileProps

Represents properties of a file on the file system.

NOTE: This class has been automatically generated from the io.vertx.core.file.FileProps non RX-ified interface using Vert.x codegen.

io.vertx.config.spi.utils.FileSet

Utility class to manage file set selected using a pattern.

io.vertx.core.file.FileSystem

Contains a broad set of operations for manipulating files on the file system.

A (potential) blocking and non blocking version of each operation is provided.

The non blocking versions take a handler which is called when the operation completes or an error occurs.

The blocking versions are named xxxBlocking and return the results, or throw exceptions directly. In many cases, depending on the operating system and file system some of the potentially blocking operations can return quickly, which is why we provide them, but it's highly recommended that you test how long they take to return in your particular application before using them on an event loop.

Please consult the documentation for more information on file system support.

io.vertx.rxjava.core.file.FileSystem

Contains a broad set of operations for manipulating files on the file system.

A (potential) blocking and non blocking version of each operation is provided.

The non blocking versions take a handler which is called when the operation completes or an error occurs.

The blocking versions are named xxxBlocking and return the results, or throw exceptions directly. In many cases, depending on the operating system and file system some of the potentially blocking operations can return quickly, which is why we provide them, but it's highly recommended that you test how long they take to return in your particular application before using them on an event loop.

Please consult the documentation for more information on file system support.

NOTE: This class has been automatically generated from the io.vertx.core.file.FileSystem non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.file.FileSystem

Contains a broad set of operations for manipulating files on the file system.

A (potential) blocking and non blocking version of each operation is provided.

The non blocking versions take a handler which is called when the operation completes or an error occurs.

The blocking versions are named xxxBlocking and return the results, or throw exceptions directly. In many cases, depending on the operating system and file system some of the potentially blocking operations can return quickly, which is why we provide them, but it's highly recommended that you test how long they take to return in your particular application before using them on an event loop.

Please consult the documentation for more information on file system support.

NOTE: This class has been automatically generated from the io.vertx.core.file.FileSystem non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.command.base.FileSystemCd
io.vertx.core.file.FileSystemException

Exception thrown by the FileSystem class

io.vertx.ext.shell.command.base.FileSystemLs
io.vertx.reactivex.core.file.FileSystemProps

Represents properties of the file system. NOTE: This class has been automatically generated from the io.vertx.core.file.FileSystemProps non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.command.base.FileSystemPwd
io.vertx.ext.web.FileUpload

Represents a file-upload from an HTTP multipart form submission.

io.vertx.rxjava.ext.web.FileUpload

Represents a file-upload from an HTTP multipart form submission.

NOTE: This class has been automatically generated from the io.vertx.ext.web.FileUpload non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.FileUpload

Represents a file-upload from an HTTP multipart form submission.

NOTE: This class has been automatically generated from the io.vertx.ext.web.FileUpload non RX-ified interface using Vert.x codegen.

io.vertx.ext.mongo.FindOptionsConverter

Converter for io.vertx.ext.mongo.FindOptions. NOTE: This class has been automatically generated from the io.vertx.ext.mongo.FindOptions original class using Vert.x codegen.

io.vertx.reactivex.core.FlowableHelper
io.vertx.reactivex.FlowableHelper
io.vertx.reactivex.core.json.FlowableUnmarshaller

An operator to unmarshall json to pojos.

io.vertx.ext.web.handler.FormLoginHandler

Handler that handles login from a form on a custom login page.

Used in conjunction with the RedirectAuthHandler.

io.vertx.rxjava.ext.web.handler.FormLoginHandler

Handler that handles login from a form on a custom login page.

Used in conjunction with the io.vertx.rxjava.ext.web.handler.RedirectAuthHandler.

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.FormLoginHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.FormLoginHandler

Handler that handles login from a form on a custom login page.

Used in conjunction with the io.vertx.reactivex.ext.web.handler.RedirectAuthHandler.

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.FormLoginHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.oauth2.providers.FoursquareAuth

Simplified factory to create an OAuth2Auth for Foursquare.

io.vertx.rxjava.ext.auth.oauth2.providers.FoursquareAuth

Simplified factory to create an for Foursquare. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.FoursquareAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.FoursquareAuth

Simplified factory to create an for Foursquare. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.FoursquareAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.stomp.FrameConverter

Converter for io.vertx.ext.stomp.Frame. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.Frame original class using Vert.x codegen.

io.vertx.ext.stomp.Frames

Utility methods to build common Frames. It defines a non-STOMP frame (PING) that is used for heartbeats. When such frame is written on the wire it is just the 0 byte. This class is thread-safe.

io.vertx.rxjava.ext.stomp.Frames

Utility methods to build common io.vertx.ext.stomp.Frames. It defines a non-STOMP frame (PING) that is used for heartbeats. When such frame is written on the wire it is just the 0 byte. This class is thread-safe. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.Frames non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.stomp.Frames

Utility methods to build common io.vertx.ext.stomp.Frames. It defines a non-STOMP frame (PING) that is used for heartbeats. When such frame is written on the wire it is just the 0 byte. This class is thread-safe. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.Frames non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.templ.FreeMarkerTemplateEngine

A template engine that uses the FreeMarker library.

io.vertx.rxjava.ext.web.templ.FreeMarkerTemplateEngine

A template engine that uses the FreeMarker library. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.FreeMarkerTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.templ.FreeMarkerTemplateEngine

A template engine that uses the FreeMarker library. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.FreeMarkerTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.core.cli.converters.FromBasedConverter

This 'default' converter tries to create objects using a static 'from' method taking a single String argument. This converter is particularly convenient for builders.

io.vertx.core.cli.converters.FromStringBasedConverter

This 'default' converter tries to create objects using a static 'from' method taking a single String argument. This converter is particularly convenient for converters themselves.

io.vertx.core.Future (extensions in package io.vertx.kotlin.coroutines)
io.vertx.rxjava.core.Future

Represents the result of an action that may, or may not, have occurred yet.

NOTE: This class has been automatically generated from the io.vertx.core.Future non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.Future

Represents the result of an action that may, or may not, have occurred yet.

NOTE: This class has been automatically generated from the io.vertx.core.Future non RX-ified interface using Vert.x codegen.

io.vertx.core.spi.FutureFactory
io.vertx.redis.op.GeoUnit

GeoUnit represents a geo spatial unit it covers both the metric and imperial systems.

io.vertx.config.git.GitConfigStore
io.vertx.config.git.GitConfigStoreFactory
io.vertx.ext.auth.oauth2.providers.GithubAuth

Simplified factory to create an OAuth2Auth for Github.

io.vertx.rxjava.ext.auth.oauth2.providers.GithubAuth

Simplified factory to create an for Github. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.GithubAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.GithubAuth

Simplified factory to create an for Github. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.GithubAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.oauth2.providers.GoogleAuth

Simplified factory to create an io.vertx.ext.auth.oauth2.OAuth2Auth for Google.

io.vertx.rxjava.ext.auth.oauth2.providers.GoogleAuth

Simplified factory to create an io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth for Google. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.GoogleAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.GoogleAuth

Simplified factory to create an io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth for Google. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.GoogleAuth non RX-ified interface using Vert.x codegen.

io.vertx.lang.groovy.GroovyDocGenerator
io.vertx.lang.groovy.GroovyVerticleFactory

Placeholder

io.vertx.grpc.GrpcBidiExchange
io.vertx.grpc.GrpcReadStream
io.vertx.grpc.GrpcUniExchange
io.vertx.grpc.GrpcWriteStream
io.vertx.ext.web.api.contract.HTTPOperationRequestValidationHandler

Base interface for HTTP request validation with API specification

io.vertx.rxjava.ext.web.api.contract.HTTPOperationRequestValidationHandler

Base interface for HTTP request validation with API specification NOTE: This class has been automatically generated from the io.vertx.ext.web.api.contract.HTTPOperationRequestValidationHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.contract.HTTPOperationRequestValidationHandler

Base interface for HTTP request validation with API specification NOTE: This class has been automatically generated from the io.vertx.ext.web.api.contract.HTTPOperationRequestValidationHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.api.validation.HTTPRequestValidationHandler

An interface for add HTTP Request validation. This class can validate parameters inside query, path, headers an body (watch below) You can assign multiple body type at the same time(for example a JSON schema together with a XML schema). This interface support:

  • application/x-www-form-urlencoded
  • multipart/form-data
  • application/xml
  • application/json
Also you can add a form parameter for validation without care about content type of your request. For form parameters this interface support both "multipart/form-data" and "application/x-www-form-urlencoded" This interface allow extra parameters in the request, so it doesn't care if in a request there's a parameter without a specified validation rule If a parameter is flagged as an array, it will be validated also if the size of array is 1 element

io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler

An interface for add HTTP Request validation. This class can validate parameters inside query, path, headers an body (watch below) You can assign multiple body type at the same time(for example a JSON schema together with a XML schema). This interface support:

  • application/x-www-form-urlencoded
  • multipart/form-data
  • application/xml
  • application/json
Also you can add a form parameter for validation without care about content type of your request. For form parameters this interface support both "multipart/form-data" and "application/x-www-form-urlencoded" This interface allow extra parameters in the request, so it doesn't care if in a request there's a parameter without a specified validation rule If a parameter is flagged as an array, it will be validated also if the size of array is 1 element NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.HTTPRequestValidationHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler

An interface for add HTTP Request validation. This class can validate parameters inside query, path, headers an body (watch below) You can assign multiple body type at the same time(for example a JSON schema together with a XML schema). This interface support:

  • application/x-www-form-urlencoded
  • multipart/form-data
  • application/xml
  • application/json
Also you can add a form parameter for validation without care about content type of your request. For form parameters this interface support both "multipart/form-data" and "application/x-www-form-urlencoded" This interface allow extra parameters in the request, so it doesn't care if in a request there's a parameter without a specified validation rule If a parameter is flagged as an array, it will be validated also if the size of array is 1 element NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.HTTPRequestValidationHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.templ.HandlebarsTemplateEngine

A template engine that uses the Handlebars library.

io.vertx.rxjava.ext.web.templ.HandlebarsTemplateEngine

A template engine that uses the Handlebars library. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.HandlebarsTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.templ.HandlebarsTemplateEngine

A template engine that uses the Handlebars library. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.HandlebarsTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.rx.java.HandlerAdapter
io.vertx.ext.sync.HandlerReceiverAdaptor

Represents an object that is both a handler of a particular event and also a receiver of that event.

In other words it converts an asynchronous stream of events into a synchronous receiver of events

io.vertx.ext.auth.mongo.HashStrategy

Determines how the hashing is computed in the implementation You can implement this to provide a different hashing strategy to the default.

io.vertx.rxjava.ext.auth.mongo.HashStrategy

Determines how the hashing is computed in the implementation You can implement this to provide a different hashing strategy to the default. NOTE: This class has been automatically generated from the io.vertx.ext.auth.mongo.HashStrategy non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.mongo.HashStrategy

Determines how the hashing is computed in the implementation You can implement this to provide a different hashing strategy to the default. NOTE: This class has been automatically generated from the io.vertx.ext.auth.mongo.HashStrategy non RX-ified interface using Vert.x codegen.

io.vertx.spi.cluster.hazelcast.HazelcastClusterManager

A cluster manager that uses Hazelcast

io.vertx.ext.stomp.utils.Headers

An implementation of HashMap to store STOMP frame headers. This implementations offer fluent methods to ease the construction of the headers.

io.vertx.ext.healthchecks.HealthCheckHandler

A Vert.x Web handler on which you register health check procedure. It computes the outcome status (`UP` or `DOWN`) . When the handler process a HTTP request, it computes the global outcome and build a HTTP response as follows:

  • 204 - status is `UP` but no procedures installed (no payload)
  • 200 - status is `UP`, the payload contains the result of the installed procedures
  • 503 - status is `DOWN`, the payload contains the result of the installed procedures
  • 500 - status is `DOWN`, the payload contains the result of the installed procedures, one of the procedure has failed

io.vertx.rxjava.ext.healthchecks.HealthCheckHandler

A Vert.x Web handler on which you register health check procedure. It computes the outcome status (`UP` or `DOWN`) . When the handler process a HTTP request, it computes the global outcome and build a HTTP response as follows:

  • 204 - status is `UP` but no procedures installed (no payload)
  • 200 - status is `UP`, the payload contains the result of the installed procedures
  • 503 - status is `DOWN`, the payload contains the result of the installed procedures
  • 500 - status is `DOWN`, the payload contains the result of the installed procedures, one of the procedure has failed
NOTE: This class has been automatically generated from the io.vertx.ext.healthchecks.HealthCheckHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.healthchecks.HealthCheckHandler

A Vert.x Web handler on which you register health check procedure. It computes the outcome status (`UP` or `DOWN`) . When the handler process a HTTP request, it computes the global outcome and build a HTTP response as follows:

  • 204 - status is `UP` but no procedures installed (no payload)
  • 200 - status is `UP`, the payload contains the result of the installed procedures
  • 503 - status is `DOWN`, the payload contains the result of the installed procedures
  • 500 - status is `DOWN`, the payload contains the result of the installed procedures, one of the procedure has failed
NOTE: This class has been automatically generated from the io.vertx.ext.healthchecks.HealthCheckHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.healthchecks.HealthChecks
io.vertx.rxjava.ext.healthchecks.HealthChecks

NOTE: This class has been automatically generated from the io.vertx.ext.healthchecks.HealthChecks non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.healthchecks.HealthChecks

NOTE: This class has been automatically generated from the io.vertx.ext.healthchecks.HealthChecks non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.command.base.Help
io.vertx.lang.rxjava.Helper
io.vertx.lang.reactivex.Helper
io.vertx.lang.ruby.Helper
io.vertx.ext.auth.oauth2.providers.HerokuAuth

Simplified factory to create an OAuth2Auth for Heroku.

io.vertx.rxjava.ext.auth.oauth2.providers.HerokuAuth

Simplified factory to create an for Heroku. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.HerokuAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.HerokuAuth

Simplified factory to create an for Heroku. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.HerokuAuth non RX-ified interface using Vert.x codegen.

io.vertx.core.cli.annotations.Hidden

Annotates a io.vertx.core.cli.CLI and/or its Option setters to hide it from the help message.

io.vertx.config.hocon.HoconProcessor

A processor using Typesafe Conf to read Hocon files. It also support JSON and Properties. More details on Hocon and the used library on the Hocon documentation page.

io.vertx.ext.auth.htdigest.HtdigestAuth

An extension of AuthProvider which is using .htdigest file as store

io.vertx.rxjava.ext.auth.htdigest.HtdigestAuth

An extension of AuthProvider which is using .htdigest file as store NOTE: This class has been automatically generated from the io.vertx.ext.auth.htdigest.HtdigestAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.htdigest.HtdigestAuth

An extension of AuthProvider which is using .htdigest file as store NOTE: This class has been automatically generated from the io.vertx.ext.auth.htdigest.HtdigestAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.HttpClient

An asynchronous HTTP client.

It allows you to make requests to HTTP servers, and a single client can make requests to any server.

It also allows you to open WebSockets to servers.

The client can also pool HTTP connections.

For pooling to occur, keep-alive must be true on the io.vertx.core.http.HttpClientOptions (default is true). In this case connections will be pooled and re-used if there are pending HTTP requests waiting to get a connection, otherwise they will be closed.

This gives the benefits of keep alive when the client is loaded but means we don't keep connections hanging around unnecessarily when there would be no benefits anyway.

The client also supports pipe-lining of requests. Pipe-lining means another request is sent on the same connection before the response from the preceding one has returned. Pipe-lining is not appropriate for all requests.

To enable pipe-lining, it must be enabled on the io.vertx.core.http.HttpClientOptions (default is false).

When pipe-lining is enabled the connection will be automatically closed when all in-flight responses have returned and there are no outstanding pending requests to write.

The client is designed to be reused between requests.

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpClient non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.HttpClientRequest

Represents a client-side HTTP request.

Instances are created by an io.vertx.reactivex.core.http.HttpClient instance, via one of the methods corresponding to the specific HTTP methods, or the generic request methods. On creation the request will not have been written to the wire.

Once a request has been obtained, headers can be set on it, and data can be written to its body if required. Once you are ready to send the request, one of the io.vertx.reactivex.core.http.HttpClientRequest#end methods should be called.

Nothing is actually sent until the request has been internally assigned an HTTP connection.

The io.vertx.reactivex.core.http.HttpClient instance will return an instance of this class immediately, even if there are no HTTP connections available in the pool. Any requests sent before a connection is assigned will be queued internally and actually sent when an HTTP connection becomes available from the pool.

The headers of the request are queued for writing either when the io.vertx.reactivex.core.http.HttpClientRequest#end method is called, or, when the first part of the body is written, whichever occurs first.

This class supports both chunked and non-chunked HTTP.

It implements io.vertx.reactivex.core.streams.WriteStream so it can be used with io.vertx.reactivex.core.streams.Pump to pump data with flow control.

An example of using this class is as follows:

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpClientRequest non RX-ified interface using Vert.x codegen.

io.vertx.core.http.HttpClientResponse

Represents a client-side HTTP response.

Vert.x provides you with one of these via the handler that was provided when creating the io.vertx.core.http.HttpClientRequest or that was set on the io.vertx.core.http.HttpClientRequest instance.

It implements io.vertx.core.streams.ReadStream so it can be used with io.vertx.core.streams.Pump to pump data with flow control.

io.vertx.reactivex.core.http.HttpClientResponse

Represents a client-side HTTP response.

Vert.x provides you with one of these via the handler that was provided when creating the io.vertx.reactivex.core.http.HttpClientRequest or that was set on the io.vertx.reactivex.core.http.HttpClientRequest instance.

It implements io.vertx.reactivex.core.streams.ReadStream so it can be used with io.vertx.reactivex.core.streams.Pump to pump data with flow control.

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpClientResponse non RX-ified interface using Vert.x codegen.

io.vertx.core.http.HttpConnection

Represents an HTTP connection. HTTP/1.x connection provides an limited implementation, the following methods are implemented:

io.vertx.rxjava.core.http.HttpConnection

Represents an HTTP connection. HTTP/1.x connection provides an limited implementation, the following methods are implemented:

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpConnection non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.HttpConnection

Represents an HTTP connection. HTTP/1.x connection provides an limited implementation, the following methods are implemented:

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpConnection non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.servicediscovery.types.HttpEndpoint

for HTTP endpoint (REST api). Consumers receive a HTTP client configured with the host and port of the endpoint. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.HttpEndpoint non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.servicediscovery.types.HttpEndpoint

for HTTP endpoint (REST api). Consumers receive a HTTP client configured with the host and port of the endpoint. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.HttpEndpoint non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.HttpFrame

An HTTP/2 frame. NOTE: This class has been automatically generated from the io.vertx.core.http.HttpFrame non RX-ified interface using Vert.x codegen.

io.vertx.core.http.HttpHeaders

Contains often used Header names.

It also contains a utility method to create optimized CharSequence which can be used as header name and value.

io.vertx.servicediscovery.types.HttpLocationConverter

Converter for io.vertx.servicediscovery.types.HttpLocation. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.HttpLocation original class using Vert.x codegen.

io.vertx.ext.web.client.HttpRequest

A client-side HTTP request.

Instances are created by an WebClient instance, via one of the methods corresponding to the specific HTTP methods such as WebClient#get, etc...

The request shall be configured prior sending, the request is immutable and when a mutator method is called, a new request is returned allowing to expose the request in a public API and apply further customization.

After the request has been configured, the methods

can be called. The sendXXX methods perform the actual request, they can be called multiple times to perform the same HTTP request at different points in time.

The handler is called back with

  • an HttpResponse instance when the HTTP response has been received
  • a failure when the HTTP request failed (like a connection error) or when the HTTP response could not be obtained (like connection or unmarshalling errors)

Most of the time, this client will buffer the HTTP response fully unless a specific BodyCodec is used such as BodyCodec#create(Handler).

io.vertx.rxjava.ext.web.client.HttpResponse

An HTTP response.

The usual HTTP response attributes are available:

The body of the response is returned by io.vertx.rxjava.ext.web.client.HttpResponse#body decoded as the format specified by the that built the response.

Keep in mind that using this HttpResponse impose to fully buffer the response body and should be used for payload that can fit in memory.

NOTE: This class has been automatically generated from the io.vertx.ext.web.client.HttpResponse non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.client.HttpResponse

An HTTP response.

The usual HTTP response attributes are available:

The body of the response is returned by io.vertx.reactivex.ext.web.client.HttpResponse#body decoded as the format specified by the that built the response.

Keep in mind that using this HttpResponse impose to fully buffer the response body and should be used for payload that can fit in memory.

NOTE: This class has been automatically generated from the io.vertx.ext.web.client.HttpResponse non RX-ified interface using Vert.x codegen.

io.vertx.ext.httpservicefactory.HttpSecureServiceFactory
io.vertx.reactivex.core.http.HttpServer

An HTTP and WebSockets server.

You receive HTTP requests by providing a io.vertx.reactivex.core.http.HttpServer#requestHandler. As requests arrive on the server the handler will be called with the requests.

You receive WebSockets by providing a io.vertx.reactivex.core.http.HttpServer#websocketHandler. As WebSocket connections arrive on the server, the WebSocket is passed to the handler.

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpServer non RX-ified interface using Vert.x codegen.

io.vertx.core.http.HttpServerFileUpload

Represents an file upload from an HTML FORM.

io.vertx.rxjava.core.http.HttpServerFileUpload

Represents an file upload from an HTML FORM. NOTE: This class has been automatically generated from the io.vertx.core.http.HttpServerFileUpload non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.HttpServerFileUpload

Represents an file upload from an HTML FORM. NOTE: This class has been automatically generated from the io.vertx.core.http.HttpServerFileUpload non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.HttpServerRequest

Represents a server-side HTTP request.

Instances are created for each request and passed to the user via a handler.

Each instance of this class is associated with a corresponding io.vertx.reactivex.core.http.HttpServerResponse instance via io.vertx.reactivex.core.http.HttpServerRequest#response.

It implements io.vertx.reactivex.core.streams.ReadStream so it can be used with io.vertx.reactivex.core.streams.Pump to pump data with flow control.

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpServerRequest non RX-ified interface using Vert.x codegen.

io.vertx.core.http.HttpServerResponse

Represents a server-side HTTP response.

An instance of this is created and associated to every instance of HttpServerRequest that.

It allows the developer to control the HTTP response that is sent back to the client for a particular HTTP request.

It contains methods that allow HTTP headers and trailers to be set, and for a body to be written out to the response.

It also allows files to be streamed by the kernel directly from disk to the outgoing HTTP connection, bypassing user space altogether (where supported by the underlying operating system). This is a very efficient way of serving files from the server since buffers do not have to be read one by one from the file and written to the outgoing socket.

It implements io.vertx.core.streams.WriteStream so it can be used with io.vertx.core.streams.Pump to pump data with flow control.

io.vertx.rxjava.core.http.HttpServerResponse

Represents a server-side HTTP response.

An instance of this is created and associated to every instance of io.vertx.rxjava.core.http.HttpServerRequest that.

It allows the developer to control the HTTP response that is sent back to the client for a particular HTTP request.

It contains methods that allow HTTP headers and trailers to be set, and for a body to be written out to the response.

It also allows files to be streamed by the kernel directly from disk to the outgoing HTTP connection, bypassing user space altogether (where supported by the underlying operating system). This is a very efficient way of serving files from the server since buffers do not have to be read one by one from the file and written to the outgoing socket.

It implements io.vertx.rxjava.core.streams.WriteStream so it can be used with io.vertx.rxjava.core.streams.Pump to pump data with flow control.

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpServerResponse non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.HttpServerResponse

Represents a server-side HTTP response.

An instance of this is created and associated to every instance of io.vertx.reactivex.core.http.HttpServerRequest that.

It allows the developer to control the HTTP response that is sent back to the client for a particular HTTP request.

It contains methods that allow HTTP headers and trailers to be set, and for a body to be written out to the response.

It also allows files to be streamed by the kernel directly from disk to the outgoing HTTP connection, bypassing user space altogether (where supported by the underlying operating system). This is a very efficient way of serving files from the server since buffers do not have to be read one by one from the file and written to the outgoing socket.

It implements io.vertx.reactivex.core.streams.WriteStream so it can be used with io.vertx.reactivex.core.streams.Pump to pump data with flow control.

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpServerResponse non RX-ified interface using Vert.x codegen.

io.vertx.ext.httpservicefactory.HttpServiceFactory
io.vertx.ext.shell.term.HttpTermOptionsConverter

Converter for io.vertx.ext.shell.term.HttpTermOptions. NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.HttpTermOptions original class using Vert.x codegen.

io.vertx.rxjava.circuitbreaker.HystrixMetricHandler

A Vert.x web handler to expose the circuit breaker to the Hystrix dasbboard. The handler listens to the circuit breaker notifications sent on the event bus. NOTE: This class has been automatically generated from the io.vertx.circuitbreaker.HystrixMetricHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.circuitbreaker.HystrixMetricHandler

A Vert.x web handler to expose the circuit breaker to the Hystrix dasbboard. The handler listens to the circuit breaker notifications sent on the event bus. NOTE: This class has been automatically generated from the io.vertx.circuitbreaker.HystrixMetricHandler non RX-ified interface using Vert.x codegen.

io.vertx.spi.cluster.ignite.IgniteClusterManager

Apache Ignite based cluster manager.

io.vertx.camel.InboundMapping

Represents a mapping between a Camel endpoint address and a Vert.x address on the event bus.

io.vertx.ext.cluster.infinispan.InfinispanAsyncMap

Extensions to the generic AsyncMap.

io.vertx.rxjava.ext.cluster.infinispan.InfinispanAsyncMap

Extensions to the generic . NOTE: This class has been automatically generated from the io.vertx.ext.cluster.infinispan.InfinispanAsyncMap non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.cluster.infinispan.InfinispanAsyncMap

Extensions to the generic . NOTE: This class has been automatically generated from the io.vertx.ext.cluster.infinispan.InfinispanAsyncMap non RX-ified interface using Vert.x codegen.

io.vertx.ext.cluster.infinispan.InfinispanClusterManager
io.vertx.micrometer.backends.InfluxDbBackendRegistry
io.vertx.redis.op.InsertOptions
io.vertx.ext.auth.oauth2.providers.InstagramAuth

Simplified factory to create an OAuth2Auth for Instagram.

io.vertx.rxjava.ext.auth.oauth2.providers.InstagramAuth

Simplified factory to create an for Instagram. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.InstagramAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.InstagramAuth

Simplified factory to create an for Instagram. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.InstagramAuth non RX-ified interface using Vert.x codegen.

io.vertx.core.cli.InvalidValueException

Exception thrown when an option or an argument receives an invalid value.

io.vertx.ext.auth.jdbc.JDBCAuth

Factory interface for creating io.vertx.ext.auth.AuthProvider 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.rxjava.ext.auth.jdbc.JDBCAuth

Factory interface for creating io.vertx.rxjava.ext.auth.AuthProvider 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. NOTE: This class has been automatically generated from the io.vertx.ext.auth.jdbc.JDBCAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.jdbc.JDBCAuth

Factory interface for creating io.vertx.reactivex.ext.auth.AuthProvider 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. NOTE: This class has been automatically generated from the io.vertx.ext.auth.jdbc.JDBCAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.jdbc.JDBCAuthOptionsConverter

Converter for io.vertx.ext.auth.jdbc.JDBCAuthOptions. NOTE: This class has been automatically generated from the io.vertx.ext.auth.jdbc.JDBCAuthOptions original class using Vert.x codegen.

io.vertx.rxjava.servicediscovery.types.JDBCDataSource

NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.JDBCDataSource non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.servicediscovery.types.JDBCDataSource

NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.JDBCDataSource non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.jdbc.JDBCHashStrategy

Determines how the hashing is computed in the implementation You can implement this to provide a different hashing strategy to the default.

io.vertx.rxjava.ext.auth.jdbc.JDBCHashStrategy

Determines how the hashing is computed in the implementation You can implement this to provide a different hashing strategy to the default. NOTE: This class has been automatically generated from the io.vertx.ext.auth.jdbc.JDBCHashStrategy non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.jdbc.JDBCHashStrategy

Determines how the hashing is computed in the implementation You can implement this to provide a different hashing strategy to the default. NOTE: This class has been automatically generated from the io.vertx.ext.auth.jdbc.JDBCHashStrategy non RX-ified interface using Vert.x codegen.

io.vertx.lang.ruby.JRubyDocGenerator
io.vertx.lang.ruby.JRubyVerticle
io.vertx.lang.ruby.JRubyVerticleFactory
io.vertx.core.logging.JULLogDelegate

A io.vertx.core.spi.logging.LogDelegate which delegates to java.util.logging

io.vertx.core.logging.JULLogDelegateFactory

A io.vertx.core.spi.logging.LogDelegateFactory which creates JULLogDelegate instances.

io.vertx.ext.jwt.JWK

JWK https://tools.ietf.org/html/rfc7517 In a nutshell a JWK is a Key(Pair) encoded as JSON. This implementation follows the spec with some limitations: * Supported algorithms are: "RS256", "RS384", "RS512", "ES256", "ES384", "ES512", "HS256", "HS384", "HS512" The rationale for this choice is to support the required algorithms for JWT. The constructor takes a single JWK (the the KeySet) or a PEM encoded pair (used by Google and useful for importing standard PEM files from OpenSSL). * Certificate chains (x5c) only allow a single element chain, certificate urls and fingerprints are not considered.

io.vertx.ext.jwt.JWT

JWT and JWS implementation draft-ietf-oauth-json-web-token-32.

io.vertx.ext.auth.jwt.JWTAuth

Factory interface for creating JWT based io.vertx.ext.auth.AuthProvider instances.

io.vertx.rxjava.ext.auth.jwt.JWTAuth

Factory interface for creating JWT based io.vertx.rxjava.ext.auth.AuthProvider instances. NOTE: This class has been automatically generated from the io.vertx.ext.auth.jwt.JWTAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.jwt.JWTAuth

Factory interface for creating JWT based io.vertx.reactivex.ext.auth.AuthProvider instances. NOTE: This class has been automatically generated from the io.vertx.ext.auth.jwt.JWTAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.handler.JWTAuthHandler

An auth handler that provides JWT Authentication support.

io.vertx.rxjava.ext.web.handler.JWTAuthHandler

An auth handler that provides JWT Authentication support. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.JWTAuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.JWTAuthHandler

An auth handler that provides JWT Authentication support. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.JWTAuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.jwt.JWTAuthOptionsConverter

Converter for io.vertx.ext.auth.jwt.JWTAuthOptions. NOTE: This class has been automatically generated from the io.vertx.ext.auth.jwt.JWTAuthOptions original class using Vert.x codegen.

io.vertx.ext.auth.jwt.JWTKeyStoreOptionsConverter

Converter for io.vertx.ext.auth.jwt.JWTKeyStoreOptions. NOTE: This class has been automatically generated from the io.vertx.ext.auth.jwt.JWTKeyStoreOptions original class using Vert.x codegen.

io.vertx.ext.jwt.JWTOptionsConverter

Converter for io.vertx.ext.jwt.JWTOptions. NOTE: This class has been automatically generated from the io.vertx.ext.jwt.JWTOptions original class using Vert.x codegen.

io.vertx.ext.web.templ.JadeTemplateEngine

A template engine that uses Jade.

io.vertx.rxjava.ext.web.templ.JadeTemplateEngine

A template engine that uses Jade. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.JadeTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.templ.JadeTemplateEngine

A template engine that uses Jade. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.JadeTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.core.net.JksOptionsConverter

Converter for io.vertx.core.net.JksOptions. NOTE: This class has been automatically generated from the io.vertx.core.net.JksOptions original class using Vert.x codegen.

io.vertx.micrometer.backends.JmxBackendRegistry
io.vertx.ext.dropwizard.reporters.JmxReporter
io.vertx.kotlin.core.json.Json
io.vertx.core.json.JsonArray (extensions in package io.vertx.kotlin.core.json)
io.vertx.kafka.client.serialization.JsonArrayDeserializer

Kafka deserializer for raw bytes in a buffer

io.vertx.kafka.client.serialization.JsonArraySerializer

Kafka serializer for raw bytes in a buffer

io.vertx.core.parsetools.JsonEvent

A JSON event emited by the JsonParser.

io.vertx.rxjava.core.parsetools.JsonEvent

A JSON event emited by the io.vertx.rxjava.core.parsetools.JsonParser. NOTE: This class has been automatically generated from the io.vertx.core.parsetools.JsonEvent non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.parsetools.JsonEvent

A JSON event emited by the io.vertx.reactivex.core.parsetools.JsonParser. NOTE: This class has been automatically generated from the io.vertx.core.parsetools.JsonEvent non RX-ified interface using Vert.x codegen.

io.vertx.core.json.JsonObject (extensions in package io.vertx.kotlin.core.json)
io.vertx.kafka.client.serialization.JsonObjectDeserializer

Kafka deserializer for raw bytes in a buffer

io.vertx.config.spi.utils.JsonObjectHelper

Some utility methods to create json objects from a set of String.

io.vertx.kafka.client.serialization.JsonObjectSerializer

Kafka serializer for raw bytes in a buffer

io.vertx.core.parsetools.JsonParser

A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json element fully. This parser is convenient for parsing large json structures. The parser also parses concatenated json streams or line delimited json streams. The parser can also parse entire object or array when it is convenient, for instance a very large array of small objects can be parsed efficiently by handling array start/end and object events. Whenever the parser fails to parse or process the stream, the #exceptionHandler(Handler) is called with the cause of the failure and the current handling stops. After such event, the parser should not handle data anymore.

io.vertx.rxjava.core.parsetools.JsonParser

A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json element fully. This parser is convenient for parsing large json structures. The parser also parses concatenated json streams or line delimited json streams. The parser can also parse entire object or array when it is convenient, for instance a very large array of small objects can be parsed efficiently by handling array start/end and object events. Whenever the parser fails to parse or process the stream, the io.vertx.rxjava.core.parsetools.JsonParser#exceptionHandler is called with the cause of the failure and the current handling stops. After such event, the parser should not handle data anymore. NOTE: This class has been automatically generated from the io.vertx.core.parsetools.JsonParser non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.parsetools.JsonParser

A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json element fully. This parser is convenient for parsing large json structures. The parser also parses concatenated json streams or line delimited json streams. The parser can also parse entire object or array when it is convenient, for instance a very large array of small objects can be parsed efficiently by handling array start/end and object events. Whenever the parser fails to parse or process the stream, the io.vertx.reactivex.core.parsetools.JsonParser#exceptionHandler is called with the cause of the failure and the current handling stops. After such event, the parser should not handle data anymore. NOTE: This class has been automatically generated from the io.vertx.core.parsetools.JsonParser non RX-ified interface using Vert.x codegen.

io.vertx.redis.utils.JsonUtils
io.vertx.kafka.client.consumer.KafkaConsumer

Vert.x Kafka consumer.

You receive Kafka records by providing a KafkaConsumer#handler(Handler). As messages arrive the handler will be called with the records.

The #pause() and #resume() provides global control over reading the records from the consumer.

The #pause(Set) and #resume(Set) provides finer grained control over reading records for specific Topic/Partition, these are Kafka's specific operations.

io.vertx.rxjava.kafka.client.consumer.KafkaConsumer

Vert.x Kafka consumer.

You receive Kafka records by providing a io.vertx.rxjava.kafka.client.consumer.KafkaConsumer#handler. As messages arrive the handler will be called with the records.

The io.vertx.rxjava.kafka.client.consumer.KafkaConsumer#pause and io.vertx.rxjava.kafka.client.consumer.KafkaConsumer#resume provides global control over reading the records from the consumer.

The io.vertx.rxjava.kafka.client.consumer.KafkaConsumer#pause and io.vertx.rxjava.kafka.client.consumer.KafkaConsumer#resume provides finer grained control over reading records for specific Topic/Partition, these are Kafka's specific operations.

NOTE: This class has been automatically generated from the io.vertx.kafka.client.consumer.KafkaConsumer non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.kafka.client.consumer.KafkaConsumer

Vert.x Kafka consumer.

You receive Kafka records by providing a io.vertx.reactivex.kafka.client.consumer.KafkaConsumer#handler. As messages arrive the handler will be called with the records.

The io.vertx.reactivex.kafka.client.consumer.KafkaConsumer#pause and io.vertx.reactivex.kafka.client.consumer.KafkaConsumer#resume provides global control over reading the records from the consumer.

The io.vertx.reactivex.kafka.client.consumer.KafkaConsumer#pause and io.vertx.reactivex.kafka.client.consumer.KafkaConsumer#resume provides finer grained control over reading records for specific Topic/Partition, these are Kafka's specific operations.

NOTE: This class has been automatically generated from the io.vertx.kafka.client.consumer.KafkaConsumer non RX-ified interface using Vert.x codegen.

io.vertx.kafka.client.consumer.KafkaConsumerRecords

Vert.x Kafka consumer records

io.vertx.rxjava.kafka.client.consumer.KafkaConsumerRecords

Vert.x Kafka consumer records NOTE: This class has been automatically generated from the io.vertx.kafka.client.consumer.KafkaConsumerRecords non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.kafka.client.consumer.KafkaConsumerRecords

Vert.x Kafka consumer records NOTE: This class has been automatically generated from the io.vertx.kafka.client.consumer.KafkaConsumerRecords non RX-ified interface using Vert.x codegen.

io.vertx.kafka.client.producer.KafkaProducer

Vert.x Kafka producer.

The #write(Object) provides global control over writing a record.

io.vertx.rxjava.kafka.client.producer.KafkaProducer

Vert.x Kafka producer.

The provides global control over writing a record.

NOTE: This class has been automatically generated from the io.vertx.kafka.client.producer.KafkaProducer non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.kafka.client.producer.KafkaProducer

Vert.x Kafka producer.

The provides global control over writing a record.

NOTE: This class has been automatically generated from the io.vertx.kafka.client.producer.KafkaProducer non RX-ified interface using Vert.x codegen.

io.vertx.kafka.client.consumer.KafkaReadStream

A ReadStream for consuming Kafka ConsumerRecord.

The #pause() and #resume() provides global control over reading the records from the consumer.

The #pause(Set) and #resume(Set) provides finer grained control over reading records for specific Topic/Partition, these are Kafka's specific operations.

io.vertx.ext.auth.KeyStoreOptionsConverter

Converter for io.vertx.ext.auth.KeyStoreOptions. NOTE: This class has been automatically generated from the io.vertx.ext.auth.KeyStoreOptions original class using Vert.x codegen.

io.vertx.ext.consul.KeyValueConverter

Converter for io.vertx.ext.consul.KeyValue. NOTE: This class has been automatically generated from the io.vertx.ext.consul.KeyValue original class using Vert.x codegen.

io.vertx.ext.consul.KeyValueListConverter

Converter for io.vertx.ext.consul.KeyValueList. NOTE: This class has been automatically generated from the io.vertx.ext.consul.KeyValueList original class using Vert.x codegen.

io.vertx.ext.auth.oauth2.providers.KeycloakAuth

Simplified factory to create an OAuth2Auth for Keycloak.

io.vertx.rxjava.ext.auth.oauth2.providers.KeycloakAuth

Simplified factory to create an for Keycloak. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.KeycloakAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.KeycloakAuth

Simplified factory to create an for Keycloak. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.KeycloakAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.oauth2.KeycloakHelper

Helper class for processing Keycloak principal.

io.vertx.rxjava.ext.auth.oauth2.KeycloakHelper

Helper class for processing Keycloak principal. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.KeycloakHelper non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.KeycloakHelper

Helper class for processing Keycloak principal. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.KeycloakHelper non RX-ified interface using Vert.x codegen.

io.vertx.lang.kotlin.KotlinCompilerHelper

Author: Sergey Mashkov

io.vertx.lang.kotlin.KotlinScriptVerticleFactory
io.vertx.lang.kotlin.KotlinScriptVerticleTemplate
io.vertx.lang.kotlin.KotlinVerticleFactory
io.vertx.servicediscovery.kubernetes.KubernetesServiceImporter

A discovery bridge listening for kubernetes services and publishing them in the Vert.x service discovery. This bridge only supports the importation of services from kubernetes in vert.x (and not the opposite).

The bridge is configured using:

* the oauth token (using the content of `/var/run/secrets/kubernetes.io/serviceaccount/token` by default) * the namespace in which the service are searched (defaults to `default`).

Be aware that the application must have access to Kubernetes and must be able to read the chosen namespace.

Record are created from Kubernetes Service. The service type is deduced from the `service.type` label. If not set, the service is imported as `unknown`. Only `http-endpoint` are supported for now.

io.vertx.config.kubernetes.KubernetesUtils

Utility methods for Kubernetes.

io.vertx.ext.auth.shiro.LDAPProviderConstants

Configuration keys used when configuring a Shiro LDAP auth realm

io.vertx.core.Launcher

A main() class that can be used to create Vert.x instance and deploy a verticle, or run a bare Vert.x instance. This class is used by the vertx command line utility to deploy verticles from the command line. It is extensible as "commands" can be added using the io.vertx.core.spi.launcher.CommandFactory SPI. E.g. vertx run myverticle.js vertx my-command ... It can also be used as the main class of an executable jar so you can run verticles directly with: java -jar myapp.jar

io.vertx.ext.auth.oauth2.providers.LinkedInAuth

Simplified factory to create an OAuth2Auth for LinkedIn.

io.vertx.rxjava.ext.auth.oauth2.providers.LinkedInAuth

Simplified factory to create an for LinkedIn. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.LinkedInAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.LinkedInAuth

Simplified factory to create an for LinkedIn. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.LinkedInAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.oauth2.providers.LiveAuth

Simplified factory to create an OAuth2Auth for live.com Services.

io.vertx.rxjava.ext.auth.oauth2.providers.LiveAuth

Simplified factory to create an for live.com Services. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.LiveAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.LiveAuth

Simplified factory to create an for live.com Services. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.LiveAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.shareddata.LocalMap

Local maps can be used to share data safely in a single Vert.x instance.

The map only allows immutable keys and values in the map, OR certain mutable objects such as io.vertx.reactivex.core.buffer.Buffer instances which will be copied when they are added to the map.

This ensures there is no shared access to mutable state from different threads (e.g. different event loops) in the Vert.x instance, and means you don't have to protect access to that state using synchronization or locks.

Your own objects can be marked as immutable by implementing the io.vertx.reactivex.core.shareddata.Shareable interface. Since the version 3.4, this class extends the interface. However some methods are only accessible in Java.

NOTE: This class has been automatically generated from the io.vertx.core.shareddata.LocalMap non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.command.base.LocalMapGet
io.vertx.ext.shell.command.base.LocalMapPut
io.vertx.ext.shell.command.base.LocalMapRm
io.vertx.ext.web.sstore.LocalSessionStore

A session store which is only available on a single node.

Can be used when sticky sessions are being used.

io.vertx.rxjava.ext.web.sstore.LocalSessionStore

A session store which is only available on a single node.

Can be used when sticky sessions are being used.

NOTE: This class has been automatically generated from the io.vertx.ext.web.sstore.LocalSessionStore non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.sstore.LocalSessionStore

A session store which is only available on a single node.

Can be used when sticky sessions are being used.

NOTE: This class has been automatically generated from the io.vertx.ext.web.sstore.LocalSessionStore non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.ext.web.Locale

NOTE: This class has been automatically generated from the io.vertx.ext.web.Locale non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.Locale

NOTE: This class has been automatically generated from the io.vertx.ext.web.Locale non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.shareddata.Lock

An asynchronous exclusive lock which can be obtained from any node in the cluster.

When the lock is obtained, no-one else in the cluster can obtain the lock with the same name until the lock is released.

NOTE: This class has been automatically generated from the io.vertx.core.shareddata.Lock non RX-ified interface using Vert.x codegen.

io.vertx.core.logging.Log4j2LogDelegate

A LogDelegate which delegates to Apache Log4j 2

io.vertx.core.logging.Log4j2LogDelegateFactory

A LogDelegateFactory which creates Log4j2LogDelegate instances.

io.vertx.core.logging.Log4jLogDelegate

A io.vertx.core.spi.logging.LogDelegate which delegates to Apache Log4j

io.vertx.core.logging.Log4jLogDelegateFactory

A io.vertx.core.spi.logging.LogDelegateFactory which creates Log4jLogDelegate instances.

io.vertx.core.spi.logging.LogDelegate

I represent operations that are delegated to underlying logging frameworks.

io.vertx.core.spi.logging.LogDelegateFactory

I am responsible for creating LogDelegate instances.

io.vertx.core.logging.Logger

This class allows us to isolate all our logging dependencies in one place. It also allows us to have zero runtime 3rd party logging jar dependencies, since we default to JUL by default.

By default logging will occur using JUL (Java-Util-Logging). The logging configuration file (logging.properties) used by JUL will taken from the default logging.properties in the JDK installation if no java.util.logging.config.file system property is set.

If you would prefer to use Log4J or SLF4J instead of JUL then you can set a system property called vertx.logger-delegate-factory-class-name to the class name of the delegate for your logging system. For Log4J the value is io.vertx.core.logging.Log4jLogDelegateFactory, for SLF4J the value is io.vertx.core.logging.SLF4JLogDelegateFactory. You will need to ensure whatever jar files required by your favourite log framework are on your classpath.

Keep in mind that logging backends use different formats to represent replaceable tokens in parameterized messages. As a consequence, if you rely on parameterized logging methods, you won't be able to switch backends without changing your code.

io.vertx.core.logging.LoggerFactory
io.vertx.ext.web.handler.LoggerFormat

The possible out of the box formats.

io.vertx.ext.web.handler.LoggerHandler

A handler which logs request information to the Vert.x logger.

io.vertx.rxjava.ext.web.handler.LoggerHandler

A handler which logs request information to the Vert.x logger. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.LoggerHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.LoggerHandler

A handler which logs request information to the Vert.x logger. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.LoggerHandler non RX-ified interface using Vert.x codegen.

io.vertx.config.vault.client.Lookup

Represents Lookup result

io.vertx.ext.web.templ.MVELTemplateEngine

A template engine that uses the Handlebars library.

io.vertx.rxjava.ext.web.templ.MVELTemplateEngine

A template engine that uses the Handlebars library. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.MVELTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.templ.MVELTemplateEngine

A template engine that uses the Handlebars library. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.MVELTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.ext.mail.mailencoder.MailEncoder

create MIME mail messages from a MailMessage object

example usage is:

MailMessage = new MailMessage(); (set elements and attachments ...) String message = new MailEncoder(mailmessage).encode();  

usually you are not using this class directly, rather it will be used by sendMail() in MailClientImpl

io.vertx.ext.mail.MailService
io.vertx.rxjava.ext.mail.MailService

NOTE: This class has been automatically generated from the io.vertx.ext.mail.MailService non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.mail.MailService

NOTE: This class has been automatically generated from the io.vertx.ext.mail.MailService non RX-ified interface using Vert.x codegen.

io.vertx.ext.mail.MailServiceVerticle

event bus verticle that supports sending mails via a MailService instance running on another machine via the event bus

when the standard config can be used (send mails via localhost:25 without login) it is possible to deploy the verticle with the id

vertx run client:io.vertx.mail-client
and send mails from other machines via the event bus with the client address vertx.mail (on the other hand, if you can send mails via localhost:25, you do not really need the event bus)

io.vertx.ext.mail.MailServiceVertxEBProxy
io.vertx.ext.mail.MailServiceVertxProxyHandler
io.vertx.ext.auth.oauth2.providers.MailchimpAuth

Simplified factory to create an OAuth2Auth for Mailchimp.

io.vertx.rxjava.ext.auth.oauth2.providers.MailchimpAuth

Simplified factory to create an for Mailchimp. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.MailchimpAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.MailchimpAuth

Simplified factory to create an for Mailchimp. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.MailchimpAuth non RX-ified interface using Vert.x codegen.

io.vertx.micrometer.Match

A match for a value.

io.vertx.micrometer.MatchType

The type of match.

io.vertx.maven.MavenCoords
io.vertx.maven.MavenVerticleFactory
io.vertx.reactivex.core.MaybeHelper
io.vertx.reactivex.MaybeHelper
io.vertx.reactivex.core.json.MaybeUnmarshaller

An operator to unmarshall json to pojos.

io.vertx.rxjava.core.metrics.Measured

NOTE: This class has been automatically generated from the io.vertx.core.metrics.Measured non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.metrics.Measured

NOTE: This class has been automatically generated from the io.vertx.core.metrics.Measured non RX-ified interface using Vert.x codegen.

io.vertx.core.eventbus.Message

Represents a message that is received from the event bus in a handler.

Messages have a #body, which can be null, and also #headers, which can be empty.

If the message was sent specifying a reply handler it will also have a #replyAddress. In that case the message can be replied to using that reply address, or, more simply by just using #reply.

If you want to notify the sender that processing failed, then #fail can be called.

io.vertx.rxjava.core.eventbus.Message

Represents a message that is received from the event bus in a handler.

Messages have a io.vertx.rxjava.core.eventbus.Message#body, which can be null, and also io.vertx.rxjava.core.eventbus.Message#headers, which can be empty.

If the message was sent specifying a reply handler it will also have a io.vertx.rxjava.core.eventbus.Message#replyAddress. In that case the message can be replied to using that reply address, or, more simply by just using io.vertx.rxjava.core.eventbus.Message#reply.

If you want to notify the sender that processing failed, then io.vertx.rxjava.core.eventbus.Message#fail can be called.

NOTE: This class has been automatically generated from the io.vertx.core.eventbus.Message non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.eventbus.Message

Represents a message that is received from the event bus in a handler.

Messages have a io.vertx.reactivex.core.eventbus.Message#body, which can be null, and also io.vertx.reactivex.core.eventbus.Message#headers, which can be empty.

If the message was sent specifying a reply handler it will also have a io.vertx.reactivex.core.eventbus.Message#replyAddress. In that case the message can be replied to using that reply address, or, more simply by just using io.vertx.reactivex.core.eventbus.Message#reply.

If you want to notify the sender that processing failed, then io.vertx.reactivex.core.eventbus.Message#fail can be called.

NOTE: This class has been automatically generated from the io.vertx.core.eventbus.Message non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.eventbus.MessageConsumer

An event bus consumer object representing a stream of message to an io.vertx.reactivex.core.eventbus.EventBus address that can be read from.

The io.vertx.reactivex.core.eventbus.EventBus#consumer or io.vertx.reactivex.core.eventbus.EventBus#localConsumer creates a new consumer, the returned consumer is not yet registered against the event bus. Registration is effective after the io.vertx.reactivex.core.eventbus.MessageConsumer#handler method is invoked.

The consumer is unregistered from the event bus using the io.vertx.reactivex.core.eventbus.MessageConsumer#unregister method or by calling the io.vertx.reactivex.core.eventbus.MessageConsumer#handler with a null value..

NOTE: This class has been automatically generated from the io.vertx.core.eventbus.MessageConsumer non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.eventbus.MessageProducer

Represents a stream of message that can be written to.

NOTE: This class has been automatically generated from the io.vertx.core.eventbus.MessageProducer non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.servicediscovery.types.MessageSource

Service type for data producer. Providers are publishing data to a specific event bus address. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.MessageSource non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.servicediscovery.types.MessageSource

Service type for data producer. Providers are publishing data to a specific event bus address. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.MessageSource non RX-ified interface using Vert.x codegen.

io.vertx.codegen.extra.MethodWithGenericFunctionArg
io.vertx.codegen.extra.MethodWithReadStreamArg
io.vertx.ext.hawkular.MetricTagsMatchConverter

Converter for io.vertx.ext.hawkular.MetricTagsMatch. NOTE: This class has been automatically generated from the io.vertx.ext.hawkular.MetricTagsMatch original class using Vert.x codegen.

io.vertx.micrometer.MetricsDomain

Metric domains with their associated prefixes.

io.vertx.core.spi.metrics.MetricsProvider

Metrics provider is the base SPI used by metrics implementations to retrieve a io.vertx.core.spi.metrics.Metrics object. It is meant to be implemented by io.vertx.core.metrics.Measured implementations but not exposed directly.

io.vertx.micrometer.MetricsService

The metrics service mainly allows to return a snapshot of measured objects. This service is derived and adapted from MetricsService in the vertx-dropwizard-metrics module.

io.vertx.ext.dropwizard.MetricsService

The metrics service mainly allows to return a snapshot of measured objects.

io.vertx.rxjava.micrometer.MetricsService

The metrics service mainly allows to return a snapshot of measured objects. This service is derived and adapted from MetricsService in the vertx-dropwizard-metrics module. NOTE: This class has been automatically generated from the io.vertx.micrometer.MetricsService non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.ext.dropwizard.MetricsService

The metrics service mainly allows to return a snapshot of measured objects. NOTE: This class has been automatically generated from the io.vertx.ext.dropwizard.MetricsService non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.micrometer.MetricsService

The metrics service mainly allows to return a snapshot of measured objects. This service is derived and adapted from MetricsService in the vertx-dropwizard-metrics module. NOTE: This class has been automatically generated from the io.vertx.micrometer.MetricsService non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.dropwizard.MetricsService

The metrics service mainly allows to return a snapshot of measured objects. NOTE: This class has been automatically generated from the io.vertx.ext.dropwizard.MetricsService non RX-ified interface using Vert.x codegen.

io.vertx.micrometer.MicrometerMetricsOptions

Vert.x micrometer configuration. It is required to set either influxDbOptions, prometheusOptions or jmxMetricsOptions] in order to actually report metrics. Joel Takvorian

io.vertx.micrometer.MicrometerMetricsOptionsConverter

Converter for io.vertx.micrometer.MicrometerMetricsOptions. NOTE: This class has been automatically generated from the io.vertx.micrometer.MicrometerMetricsOptions original class using Vert.x codegen.

io.vertx.core.cli.MissingOptionException

Exception thrown when an option was expected and was not found on the command line.

io.vertx.core.cli.MissingValueException

Exception thrown when an option requiring a value does not receive the value, or when a mandatory argument does not receive a value.

io.vertx.ext.auth.mongo.MongoAuth

An extension of AuthProvider which is using MongoClient as store

io.vertx.rxjava.ext.auth.mongo.MongoAuth

An extension of AuthProvider which is using as store NOTE: This class has been automatically generated from the io.vertx.ext.auth.mongo.MongoAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.mongo.MongoAuth

An extension of AuthProvider which is using as store NOTE: This class has been automatically generated from the io.vertx.ext.auth.mongo.MongoAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.mongo.MongoAuthOptionsConverter

Converter for io.vertx.ext.auth.mongo.MongoAuthOptions. NOTE: This class has been automatically generated from the io.vertx.ext.auth.mongo.MongoAuthOptions original class using Vert.x codegen.

io.vertx.rxjava.servicediscovery.types.MongoDataSource

NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.MongoDataSource non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.servicediscovery.types.MongoDataSource

NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.MongoDataSource non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.mqtt.MqttClient

An MQTT client NOTE: This class has been automatically generated from the io.vertx.mqtt.MqttClient non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.mqtt.MqttClient

An MQTT client NOTE: This class has been automatically generated from the io.vertx.mqtt.MqttClient non RX-ified interface using Vert.x codegen.

io.vertx.mqtt.MqttClientOptionsConverter

Converter for io.vertx.mqtt.MqttClientOptions. NOTE: This class has been automatically generated from the io.vertx.mqtt.MqttClientOptions original class using Vert.x codegen.

io.vertx.rxjava.mqtt.messages.MqttConnAckMessage

Represents an MQTT CONNACK message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttConnAckMessage non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.mqtt.messages.MqttConnAckMessage

Represents an MQTT CONNACK message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttConnAckMessage non RX-ified interface using Vert.x codegen.

io.vertx.mqtt.MqttConnectionException

Exception raised when a connection request fails at MQTT level

io.vertx.rxjava.mqtt.MqttEndpoint

Represents an MQTT endpoint for point-to-point communication with the remote MQTT client NOTE: This class has been automatically generated from the io.vertx.mqtt.MqttEndpoint non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.mqtt.MqttEndpoint

Represents an MQTT endpoint for point-to-point communication with the remote MQTT client NOTE: This class has been automatically generated from the io.vertx.mqtt.MqttEndpoint non RX-ified interface using Vert.x codegen.

io.vertx.mqtt.MqttException

Exception raised with a specific reason code

io.vertx.rxjava.mqtt.messages.MqttMessage

Represent the interface for each MQTT message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttMessage non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.mqtt.messages.MqttMessage

Represent the interface for each MQTT message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttMessage non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.mqtt.messages.MqttPublishMessage

Represents an MQTT PUBLISH message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttPublishMessage non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.mqtt.messages.MqttPublishMessage

Represents an MQTT PUBLISH message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttPublishMessage non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.mqtt.MqttServer

An MQTT server

You can accept incoming MQTT connection requests providing a io.vertx.rxjava.mqtt.MqttServer#endpointHandler. As the requests arrive, the handler will be called with an instance of io.vertx.rxjava.mqtt.MqttEndpoint in order to manage the communication with the remote MQTT client.

NOTE: This class has been automatically generated from the io.vertx.mqtt.MqttServer non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.mqtt.MqttServer

An MQTT server

You can accept incoming MQTT connection requests providing a io.vertx.reactivex.mqtt.MqttServer#endpointHandler. As the requests arrive, the handler will be called with an instance of io.vertx.reactivex.mqtt.MqttEndpoint in order to manage the communication with the remote MQTT client.

NOTE: This class has been automatically generated from the io.vertx.mqtt.MqttServer non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.mqtt.messages.MqttSubAckMessage

Represents an MQTT SUBACK message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttSubAckMessage non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.mqtt.messages.MqttSubAckMessage

Represents an MQTT SUBACK message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttSubAckMessage non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.mqtt.messages.MqttSubscribeMessage

Represents an MQTT SUBSCRIBE message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttSubscribeMessage non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.mqtt.messages.MqttSubscribeMessage

Represents an MQTT SUBSCRIBE message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttSubscribeMessage non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.mqtt.messages.MqttUnsubscribeMessage

Represents an MQTT UNSUBSCRIBE message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttUnsubscribeMessage non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.mqtt.messages.MqttUnsubscribeMessage

Represents an MQTT UNSUBSCRIBE message NOTE: This class has been automatically generated from the io.vertx.mqtt.messages.MqttUnsubscribeMessage non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.MultiMap

This class represents a MultiMap of String keys to a List of String values.

It's useful in Vert.x to represent things in Vert.x like HTTP headers and HTTP parameters which allow multiple values for keys.

NOTE: This class has been automatically generated from the io.vertx.core.MultiMap non RX-ified interface using Vert.x codegen.

io.vertx.core.dns.MxRecord

Represent a Mail-Exchange-Record (MX) which was resolved for a domain.

io.vertx.rxjava.core.dns.MxRecord

Represent a Mail-Exchange-Record (MX) which was resolved for a domain. NOTE: This class has been automatically generated from the io.vertx.core.dns.MxRecord non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.dns.MxRecord

Represent a Mail-Exchange-Record (MX) which was resolved for a domain. NOTE: This class has been automatically generated from the io.vertx.core.dns.MxRecord non RX-ified interface using Vert.x codegen.

io.vertx.ext.asyncsql.MySQLClient

Represents an asynchronous MySQL client

io.vertx.rxjava.ext.asyncsql.MySQLClient

Represents an asynchronous MySQL client NOTE: This class has been automatically generated from the io.vertx.ext.asyncsql.MySQLClient non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.asyncsql.MySQLClient

Represents an asynchronous MySQL client NOTE: This class has been automatically generated from the io.vertx.ext.asyncsql.MySQLClient non RX-ified interface using Vert.x codegen.

io.vertx.core.cli.annotations.Name

Defines the name of a CLI.

io.vertx.core.net.NetClient

A TCP client.

Multiple connections to different servers can be made using the same instance.

This client supports a configurable number of connection attempts and a configurable delay between attempts.

io.vertx.rxjava.core.net.NetClient

A TCP client.

Multiple connections to different servers can be made using the same instance.

This client supports a configurable number of connection attempts and a configurable delay between attempts.

NOTE: This class has been automatically generated from the io.vertx.core.net.NetClient non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.net.NetClient

A TCP client.

Multiple connections to different servers can be made using the same instance.

This client supports a configurable number of connection attempts and a configurable delay between attempts.

NOTE: This class has been automatically generated from the io.vertx.core.net.NetClient non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.command.base.NetCommandLs
io.vertx.core.net.NetServer

Represents a TCP server

io.vertx.rxjava.core.net.NetServer

Represents a TCP server NOTE: This class has been automatically generated from the io.vertx.core.net.NetServer non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.net.NetServer

Represents a TCP server NOTE: This class has been automatically generated from the io.vertx.core.net.NetServer non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.net.NetSocket

Represents a socket-like interface to a TCP connection on either the client or the server side.

Instances of this class are created on the client side by an io.vertx.reactivex.core.net.NetClient when a connection to a server is made, or on the server side by a io.vertx.reactivex.core.net.NetServer when a server accepts a connection.

It implements both and so it can be used with io.vertx.reactivex.core.streams.Pump to pump data with flow control.

NOTE: This class has been automatically generated from the io.vertx.core.net.NetSocket non RX-ified interface using Vert.x codegen.

io.vertx.ext.consul.NodeConverter

Converter for io.vertx.ext.consul.Node. NOTE: This class has been automatically generated from the io.vertx.ext.consul.Node original class using Vert.x codegen.

io.vertx.ext.consul.NodeListConverter

Converter for io.vertx.ext.consul.NodeList. NOTE: This class has been automatically generated from the io.vertx.ext.consul.NodeList original class using Vert.x codegen.

io.vertx.core.spi.cluster.NodeListener

A NodeListener is called when nodes join or leave the cluster

io.vertx.ext.consul.NodeQueryOptionsConverter

Converter for io.vertx.ext.consul.NodeQueryOptions. NOTE: This class has been automatically generated from the io.vertx.ext.consul.NodeQueryOptions original class using Vert.x codegen.

io.vertx.codegen.extra.NonConcreteWithToString
io.vertx.micrometer.backends.NoopBackendRegistry
io.vertx.ext.auth.oauth2.OAuth2Auth

Factory interface for creating OAuth2 based io.vertx.ext.auth.AuthProvider instances.

io.vertx.rxjava.ext.auth.oauth2.OAuth2Auth

Factory interface for creating OAuth2 based io.vertx.rxjava.ext.auth.AuthProvider instances. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.OAuth2Auth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.OAuth2Auth

Factory interface for creating OAuth2 based io.vertx.reactivex.ext.auth.AuthProvider instances. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.OAuth2Auth non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.handler.OAuth2AuthHandler

An auth handler that provides OAuth2 Authentication support. This handler is suitable for AuthCode flows.

io.vertx.rxjava.ext.web.handler.OAuth2AuthHandler

An auth handler that provides OAuth2 Authentication support. This handler is suitable for AuthCode flows. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.OAuth2AuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.OAuth2AuthHandler

An auth handler that provides OAuth2 Authentication support. This handler is suitable for AuthCode flows. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.OAuth2AuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.oauth2.OAuth2ClientOptionsConverter

Converter for io.vertx.ext.auth.oauth2.OAuth2ClientOptions. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.OAuth2ClientOptions original class using Vert.x codegen.

io.vertx.ext.auth.oauth2.OAuth2Response

A response from a fetch request. This class represents a secure response from a Oauth2 fetch call. A fetch is a simplified HTTP response from a protected resource.

io.vertx.rxjava.ext.auth.oauth2.OAuth2Response

A response from a fetch request. This class represents a secure response from a Oauth2 fetch call. A fetch is a simplified HTTP response from a protected resource. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.OAuth2Response non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.OAuth2Response

A response from a fetch request. This class represents a secure response from a Oauth2 fetch call. A fetch is a simplified HTTP response from a protected resource. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.OAuth2Response non RX-ified interface using Vert.x codegen.

io.vertx.redis.op.ObjectCmd
io.vertx.reactivex.core.ObservableHelper
io.vertx.reactivex.ObservableHelper
io.vertx.reactivex.core.json.ObservableUnmarshaller

An operator to unmarshall json to pojos.

io.vertx.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler
io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler

NOTE: This class has been automatically generated from the io.vertx.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler

NOTE: This class has been automatically generated from the io.vertx.ext.web.api.contract.openapi3.OpenAPI3RequestValidationHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.api.contract.openapi3.OpenAPI3RouterFactory

Interface for OpenAPI3RouterFactory. To add an handler, use OpenAPI3RouterFactory#addHandlerByOperationId(String, Handler), in this class is better than generic RouterFactory#addHandler(HttpMethod, String, Handler) If you want to use RouterFactory#addHandler(HttpMethod, String, Handler) remember that you have to pass path as declared in openapi specification Usage example:

OpenAPI3RouterFactory.createRouterFactoryFromFile(vertx, "src/resources/spec.yaml", asyncResult -> { if (!asyncResult.succeeded()) { // IO failure or spec invalid } else { OpenAPI3RouterFactory routerFactory = asyncResult.result(); routerFactory.addHandlerByOperationId("operation_id", routingContext -> { // Do something }, routingContext -> { // Do something with failure handler }); Router router = routerFactory.getRouter(); } });  

io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory

Interface for OpenAPI3RouterFactory. To add an handler, use io.vertx.rxjava.ext.web.api.contract.openapi3.OpenAPI3RouterFactory#addHandlerByOperationId, in this class is better than generic If you want to use remember that you have to pass path as declared in openapi specification Usage example:

OpenAPI3RouterFactory.createRouterFactoryFromFile(vertx, "src/resources/spec.yaml", asyncResult -> { if (!asyncResult.succeeded()) { // IO failure or spec invalid else { OpenAPI3RouterFactory routerFactory = asyncResult.result(); routerFactory.addHandlerByOperationId("operation_id", routingContext -> { // Do something }, routingContext -> { // Do something with failure handler }); Router router = routerFactory.getRouter(); } }); } 
NOTE: This class has been automatically generated from the io.vertx.ext.web.api.contract.openapi3.OpenAPI3RouterFactory non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory

Interface for OpenAPI3RouterFactory. To add an handler, use io.vertx.reactivex.ext.web.api.contract.openapi3.OpenAPI3RouterFactory#addHandlerByOperationId, in this class is better than generic If you want to use remember that you have to pass path as declared in openapi specification Usage example:

OpenAPI3RouterFactory.createRouterFactoryFromFile(vertx, "src/resources/spec.yaml", asyncResult -> { if (!asyncResult.succeeded()) { // IO failure or spec invalid else { OpenAPI3RouterFactory routerFactory = asyncResult.result(); routerFactory.addHandlerByOperationId("operation_id", routingContext -> { // Do something }, routingContext -> { // Do something with failure handler }); Router router = routerFactory.getRouter(); } }); } 
NOTE: This class has been automatically generated from the io.vertx.ext.web.api.contract.openapi3.OpenAPI3RouterFactory non RX-ified interface using Vert.x codegen.

io.vertx.core.cli.annotations.Option

Annotates a setter to be called with the value of a command line option. Setter have been preferred to field to allow validation. The cardinality of the option is detected from the single method parameter type: arrays, list and set can receive several values.

io.vertx.camel.OutboundMapping

Represents a mapping between a Vert.x event bus address and a Camel endpoint.

io.vertx.ext.httpservicefactory.PGPHelper
io.vertx.ext.auth.PRNG

Wrapper around secure random that periodically seeds the PRNG with new entropy. To avoid entropy exhaustion the entropy is only refreshed if the PRNG is used. This introduces a new variable which reduces the probability of cracking the random number generator.

io.vertx.ext.web.api.validation.ParameterLocation

ParameterLocation describe the location of parameter inside HTTP Request

io.vertx.ext.web.api.validation.ParameterType

ParameterType contains prebuilt type validators. To access to ParameterTypeValidator of every ParameterType, use ParameterType#validationMethod()

io.vertx.ext.web.api.validation.ParameterTypeValidator

Interface for declaration of method for validate a specific parameter type. If you want to implement your own type validator, you need only to implement ParameterTypeValidator#isValid(String):

io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator

Interface for declaration of method for validate a specific parameter type. If you want to implement your own type validator, you need only to implement io.vertx.rxjava.ext.web.api.validation.ParameterTypeValidator#isValid:

  • If parameter is valid, call to put value (maybe modified) inside RequestParameters. The validation flow will care about set parameter name
  • If parameter is invalid, throw a new ValidationException with message (io.vertx.rxjava.ext.web.api.validation.ValidationException) and/or with io.vertx.rxjava.ext.web.api.validation.ValidationException.ErrorType (). As for value, the validation flow will care about setting all other ValidationException fields
NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.ParameterTypeValidator non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator

Interface for declaration of method for validate a specific parameter type. If you want to implement your own type validator, you need only to implement io.vertx.reactivex.ext.web.api.validation.ParameterTypeValidator#isValid:

  • If parameter is valid, call to put value (maybe modified) inside RequestParameters. The validation flow will care about set parameter name
  • If parameter is invalid, throw a new ValidationException with message (io.vertx.reactivex.ext.web.api.validation.ValidationException) and/or with io.vertx.reactivex.ext.web.api.validation.ValidationException.ErrorType (). As for value, the validation flow will care about setting all other ValidationException fields
NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.ParameterTypeValidator non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.api.validation.ParameterValidationRule

This function is an inner wrapper for ParameterTypeValidator inside ValidationHandler parameter maps. Don't instantiate this class, if you want to add custom ParameterTypeValidator to a parameter use functions in HTTPRequestValidationHandler

io.vertx.rxjava.ext.web.api.validation.ParameterValidationRule

This function is an inner wrapper for ParameterTypeValidator inside ValidationHandler parameter maps. Don't instantiate this class, if you want to add custom ParameterTypeValidator to a parameter use functions in io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.ParameterValidationRule non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.validation.ParameterValidationRule

This function is an inner wrapper for ParameterTypeValidator inside ValidationHandler parameter maps. Don't instantiate this class, if you want to add custom ParameterTypeValidator to a parameter use functions in io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.ParameterValidationRule non RX-ified interface using Vert.x codegen.

io.vertx.core.cli.annotations.ParsedAsList

Annotates a setter to be called with the value of a command line option. The setter must also have been annotated with Option. When annotated with ParsedAsList, the option value is parsed as a list. The value is split and then each segment is trimmed.

io.vertx.ext.web.ParsedHeaderValue
io.vertx.rxjava.ext.web.ParsedHeaderValue
io.vertx.reactivex.ext.web.ParsedHeaderValue
io.vertx.ext.web.ParsedHeaderValues

A container with the request's headers that are meaningful enough to be parsed Contains:

  • Accept -> MIME header, parameters and sortable
  • Accept-Charset -> Parameters and sortable
  • Accept-Encoding -> Parameters and sortable
  • Accept-Language -> Parameters and sortable
  • Content-Type -> MIME header and parameters

io.vertx.rxjava.ext.web.ParsedHeaderValues

A container with the request's headers that are meaningful enough to be parsed Contains:

  • Accept -> MIME header, parameters and sortable
  • Accept-Charset -> Parameters and sortable
  • Accept-Encoding -> Parameters and sortable
  • Accept-Language -> Parameters and sortable
  • Content-Type -> MIME header and parameters
NOTE: This class has been automatically generated from the io.vertx.ext.web.ParsedHeaderValues non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.ParsedHeaderValues

A container with the request's headers that are meaningful enough to be parsed Contains:

  • Accept -> MIME header, parameters and sortable
  • Accept-Charset -> Parameters and sortable
  • Accept-Encoding -> Parameters and sortable
  • Accept-Language -> Parameters and sortable
  • Content-Type -> MIME header and parameters
NOTE: This class has been automatically generated from the io.vertx.ext.web.ParsedHeaderValues non RX-ified interface using Vert.x codegen.

io.vertx.kafka.client.common.PartitionInfoConverter

Converter for io.vertx.kafka.client.common.PartitionInfo. NOTE: This class has been automatically generated from the io.vertx.kafka.client.common.PartitionInfo original class using Vert.x codegen.

io.vertx.ext.web.templ.PebbleTemplateEngine

A template engine that uses the Pebble library.

io.vertx.rxjava.ext.web.templ.PebbleTemplateEngine

A template engine that uses the Pebble library. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.PebbleTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.templ.PebbleTemplateEngine

A template engine that uses the Pebble library. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.PebbleTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.ext.bridge.PermittedOptionsConverter

Converter for io.vertx.ext.bridge.PermittedOptions. NOTE: This class has been automatically generated from the io.vertx.ext.bridge.PermittedOptions original class using Vert.x codegen.

io.vertx.ext.asyncsql.PostgreSQLClient

Represents an PostgreSQL client

io.vertx.rxjava.ext.asyncsql.PostgreSQLClient

Represents an PostgreSQL client NOTE: This class has been automatically generated from the io.vertx.ext.asyncsql.PostgreSQLClient non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.asyncsql.PostgreSQLClient

Represents an PostgreSQL client NOTE: This class has been automatically generated from the io.vertx.ext.asyncsql.PostgreSQLClient non RX-ified interface using Vert.x codegen.

io.vertx.ext.consul.PreparedQueryExecuteOptionsConverter

Converter for io.vertx.ext.consul.PreparedQueryExecuteOptions. NOTE: This class has been automatically generated from the io.vertx.ext.consul.PreparedQueryExecuteOptions original class using Vert.x codegen.

io.vertx.ext.consul.PreparedQueryExecuteResponseConverter

Converter for io.vertx.ext.consul.PreparedQueryExecuteResponse. NOTE: This class has been automatically generated from the io.vertx.ext.consul.PreparedQueryExecuteResponse original class using Vert.x codegen.

io.vertx.ext.shell.system.Process

A process managed by the shell.

io.vertx.rxjava.ext.shell.system.Process

A process managed by the shell. NOTE: This class has been automatically generated from the io.vertx.ext.shell.system.Process non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.system.Process

A process managed by the shell. NOTE: This class has been automatically generated from the io.vertx.ext.shell.system.Process non RX-ified interface using Vert.x codegen.

io.vertx.config.spi.utils.Processors

A class to deal with configuration prcessors.

io.vertx.micrometer.backends.PrometheusBackendRegistry
io.vertx.ext.auth.shiro.PropertiesProviderConstants

Configuration keys used when configuring a Shiro properties auth realm

io.vertx.core.net.ProxyType

The type of a TCP proxy server.

io.vertx.ext.shell.term.Pty

A pseudo terminal used for controlling a Tty. This interface acts as a pseudo terminal master, #slave() returns the assocated slave pseudo terminal.

io.vertx.rxjava.ext.shell.term.Pty

A pseudo terminal used for controlling a io.vertx.rxjava.ext.shell.term.Tty. This interface acts as a pseudo terminal master, io.vertx.rxjava.ext.shell.term.Pty#slave returns the assocated slave pseudo terminal. NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.Pty non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.term.Pty

A pseudo terminal used for controlling a io.vertx.reactivex.ext.shell.term.Tty. This interface acts as a pseudo terminal master, io.vertx.reactivex.ext.shell.term.Pty#slave returns the assocated slave pseudo terminal. NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.Pty non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.PubSecKeyOptionsConverter

Converter for io.vertx.ext.auth.PubSecKeyOptions. NOTE: This class has been automatically generated from the io.vertx.ext.auth.PubSecKeyOptions original class using Vert.x codegen.

io.vertx.core.streams.Pump

Pumps data from a ReadStream to a WriteStream and performs flow control where necessary to prevent the write stream buffer from getting overfull.

Instances of this class read items from a ReadStream and write them to a WriteStream. If data can be read faster than it can be written this could result in the write queue of the WriteStream growing without bound, eventually causing it to exhaust all available RAM.

To prevent this, after each write, instances of this class check whether the write queue of the is full, and if so, the ReadStream is paused, and a drainHandler is set on the WriteStream.

When the WriteStream has processed half of its backlog, the drainHandler will be called, which results in the pump resuming the ReadStream.

This class can be used to pump from any ReadStream to any WriteStream, e.g. from an io.vertx.core.http.HttpServerRequest to an io.vertx.core.file.AsyncFile, or from io.vertx.core.net.NetSocket to a io.vertx.core.http.WebSocket.

Please see the documentation for more information.

io.vertx.rxjava.core.streams.Pump

Pumps data from a io.vertx.rxjava.core.streams.ReadStream to a io.vertx.rxjava.core.streams.WriteStream and performs flow control where necessary to prevent the write stream buffer from getting overfull.

Instances of this class read items from a io.vertx.rxjava.core.streams.ReadStream and write them to a io.vertx.rxjava.core.streams.WriteStream. If data can be read faster than it can be written this could result in the write queue of the io.vertx.rxjava.core.streams.WriteStream growing without bound, eventually causing it to exhaust all available RAM.

To prevent this, after each write, instances of this class check whether the write queue of the io.vertx.rxjava.core.streams.WriteStream is full, and if so, the io.vertx.rxjava.core.streams.ReadStream is paused, and a drainHandler is set on the io.vertx.rxjava.core.streams.WriteStream.

When the io.vertx.rxjava.core.streams.WriteStream has processed half of its backlog, the drainHandler will be called, which results in the pump resuming the io.vertx.rxjava.core.streams.ReadStream.

This class can be used to pump from any io.vertx.rxjava.core.streams.ReadStream to any io.vertx.rxjava.core.streams.WriteStream, e.g. from an io.vertx.rxjava.core.http.HttpServerRequest to an io.vertx.rxjava.core.file.AsyncFile, or from io.vertx.rxjava.core.net.NetSocket to a io.vertx.rxjava.core.http.WebSocket.

Please see the documentation for more information.

NOTE: This class has been automatically generated from the io.vertx.core.streams.Pump non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.streams.Pump

Pumps data from a io.vertx.reactivex.core.streams.ReadStream to a io.vertx.reactivex.core.streams.WriteStream and performs flow control where necessary to prevent the write stream buffer from getting overfull.

Instances of this class read items from a io.vertx.reactivex.core.streams.ReadStream and write them to a io.vertx.reactivex.core.streams.WriteStream. If data can be read faster than it can be written this could result in the write queue of the io.vertx.reactivex.core.streams.WriteStream growing without bound, eventually causing it to exhaust all available RAM.

To prevent this, after each write, instances of this class check whether the write queue of the io.vertx.reactivex.core.streams.WriteStream is full, and if so, the io.vertx.reactivex.core.streams.ReadStream is paused, and a drainHandler is set on the io.vertx.reactivex.core.streams.WriteStream.

When the io.vertx.reactivex.core.streams.WriteStream has processed half of its backlog, the drainHandler will be called, which results in the pump resuming the io.vertx.reactivex.core.streams.ReadStream.

This class can be used to pump from any io.vertx.reactivex.core.streams.ReadStream to any io.vertx.reactivex.core.streams.WriteStream, e.g. from an io.vertx.reactivex.core.http.HttpServerRequest to an io.vertx.reactivex.core.file.AsyncFile, or from io.vertx.reactivex.core.net.NetSocket to a io.vertx.reactivex.core.http.WebSocket.

Please see the documentation for more information.

NOTE: This class has been automatically generated from the io.vertx.core.streams.Pump non RX-ified interface using Vert.x codegen.

io.vertx.rabbitmq.RabbitMQClient
io.vertx.rxjava.rabbitmq.RabbitMQClient

NOTE: This class has been automatically generated from the io.vertx.rabbitmq.RabbitMQClient non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.rabbitmq.RabbitMQClient

NOTE: This class has been automatically generated from the io.vertx.rabbitmq.RabbitMQClient non RX-ified interface using Vert.x codegen.

io.vertx.rabbitmq.RabbitMQOptionsConverter

Converter for io.vertx.rabbitmq.RabbitMQOptions. NOTE: This class has been automatically generated from the io.vertx.rabbitmq.RabbitMQOptions original class using Vert.x codegen.

io.vertx.redis.op.RangeOptions
io.vertx.ext.reactivestreams.ReactiveReadStream

A Vert.x read stream that also implements reactive streams subscriber interface.

io.vertx.ext.reactivestreams.ReactiveWriteStream

A Vert.x write stream that also implements reactive streams publisher interface.

io.vertx.core.streams.ReadStream (extensions in package io.vertx.kotlin.coroutines)
io.vertx.reactivex.core.streams.ReadStream

Represents a stream of items that can be read from.

Any class that implements this interface can be used by a io.vertx.reactivex.core.streams.Pump to pump data from it to a io.vertx.reactivex.core.streams.WriteStream.

NOTE: This class has been automatically generated from the io.vertx.core.streams.ReadStream non RX-ified interface using Vert.x codegen.

io.vertx.codegen.extra.ReadStreamExt

We just want to check it compiles fine.

io.vertx.rx.java.ReadStreamSubscriber

An RxJava Subscriber that turns an Observable into a ReadStream.

The stream implements the #pause() and #resume() operation by maintaining a buffer of #BUFFER_SIZE elements between the Observable and the ReadStream.

When the subscriber is created it requests 0 elements to activate the subscriber's back-pressure. Setting the handler initially on the ReadStream triggers a request of #BUFFER_SIZE elements. When the item buffer is half empty, new elements are requested to fill the buffer back to #BUFFER_SIZE elements.

The < is called when the Observable is completed or has failed and no pending elements, emitted before the completion or failure, are still in the buffer, i.e the handler is not called when the stream is paused.

io.vertx.kotlin.coroutines.ReceiveChannelHandler

An adapter that converts a stream of events from the Handler into a ReceiveChannel which allows the events to be received synchronously.

io.vertx.ext.sync.Receiver

Represents a synchronous receiver of events.

Note that the `receive` methods may block the calling fiber but will not block an underlying kernel thread.

io.vertx.servicediscovery.RecordConverter

Converter for io.vertx.servicediscovery.Record. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.Record original class using Vert.x codegen.

io.vertx.core.parsetools.RecordParser

A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

Instances of this class take as input io.vertx.core.buffer.Buffer instances containing raw bytes, and output records.

For example, if I had a simple ASCII text protocol delimited by '\n' and the input was the following:

 buffer1:HELLO\nHOW ARE Y buffer2:OU?\nI AM buffer3: DOING OK buffer4:\n 
Then the output would be:

 buffer1:HELLO buffer2:HOW ARE YOU? buffer3:I AM DOING OK 
Instances of this class can be changed between delimited mode and fixed size record mode on the fly as individual records are read, this allows you to parse protocols where, for example, the first 5 records might all be fixed size (of potentially different sizes), followed by some delimited records, followed by more fixed size records.

Instances of this class can't currently be used for protocols where the text is encoded with something other than a 1-1 byte-char mapping.

Please see the documentation for more information.

io.vertx.rxjava.core.parsetools.RecordParser

A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

Instances of this class take as input io.vertx.rxjava.core.buffer.Buffer instances containing raw bytes, and output records.

For example, if I had a simple ASCII text protocol delimited by '\n' and the input was the following:

 buffer1:HELLO\nHOW ARE Y buffer2:OU?\nI AM buffer3: DOING OK buffer4:\n 
Then the output would be:

 buffer1:HELLO buffer2:HOW ARE YOU? buffer3:I AM DOING OK 
Instances of this class can be changed between delimited mode and fixed size record mode on the fly as individual records are read, this allows you to parse protocols where, for example, the first 5 records might all be fixed size (of potentially different sizes), followed by some delimited records, followed by more fixed size records.

Instances of this class can't currently be used for protocols where the text is encoded with something other than a 1-1 byte-char mapping.

Please see the documentation for more information.

NOTE: This class has been automatically generated from the io.vertx.core.parsetools.RecordParser non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.parsetools.RecordParser

A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

Instances of this class take as input io.vertx.reactivex.core.buffer.Buffer instances containing raw bytes, and output records.

For example, if I had a simple ASCII text protocol delimited by '\n' and the input was the following:

 buffer1:HELLO\nHOW ARE Y buffer2:OU?\nI AM buffer3: DOING OK buffer4:\n 
Then the output would be:

 buffer1:HELLO buffer2:HOW ARE YOU? buffer3:I AM DOING OK 
Instances of this class can be changed between delimited mode and fixed size record mode on the fly as individual records are read, this allows you to parse protocols where, for example, the first 5 records might all be fixed size (of potentially different sizes), followed by some delimited records, followed by more fixed size records.

Instances of this class can't currently be used for protocols where the text is encoded with something other than a 1-1 byte-char mapping.

Please see the documentation for more information.

NOTE: This class has been automatically generated from the io.vertx.core.parsetools.RecordParser non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.handler.RedirectAuthHandler

An auth handler that's used to handle auth by redirecting user to a custom login page.

io.vertx.rxjava.ext.web.handler.RedirectAuthHandler

An auth handler that's used to handle auth by redirecting user to a custom login page. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.RedirectAuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.RedirectAuthHandler

An auth handler that's used to handle auth by redirecting user to a custom login page. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.RedirectAuthHandler non RX-ified interface using Vert.x codegen.

io.vertx.servicediscovery.backend.redis.RedisBackendService

An implementation of the discovery backend based on Redis.

io.vertx.rxjava.redis.RedisClient
io.vertx.reactivex.redis.RedisClient
io.vertx.redis.utils.RedisCommandUtils
io.vertx.config.redis.RedisConfigStore

An implementation of configuration store reading hash from Redis.

io.vertx.config.redis.RedisConfigStoreFactory

Factory to create RedisConfigStore instances.

io.vertx.rxjava.servicediscovery.types.RedisDataSource

Service type for Redis data source. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.RedisDataSource non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.servicediscovery.types.RedisDataSource

Service type for Redis data source. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.types.RedisDataSource non RX-ified interface using Vert.x codegen.

io.vertx.redis.RedisOptionsConverter

Converter for io.vertx.redis.RedisOptions. NOTE: This class has been automatically generated from the io.vertx.redis.RedisOptions original class using Vert.x codegen.

io.vertx.redis.sentinel.RedisSentinel

Interface for sentinel commands

io.vertx.rxjava.redis.sentinel.RedisSentinel

Interface for sentinel commands NOTE: This class has been automatically generated from the io.vertx.redis.sentinel.RedisSentinel non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.redis.sentinel.RedisSentinel

Interface for sentinel commands NOTE: This class has been automatically generated from the io.vertx.redis.sentinel.RedisSentinel non RX-ified interface using Vert.x codegen.

io.vertx.redis.RedisTransaction

This Interface represents a TX

io.vertx.rxjava.redis.RedisTransaction

This Interface represents a TX NOTE: This class has been automatically generated from the io.vertx.redis.RedisTransaction non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.redis.RedisTransaction

This Interface represents a TX NOTE: This class has been automatically generated from the io.vertx.redis.RedisTransaction non RX-ified interface using Vert.x codegen.

io.vertx.ext.unit.junit.Repeat

Annotates a test method to repeat this test several times. This can be useful when a test fails randomly and not often.

io.vertx.ext.unit.junit.RepeatRule
io.vertx.core.eventbus.ReplyException

Represents the failure of a message send.

If a message was sent specifying a reply handler and the message delivery fails, a failure will be provided to the reply handler and the cause of the failure will be an instance of this.

io.vertx.core.eventbus.ReplyFailure

Represents the type of reply failure

io.vertx.ext.unit.report.ReportOptions

Configures a reporter consisting in a name to, an address at and an optional format.

io.vertx.ext.unit.report.ReportOptionsConverter

Converter for io.vertx.ext.unit.report.ReportOptions. NOTE: This class has been automatically generated from the io.vertx.ext.unit.report.ReportOptions original class using Vert.x codegen.

io.vertx.ext.unit.report.Reporter

The reporter defines a set of callback for the life cycle events.

io.vertx.ext.unit.report.ReporterFactory
io.vertx.ext.unit.report.ReportingOptions

Reporting options:

  • the reporters is an array of reporter configurations

io.vertx.ext.unit.report.ReportingOptionsConverter

Converter for io.vertx.ext.unit.report.ReportingOptions. NOTE: This class has been automatically generated from the io.vertx.ext.unit.report.ReportingOptions original class using Vert.x codegen.

io.vertx.core.http.RequestOptions

Options describing how an HttpClient will make connect to make a request.

io.vertx.ext.web.api.RequestParameter

Request parameter holder

io.vertx.rxjava.ext.web.api.RequestParameter

Request parameter holder NOTE: This class has been automatically generated from the io.vertx.ext.web.api.RequestParameter non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.RequestParameter

Request parameter holder NOTE: This class has been automatically generated from the io.vertx.ext.web.api.RequestParameter non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.api.RequestParameters

Container for request parameters

io.vertx.rxjava.ext.web.api.RequestParameters

Container for request parameters NOTE: This class has been automatically generated from the io.vertx.ext.web.api.RequestParameters non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.RequestParameters

Container for request parameters NOTE: This class has been automatically generated from the io.vertx.ext.web.api.RequestParameters non RX-ified interface using Vert.x codegen.

io.vertx.redis.op.ResetOptions
io.vertx.maven.resolver.ResolutionOptions

Options configuring the resolution of a single dependency.

io.vertx.maven.Resolver

Interface implemented by resolver. Resolvers are responsible for the resolution of the dependencies.

io.vertx.maven.resolver.ResolverImpl

An implementation of Resolver based on Aether.

io.vertx.maven.ResolverOptions

Options to configure the resolver.

io.vertx.core.spi.resolver.ResolverProvider
io.vertx.rxjava.ext.web.handler.ResponseContentTypeHandler

A handler which sets the response content type automatically according to the best Accept header match. The header is set only if:

  • no object is stored in the routing context under the name io.vertx.rxjava.ext.web.handler.ResponseContentTypeHandler
  • a match is found
  • the header is not present already
  • content length header is absent or set to something different than zero
NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.ResponseContentTypeHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.ResponseContentTypeHandler

A handler which sets the response content type automatically according to the best Accept header match. The header is set only if:

  • no object is stored in the routing context under the name io.vertx.reactivex.ext.web.handler.ResponseContentTypeHandler
  • a match is found
  • the header is not present already
  • content length header is absent or set to something different than zero
NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.ResponseContentTypeHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.handler.ResponseTimeHandler

Handler which adds a header `x-response-time` in the response of matching requests containing the time taken in ms to process the request.

io.vertx.rxjava.ext.web.handler.ResponseTimeHandler

Handler which adds a header `x-response-time` in the response of matching requests containing the time taken in ms to process the request. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.ResponseTimeHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.ResponseTimeHandler

Handler which adds a header `x-response-time` in the response of matching requests containing the time taken in ms to process the request. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.ResponseTimeHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.sql.ResultSetConverter

Converter for io.vertx.ext.sql.ResultSet. NOTE: This class has been automatically generated from the io.vertx.ext.sql.ResultSet original class using Vert.x codegen.

io.vertx.ext.web.api.contract.RouterFactory

Main interface for Design Driven Router factory Author: Francesco Guardiani @slinkydeveloper

io.vertx.rxjava.ext.web.api.contract.RouterFactory

Main interface for Design Driven Router factory Author: Francesco Guardiani @slinkydeveloper NOTE: This class has been automatically generated from the io.vertx.ext.web.api.contract.RouterFactory non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.contract.RouterFactory

Main interface for Design Driven Router factory Author: Francesco Guardiani @slinkydeveloper NOTE: This class has been automatically generated from the io.vertx.ext.web.api.contract.RouterFactory non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.api.contract.RouterFactoryException

Main class for router factory exceptions

io.vertx.ext.web.api.contract.RouterFactoryOptions
io.vertx.ext.unit.junit.RunTestOnContext

A JUnit rule that runs tests on a Vert.x context. When used as a org.junit.Rule a new context is created for each tested method, the context will be same for the before and after method, but different for all the tested methods. When used as a org.junit.ClassRule, a single context is created for all the tested method, the beforeClass and afterClass method will also executed in this context.

io.vertx.ext.sql.RuntimeSQLException
io.vertx.lang.reactivex.RxGen

Associate an RxJava generated class with its original type, used for mapping the generated classes to their original type.

io.vertx.rxjava.core.RxHelper

A set of helpers for RxJava and Vert.x.

io.vertx.reactivex.core.RxHelper
io.vertx.reactivex.RxHelper
io.vertx.rx.java.RxHelper

A set of helpers for RxJava and Vert.x.

io.vertx.core.logging.SLF4JLogDelegate
io.vertx.core.logging.SLF4JLogDelegateFactory
io.vertx.ext.sql.SQLOptionsConverter

Converter for io.vertx.ext.sql.SQLOptions. NOTE: This class has been automatically generated from the io.vertx.ext.sql.SQLOptions original class using Vert.x codegen.

io.vertx.ext.sql.SQLRowStream

A ReadStream of Rows from the underlying RDBMS. This class follows the ReadStream semantics and will automatically close the underlying resources if all returned rows are returned. For cases where the results are ignored before the full processing of the returned rows is complete the close method **MUST** be called in order to release underlying resources. The interface is minimal in order to support all SQL clients not just JDBC.

io.vertx.rxjava.ext.sql.SQLRowStream

A ReadStream of Rows from the underlying RDBMS. This class follows the ReadStream semantics and will automatically close the underlying resources if all returned rows are returned. For cases where the results are ignored before the full processing of the returned rows is complete the close method **MUST** be called in order to release underlying resources. The interface is minimal in order to support all SQL clients not just JDBC. NOTE: This class has been automatically generated from the io.vertx.ext.sql.SQLRowStream non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.sql.SQLRowStream

A ReadStream of Rows from the underlying RDBMS. This class follows the ReadStream semantics and will automatically close the underlying resources if all returned rows are returned. For cases where the results are ignored before the full processing of the returned rows is complete the close method **MUST** be called in order to release underlying resources. The interface is minimal in order to support all SQL clients not just JDBC. NOTE: This class has been automatically generated from the io.vertx.ext.sql.SQLRowStream non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.term.SSHTermOptionsConverter

Converter for io.vertx.ext.shell.term.SSHTermOptions. NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.SSHTermOptions original class using Vert.x codegen.

io.vertx.ext.auth.oauth2.providers.SalesforceAuth

Simplified factory to create an OAuth2Auth for Salesforce.

io.vertx.rxjava.ext.auth.oauth2.providers.SalesforceAuth

Simplified factory to create an for Salesforce. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.SalesforceAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.SalesforceAuth

Simplified factory to create an for Salesforce. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.SalesforceAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.dropwizard.ScheduledMetricsConsumer

TODO - support listening to more than one Measured

io.vertx.redis.Script

Container for a script and its sha1 hash.

io.vertx.redis.op.ScriptDebugOptions
io.vertx.lang.kotlin.ScriptVerticle
io.vertx.lang.groovy.ScriptVerticle

A Vert.x native verticle wrapping a Groovy script, the script will be executed when the Verticle starts. When the script defines a no arg accessible vertxStop method, this method will be invoked when the verticle stops. Before the script starts the following objects are bound in the script binding:

  • vertx: the io.vertx.core.Vertx object
  • deploymentID: the deploymentID of this Verticle
  • config: the Verticle config as a Map<String, Object>

io.vertx.config.vault.client.Secret

Represent Secret result.

io.vertx.ext.auth.SecretOptionsConverter

Converter for io.vertx.ext.auth.SecretOptions. NOTE: This class has been automatically generated from the io.vertx.ext.auth.SecretOptions original class using Vert.x codegen.

io.vertx.core.net.SelfSignedCertificate

A self-signed certificate helper for testing and development purposes.

While it helps for testing and development, it should never ever be used in production settings.

io.vertx.rxjava.core.net.SelfSignedCertificate

A self-signed certificate helper for testing and development purposes.

While it helps for testing and development, it should never ever be used in production settings.

NOTE: This class has been automatically generated from the io.vertx.core.net.SelfSignedCertificate non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.net.SelfSignedCertificate

A self-signed certificate helper for testing and development purposes.

While it helps for testing and development, it should never ever be used in production settings.

NOTE: This class has been automatically generated from the io.vertx.core.net.SelfSignedCertificate non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.eventbus.SendContext

Encapsulates a message being sent from Vert.x. Used with event bus interceptors NOTE: This class has been automatically generated from the io.vertx.core.eventbus.SendContext non RX-ified interface using Vert.x codegen.

io.vertx.ext.stomp.utils.Server

Class responsible for the computation of the server id. From the STOMP specification, this id must be constructed as follows: name/version comments.

io.vertx.core.net.ServerOptionsBase
io.vertx.core.http.ServerWebSocket

Represents a server side WebSocket.

Instances of this class are passed into a io.vertx.core.http.HttpServer#websocketHandler or provided when a WebSocket handshake is manually HttpServerRequest#upgradeed.

io.vertx.rxjava.core.http.ServerWebSocket

Represents a server side WebSocket.

Instances of this class are passed into a io.vertx.rxjava.core.http.HttpServer#websocketHandler or provided when a WebSocket handshake is manually io.vertx.rxjava.core.http.HttpServerRequest#upgradeed.

NOTE: This class has been automatically generated from the io.vertx.core.http.ServerWebSocket non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.ServerWebSocket

Represents a server side WebSocket.

Instances of this class are passed into a io.vertx.reactivex.core.http.HttpServer#websocketHandler or provided when a WebSocket handshake is manually io.vertx.reactivex.core.http.HttpServerRequest#upgradeed.

NOTE: This class has been automatically generated from the io.vertx.core.http.ServerWebSocket non RX-ified interface using Vert.x codegen.

io.vertx.serviceproxy.ServiceBinder

A binder for Service Proxies which state can be reused during the binder lifecycle.

io.vertx.servicediscovery.ServiceDiscoveryOptionsConverter

Converter for io.vertx.servicediscovery.ServiceDiscoveryOptions. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.ServiceDiscoveryOptions original class using Vert.x codegen.

io.vertx.servicediscovery.rest.ServiceDiscoveryRestEndpoint

Allows publishing the vert.x service discovery as a REST endpoint. It supports retrieving services, but also publish, withdraw and modify services.

io.vertx.ext.consul.ServiceEntryConverter

Converter for io.vertx.ext.consul.ServiceEntry. NOTE: This class has been automatically generated from the io.vertx.ext.consul.ServiceEntry original class using Vert.x codegen.

io.vertx.ext.consul.ServiceEntryListConverter

Converter for io.vertx.ext.consul.ServiceEntryList. NOTE: This class has been automatically generated from the io.vertx.ext.consul.ServiceEntryList original class using Vert.x codegen.

io.vertx.serviceproxy.ServiceException

An Exception to be returned from Service implementations.

io.vertx.serviceproxy.ServiceExceptionMessageCodec

A MessageCodec for ServiceException

io.vertx.rxjava.servicediscovery.spi.ServiceExporter

The service exporter allows integrate other discovery technologies with the Vert.x service discovery. It maps entries from another technology to a and maps to a publication in this other technology. The exporter is one side of a service discovery bridge. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.spi.ServiceExporter non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.servicediscovery.spi.ServiceExporter

The service exporter allows integrate other discovery technologies with the Vert.x service discovery. It maps entries from another technology to a and maps to a publication in this other technology. The exporter is one side of a service discovery bridge. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.spi.ServiceExporter non RX-ified interface using Vert.x codegen.

io.vertx.core.ServiceHelper

A helper class for loading factories from the classpath and from the vert.x OSGi bundle.

io.vertx.rxjava.servicediscovery.spi.ServiceImporter

The service importer allows integrate other discovery technologies with the Vert.x service discovery. It maps entries from another technology to a and maps to a publication in this other technology. The importer is one side of a service discovery bridge. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.spi.ServiceImporter non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.servicediscovery.spi.ServiceImporter

The service importer allows integrate other discovery technologies with the Vert.x service discovery. It maps entries from another technology to a and maps to a publication in this other technology. The importer is one side of a service discovery bridge. NOTE: This class has been automatically generated from the io.vertx.servicediscovery.spi.ServiceImporter non RX-ified interface using Vert.x codegen.

io.vertx.serviceproxy.ServiceJWTInterceptor

Create an event bus service interceptor using a JWT auth that will verify all requests before the service is invoked Once a JWT is validated it will be queried for authorities. If authorities are missing a error 403 is returned.

io.vertx.ext.consul.ServiceListConverter

Converter for io.vertx.ext.consul.ServiceList. NOTE: This class has been automatically generated from the io.vertx.ext.consul.ServiceList original class using Vert.x codegen.

io.vertx.ext.consul.ServiceOptionsConverter

Converter for io.vertx.ext.consul.ServiceOptions. NOTE: This class has been automatically generated from the io.vertx.ext.consul.ServiceOptions original class using Vert.x codegen.

io.vertx.serviceproxy.ServiceProxyBuilder

A builder for Service Proxies which state can be reused during the builder lifecycle.

io.vertx.serviceproxy.ServiceProxyProcessor
io.vertx.ext.consul.ServiceQueryOptionsConverter

Converter for io.vertx.ext.consul.ServiceQueryOptions. NOTE: This class has been automatically generated from the io.vertx.ext.consul.ServiceQueryOptions original class using Vert.x codegen.

io.vertx.rxjava.servicediscovery.ServiceReference

Once a consumer has chosen a service, it builds a io.vertx.rxjava.servicediscovery.ServiceReference managing the binding with the chosen service provider.

The reference lets the consumer: * access the service (via a proxy or a client) with the io.vertx.rxjava.servicediscovery.ServiceReference#get method * release the reference - so the binding between the consumer and the provider is removed

NOTE: This class has been automatically generated from the io.vertx.servicediscovery.ServiceReference non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.servicediscovery.ServiceReference

Once a consumer has chosen a service, it builds a io.vertx.reactivex.servicediscovery.ServiceReference managing the binding with the chosen service provider.

The reference lets the consumer: * access the service (via a proxy or a client) with the io.vertx.reactivex.servicediscovery.ServiceReference#get method * release the reference - so the binding between the consumer and the provider is removed

NOTE: This class has been automatically generated from the io.vertx.servicediscovery.ServiceReference non RX-ified interface using Vert.x codegen.

io.vertx.ext.consul.SessionConverter

Converter for io.vertx.ext.consul.Session. NOTE: This class has been automatically generated from the io.vertx.ext.consul.Session original class using Vert.x codegen.

io.vertx.ext.web.handler.SessionHandler

A handler that maintains a io.vertx.ext.web.Session for each browser session.

It looks up the session for each request based on a session cookie which contains a session ID. It stores the session when the response is ended in the session store.

The session is available on the routing context with RoutingContext#session().

The session handler requires a CookieHandler to be on the routing chain before it.

io.vertx.rxjava.ext.web.handler.SessionHandler

A handler that maintains a io.vertx.rxjava.ext.web.Session for each browser session.

It looks up the session for each request based on a session cookie which contains a session ID. It stores the session when the response is ended in the session store.

The session is available on the routing context with .

The session handler requires a io.vertx.rxjava.ext.web.handler.CookieHandler to be on the routing chain before it.

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.SessionHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.SessionHandler

A handler that maintains a io.vertx.reactivex.ext.web.Session for each browser session.

It looks up the session for each request based on a session cookie which contains a session ID. It stores the session when the response is ended in the session store.

The session is available on the routing context with .

The session handler requires a io.vertx.reactivex.ext.web.handler.CookieHandler to be on the routing chain before it.

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.SessionHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.consul.SessionListConverter

Converter for io.vertx.ext.consul.SessionList. NOTE: This class has been automatically generated from the io.vertx.ext.consul.SessionList original class using Vert.x codegen.

io.vertx.core.shareddata.Shareable

A marker interface which allows you to put arbitrary objects into a io.vertx.core.shareddata.LocalMap.

Normally local maps only allow immutable objects or other copiable objects such as io.vertx.core.buffer.Buffer instances in order to avoid shared access to mutable state.

However if you have an object that you know is thread-safe you can mark it with this interface and then you will be able to add it to io.vertx.core.shareddata.LocalMap instances.

Use this interface with caution.

io.vertx.core.shareddata.SharedData

Shared data allows you to share data safely between different parts of your application in a safe way.

Shared data provides:

  • synchronous shared maps (local)
  • asynchronous maps (local or cluster-wide)
  • asynchronous locks (local or cluster-wide)
  • asynchronous counters (local or cluster-wide)

WARNING: In clustered mode, asynchronous maps/locks/counters rely on distributed data structures provided by the cluster manager. Beware that the latency relative to asynchronous maps/locks/counters operations can be much higher in clustered than in local mode.

Please see the documentation for more information.

io.vertx.rxjava.core.shareddata.SharedData

Shared data allows you to share data safely between different parts of your application in a safe way.

Shared data provides:

  • synchronous shared maps (local)
  • asynchronous maps (local or cluster-wide)
  • asynchronous locks (local or cluster-wide)
  • asynchronous counters (local or cluster-wide)

WARNING: In clustered mode, asynchronous maps/locks/counters rely on distributed data structures provided by the cluster manager. Beware that the latency relative to asynchronous maps/locks/counters operations can be much higher in clustered than in local mode.

Please see the documentation for more information. NOTE: This class has been automatically generated from the io.vertx.core.shareddata.SharedData non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.shareddata.SharedData

Shared data allows you to share data safely between different parts of your application in a safe way.

Shared data provides:

  • synchronous shared maps (local)
  • asynchronous maps (local or cluster-wide)
  • asynchronous locks (local or cluster-wide)
  • asynchronous counters (local or cluster-wide)

WARNING: In clustered mode, asynchronous maps/locks/counters rely on distributed data structures provided by the cluster manager. Beware that the latency relative to asynchronous maps/locks/counters operations can be much higher in clustered than in local mode.

Please see the documentation for more information. NOTE: This class has been automatically generated from the io.vertx.core.shareddata.SharedData non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.Shell

An interactive session between a consumer and a shell.

io.vertx.rxjava.ext.shell.Shell

An interactive session between a consumer and a shell. NOTE: This class has been automatically generated from the io.vertx.ext.shell.Shell non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.Shell

An interactive session between a consumer and a shell. NOTE: This class has been automatically generated from the io.vertx.ext.shell.Shell non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.ShellServer

The shell server. A shell server is associated with a collection of TermServer: the #registerTermServer(TermServer) method registers a term server. Term servers life cycle are managed by this server. When a TermServer receives an incoming connection, a JobController instance is created and associated with this connection. The #createShell() method can be used to create JobController instance for testing purposes.

io.vertx.rxjava.ext.shell.ShellServer

The shell server. A shell server is associated with a collection of : the io.vertx.rxjava.ext.shell.ShellServer#registerTermServer method registers a term server. Term servers life cycle are managed by this server. When a receives an incoming connection, a instance is created and associated with this connection. The io.vertx.rxjava.ext.shell.ShellServer#createShell method can be used to create instance for testing purposes. NOTE: This class has been automatically generated from the io.vertx.ext.shell.ShellServer non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.ShellServer

The shell server. A shell server is associated with a collection of : the io.vertx.reactivex.ext.shell.ShellServer#registerTermServer method registers a term server. Term servers life cycle are managed by this server. When a receives an incoming connection, a instance is created and associated with this connection. The io.vertx.reactivex.ext.shell.ShellServer#createShell method can be used to create instance for testing purposes. NOTE: This class has been automatically generated from the io.vertx.ext.shell.ShellServer non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.ShellServerOptionsConverter

Converter for io.vertx.ext.shell.ShellServerOptions. NOTE: This class has been automatically generated from the io.vertx.ext.shell.ShellServerOptions original class using Vert.x codegen.

io.vertx.ext.shell.ShellService

The shell service, provides a remotely accessible shell available via Telnet or SSH according to the io.vertx.ext.shell.ShellServiceOptions configuration. The shell service will expose commands using io.vertx.ext.shell.command.CommandResolver on the classpath and the shared command registry for the Vert.x instance.

io.vertx.rxjava.ext.shell.ShellService

The shell service, provides a remotely accessible shell available via Telnet or SSH according to the io.vertx.ext.shell.ShellServiceOptions configuration. The shell service will expose commands using io.vertx.rxjava.ext.shell.command.CommandResolver on the classpath and the shared command registry for the Vert.x instance. NOTE: This class has been automatically generated from the io.vertx.ext.shell.ShellService non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.ShellService

The shell service, provides a remotely accessible shell available via Telnet or SSH according to the io.vertx.ext.shell.ShellServiceOptions configuration. The shell service will expose commands using io.vertx.reactivex.ext.shell.command.CommandResolver on the classpath and the shared command registry for the Vert.x instance. NOTE: This class has been automatically generated from the io.vertx.ext.shell.ShellService non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.ShellServiceOptionsConverter

Converter for io.vertx.ext.shell.ShellServiceOptions. NOTE: This class has been automatically generated from the io.vertx.ext.shell.ShellServiceOptions original class using Vert.x codegen.

io.vertx.ext.shell.ShellVerticle
io.vertx.ext.auth.shiro.ShiroAuth

Factory interface for creating Apache Shiro based io.vertx.ext.auth.AuthProvider instances.

io.vertx.rxjava.ext.auth.shiro.ShiroAuth

Factory interface for creating Apache Shiro based io.vertx.rxjava.ext.auth.AuthProvider instances. NOTE: This class has been automatically generated from the io.vertx.ext.auth.shiro.ShiroAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.shiro.ShiroAuth

Factory interface for creating Apache Shiro based io.vertx.reactivex.ext.auth.AuthProvider instances. NOTE: This class has been automatically generated from the io.vertx.ext.auth.shiro.ShiroAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.shiro.ShiroAuthOptionsConverter

Converter for io.vertx.ext.auth.shiro.ShiroAuthOptions. NOTE: This class has been automatically generated from the io.vertx.ext.auth.shiro.ShiroAuthOptions original class using Vert.x codegen.

io.vertx.ext.auth.oauth2.providers.ShopifyAuth

Simplified factory to create an OAuth2Auth for Shopify.

io.vertx.rxjava.ext.auth.oauth2.providers.ShopifyAuth

Simplified factory to create an for Shopify. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.ShopifyAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.ShopifyAuth

Simplified factory to create an for Shopify. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.ShopifyAuth non RX-ified interface using Vert.x codegen.

io.vertx.redis.op.ShutdownOptions
io.vertx.ext.shell.term.SignalHandler
io.vertx.rxjava.ext.shell.term.SignalHandler

NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.SignalHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.term.SignalHandler

NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.SignalHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.SingleHelper
io.vertx.reactivex.SingleHelper
io.vertx.rx.java.SingleOnSubscribeAdapter
io.vertx.reactivex.core.json.SingleUnmarshaller

An operator to unmarshall json to pojos.

io.vertx.ext.shell.command.base.Sleep
io.vertx.config.vault.client.SlimVaultClient

A very simple Vault client - does not intend to be complete.

io.vertx.redis.op.SlotCmd
io.vertx.ext.web.handler.sockjs.SockJSHandler

A handler that allows you to handle SockJS connections from clients.

We currently support version 0.3.3 of the SockJS protocol, which can be found in this tag:

io.vertx.rxjava.ext.web.handler.sockjs.SockJSHandler

A handler that allows you to handle SockJS connections from clients.

We currently support version 0.3.3 of the SockJS protocol, which can be found in this tag:

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.sockjs.SockJSHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.sockjs.SockJSHandler

A handler that allows you to handle SockJS connections from clients.

We currently support version 0.3.3 of the SockJS protocol, which can be found in this tag:

NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.sockjs.SockJSHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.term.SockJSTermHandler
io.vertx.rxjava.ext.shell.term.SockJSTermHandler

NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.SockJSTermHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.term.SockJSTermHandler

NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.SockJSTermHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.net.SocketAddress

The address of a socket, an inet socket address or a domain socket address. Use io.vertx.reactivex.core.net.SocketAddress#inetSocketAddress to create an inet socket address and io.vertx.reactivex.core.net.SocketAddress#domainSocketAddress to create a domain socket address NOTE: This class has been automatically generated from the io.vertx.core.net.SocketAddress non RX-ified interface using Vert.x codegen.

io.vertx.ext.auth.oauth2.providers.SoundcloudAuth

Simplified factory to create an OAuth2Auth for SoundCloud.

io.vertx.rxjava.ext.auth.oauth2.providers.SoundcloudAuth

Simplified factory to create an for SoundCloud. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.SoundcloudAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.SoundcloudAuth

Simplified factory to create an for SoundCloud. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.SoundcloudAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.api.validation.SpecFeatureNotSupportedException
io.vertx.config.spring.SpringConfigServerStoreFactory

Factory to create instance of SpringConfigServerStore.

io.vertx.reactivex.core.dns.SrvRecord

Represent a Service-Record (SRV) which was resolved for a domain. NOTE: This class has been automatically generated from the io.vertx.core.dns.SrvRecord non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.handler.StaticHandler

A handler for serving static resources from the file system or classpath.

io.vertx.rxjava.ext.web.handler.StaticHandler

A handler for serving static resources from the file system or classpath. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.StaticHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.StaticHandler

A handler for serving static resources from the file system or classpath. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.StaticHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.healthchecks.Status

Represents the outcome of a health check procedure. Each procedure produces a Status indicating either OK or KO. Optionally, it can also provide additional data.

io.vertx.ext.healthchecks.StatusConverter

Converter for io.vertx.ext.healthchecks.Status. NOTE: This class has been automatically generated from the io.vertx.ext.healthchecks.Status original class using Vert.x codegen.

io.vertx.ext.stomp.StompClientConnection

Once a connection to the STOMP server has been made, client receives a StompClientConnection, that let send and receive STOMP frames.

io.vertx.rxjava.ext.stomp.StompClientConnection

Once a connection to the STOMP server has been made, client receives a io.vertx.rxjava.ext.stomp.StompClientConnection, that let send and receive STOMP frames. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.StompClientConnection non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.stomp.StompClientConnection

Once a connection to the STOMP server has been made, client receives a io.vertx.reactivex.ext.stomp.StompClientConnection, that let send and receive STOMP frames. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.StompClientConnection non RX-ified interface using Vert.x codegen.

io.vertx.ext.stomp.StompClientOptionsConverter

Converter for io.vertx.ext.stomp.StompClientOptions. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.StompClientOptions original class using Vert.x codegen.

io.vertx.ext.stomp.StompServer

Defines a STOMP server. STOMP servers delegates to a StompServerHandler that let customize the behavior of the server. By default, it uses a handler compliant with the STOMP specification, but let you change anything.

io.vertx.rxjava.ext.stomp.StompServer

Defines a STOMP server. STOMP servers delegates to a io.vertx.rxjava.ext.stomp.StompServerHandler that let customize the behavior of the server. By default, it uses a handler compliant with the STOMP specification, but let you change anything. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.StompServer non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.stomp.StompServer

Defines a STOMP server. STOMP servers delegates to a io.vertx.reactivex.ext.stomp.StompServerHandler that let customize the behavior of the server. By default, it uses a handler compliant with the STOMP specification, but let you change anything. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.StompServer non RX-ified interface using Vert.x codegen.

io.vertx.ext.stomp.StompServerOptionsConverter

Converter for io.vertx.ext.stomp.StompServerOptions. NOTE: This class has been automatically generated from the io.vertx.ext.stomp.StompServerOptions original class using Vert.x codegen.

io.vertx.reactivex.core.streams.StreamBase

Base interface for a stream. NOTE: This class has been automatically generated from the io.vertx.core.streams.StreamBase non RX-ified interface using Vert.x codegen.

io.vertx.core.http.StreamResetException

This exception signals a stream reset, it is used only for HTTP/2.

io.vertx.core.cli.converters.StringConverter

Converts String to String, that's the easy one.

io.vertx.ext.auth.oauth2.providers.StripeAuth

Simplified factory to create an OAuth2Auth for Stripe.

io.vertx.rxjava.ext.auth.oauth2.providers.StripeAuth

Simplified factory to create an for Stripe. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.StripeAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.StripeAuth

Simplified factory to create an for Stripe. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.StripeAuth non RX-ified interface using Vert.x codegen.

io.vertx.core.cli.annotations.Summary

Annotates a io.vertx.core.cli.CLI with summary. The summary is the main short explanation of the command. Long description should be written in the Description.

io.vertx.ext.sync.SuspendableRunnable
io.vertx.ext.sync.Sync

This class contains various static methods to allowing events and asynchronous results to be accessed in a synchronous way.

io.vertx.ext.sync.SyncVerticle

A `Verticle` which runs its `start` and `stop` methods using fibers. You should subclass this class instead of `AbstractVerticle` to create any verticles that use vertx-sync.

io.vertx.core.spi.metrics.TCPMetrics

An SPI used internally by Vert.x to gather metrics on a net socket which serves as a base class for things like HttpServer and HttpClient, all of which serve TCP connections. The thread model for the tcp metrics depends on the actual context thats created the client/server. Event loop context Unless specified otherwise, all the methods on this object including the methods inherited from the super interfaces are invoked with the thread of the client/server and therefore are the same than the io.vertx.core.spi.metrics.VertxMetrics createMetrics method that created and returned this metrics object. Worker context Unless specified otherwise, all the methods on this object including the methods inherited from the super interfaces are invoked with a worker thread.

io.vertx.ext.eventbus.bridge.tcp.TcpEventBusBridge

TCP EventBus bridge for Vert.x

io.vertx.ext.rxjava.eventbus.bridge.tcp.TcpEventBusBridge

TCP EventBus bridge for Vert.x NOTE: This class has been automatically generated from the io.vertx.ext.eventbus.bridge.tcp.TcpEventBusBridge non RX-ified interface using Vert.x codegen.

io.vertx.ext.groovy.eventbus.bridge.tcp.TcpEventBusBridge_GroovyStaticExtension
io.vertx.ext.shell.term.TelnetTermOptionsConverter

Converter for io.vertx.ext.shell.term.TelnetTermOptions. NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.TelnetTermOptions original class using Vert.x codegen.

io.vertx.ext.web.handler.TemplateHandler

A handler which renders responses using a template engine and where the template name is selected from the URI path.

io.vertx.rxjava.ext.web.handler.TemplateHandler

A handler which renders responses using a template engine and where the template name is selected from the URI path. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.TemplateHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.TemplateHandler

A handler which renders responses using a template engine and where the template name is selected from the URI path. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.TemplateHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.shell.term.TermServer

A server for terminal based applications.

io.vertx.rxjava.ext.shell.term.TermServer

A server for terminal based applications. NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.TermServer non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.shell.term.TermServer

A server for terminal based applications. NOTE: This class has been automatically generated from the io.vertx.ext.shell.term.TermServer non RX-ified interface using Vert.x codegen.

io.vertx.ext.unit.TestCase

A test case object can be used to create a single test.

io.vertx.rxjava.ext.unit.TestCase

A test case object can be used to create a single test. NOTE: This class has been automatically generated from the io.vertx.ext.unit.TestCase non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.TestCase

A test case object can be used to create a single test. NOTE: This class has been automatically generated from the io.vertx.ext.unit.TestCase non RX-ified interface using Vert.x codegen.

io.vertx.ext.unit.report.TestCaseReport

Report the execution of a test case.

io.vertx.rxjava.ext.unit.report.TestCaseReport

Report the execution of a test case. NOTE: This class has been automatically generated from the io.vertx.ext.unit.report.TestCaseReport non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.report.TestCaseReport

Report the execution of a test case. NOTE: This class has been automatically generated from the io.vertx.ext.unit.report.TestCaseReport non RX-ified interface using Vert.x codegen.

io.vertx.ext.unit.TestCompletion

This object provides callback-ability for the end of a test suite, the completion succeeds when all tests pass otherwise it fails.

io.vertx.rxjava.ext.unit.TestCompletion

This object provides callback-ability for the end of a test suite, the completion succeeds when all tests pass otherwise it fails. NOTE: This class has been automatically generated from the io.vertx.ext.unit.TestCompletion non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.TestCompletion

This object provides callback-ability for the end of a test suite, the completion succeeds when all tests pass otherwise it fails. NOTE: This class has been automatically generated from the io.vertx.ext.unit.TestCompletion non RX-ified interface using Vert.x codegen.

io.vertx.ext.unit.TestContext

The test context is used for performing test assertions and manage the completion of the test. This context is provided by vertx-unit as argument of the test case.

io.vertx.rxjava.ext.unit.TestContext

The test context is used for performing test assertions and manage the completion of the test. This context is provided by vertx-unit as argument of the test case. NOTE: This class has been automatically generated from the io.vertx.ext.unit.TestContext non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.TestContext

The test context is used for performing test assertions and manage the completion of the test. This context is provided by vertx-unit as argument of the test case. NOTE: This class has been automatically generated from the io.vertx.ext.unit.TestContext non RX-ified interface using Vert.x codegen.

io.vertx.ext.unit.TestOptions

Test execution options:

  • the timeout in milliseconds, the default value is 2 minutes
  • the useEventLoop
  • configures the event loop usage
    • true always runs with an event loop
    • false never runs with an event loop
    • null uses an event loop if there is one (provided by io.vertx.core.Vertx#currentContext()) otherwise run without
  • the reporters is an array of reporter configurations

io.vertx.ext.unit.TestOptionsConverter

Converter for io.vertx.ext.unit.TestOptions. NOTE: This class has been automatically generated from the io.vertx.ext.unit.TestOptions original class using Vert.x codegen.

io.vertx.ext.unit.report.TestResult

The result of a test.

io.vertx.rxjava.ext.unit.report.TestResult

The result of a test. NOTE: This class has been automatically generated from the io.vertx.ext.unit.report.TestResult non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.report.TestResult

The result of a test. NOTE: This class has been automatically generated from the io.vertx.ext.unit.report.TestResult non RX-ified interface using Vert.x codegen.

io.vertx.ext.unit.TestSuite

A named suite of test cases that are executed altogether. The suite suite is created with the #create(String) and the returned suite contains initially no tests. The suite can declare a callback before the suite with #before(io.vertx.core.Handler) or after the suite with #after(io.vertx.core.Handler). The suite can declare a callback before each test with #beforeEach(io.vertx.core.Handler) or after each test with #afterEach(io.vertx.core.Handler). Each test case of the suite is declared by calling the #test(String, io.vertx.core.Handler) method.

io.vertx.rxjava.ext.unit.TestSuite

A named suite of test cases that are executed altogether. The suite suite is created with the io.vertx.rxjava.ext.unit.TestSuite#create and the returned suite contains initially no tests. The suite can declare a callback before the suite with io.vertx.rxjava.ext.unit.TestSuite#before or after the suite with io.vertx.rxjava.ext.unit.TestSuite#after. The suite can declare a callback before each test with io.vertx.rxjava.ext.unit.TestSuite#beforeEach or after each test with io.vertx.rxjava.ext.unit.TestSuite#afterEach. Each test case of the suite is declared by calling the io.vertx.rxjava.ext.unit.TestSuite#test method. NOTE: This class has been automatically generated from the io.vertx.ext.unit.TestSuite non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.TestSuite

A named suite of test cases that are executed altogether. The suite suite is created with the io.vertx.reactivex.ext.unit.TestSuite#create and the returned suite contains initially no tests. The suite can declare a callback before the suite with io.vertx.reactivex.ext.unit.TestSuite#before or after the suite with io.vertx.reactivex.ext.unit.TestSuite#after. The suite can declare a callback before each test with io.vertx.reactivex.ext.unit.TestSuite#beforeEach or after each test with io.vertx.reactivex.ext.unit.TestSuite#afterEach. Each test case of the suite is declared by calling the io.vertx.reactivex.ext.unit.TestSuite#test method. NOTE: This class has been automatically generated from the io.vertx.ext.unit.TestSuite non RX-ified interface using Vert.x codegen.

io.vertx.ext.unit.report.TestSuiteReport

The test suite reports is basically a stream of events reporting the test suite execution.

io.vertx.rxjava.ext.unit.report.TestSuiteReport

The test suite reports is basically a stream of events reporting the test suite execution. NOTE: This class has been automatically generated from the io.vertx.ext.unit.report.TestSuiteReport non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.unit.report.TestSuiteReport

The test suite reports is basically a stream of events reporting the test suite execution. NOTE: This class has been automatically generated from the io.vertx.ext.unit.report.TestSuiteReport non RX-ified interface using Vert.x codegen.

io.vertx.ext.dropwizard.ThroughputMeter

A throughput metric, wraps a Meter object to provide a one second instant throughput value returned by #getValue().

io.vertx.ext.dropwizard.ThroughputTimer

A throughput metric, wraps a Meter object to provide a one second instant throughput value returned by #getValue().

io.vertx.ext.web.templ.ThymeleafTemplateEngine

A template engine that uses the Thymeleaf library.

io.vertx.rxjava.ext.web.templ.ThymeleafTemplateEngine

A template engine that uses the Thymeleaf library. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.ThymeleafTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.templ.ThymeleafTemplateEngine

A template engine that uses the Thymeleaf library. NOTE: This class has been automatically generated from the io.vertx.ext.web.templ.ThymeleafTemplateEngine non RX-ified interface using Vert.x codegen.

io.vertx.ext.unit.junit.Timeout

A rule for configuring the tests timeout.

io.vertx.junit5.Timeout

Specify how long VertxTestContext#awaitCompletion(long, TimeUnit) waits before timing out.

This annotation works on both test methods and test classes.

io.vertx.ext.web.handler.TimeoutHandler

Handler that will timeout requests if the response has not been written after a certain time. Timeout requests will be ended with an HTTP status code `503`.

io.vertx.rxjava.ext.web.handler.TimeoutHandler

Handler that will timeout requests if the response has not been written after a certain time. Timeout requests will be ended with an HTTP status code `503`. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.TimeoutHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.TimeoutHandler

Handler that will timeout requests if the response has not been written after a certain time. Timeout requests will be ended with an HTTP status code `503`. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.TimeoutHandler non RX-ified interface using Vert.x codegen.

io.vertx.core.TimeoutStream

A timeout stream is triggered by a timer, the io.vertx.core.Handler will be call when the timer is fired, it can be once or several times depending on the nature of the timer related to this stream. The ReadStream#endHandler(Handler) will be called after the timer handler has been called.

Pausing the timer inhibits the timer shots until the stream is resumed. Setting a null handler callback cancels the timer.

io.vertx.rxjava.core.TimeoutStream

A timeout stream is triggered by a timer, the io.vertx.rxjava.core.Handler will be call when the timer is fired, it can be once or several times depending on the nature of the timer related to this stream. The will be called after the timer handler has been called.

Pausing the timer inhibits the timer shots until the stream is resumed. Setting a null handler callback cancels the timer.

NOTE: This class has been automatically generated from the io.vertx.core.TimeoutStream non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.TimeoutStream

A timeout stream is triggered by a timer, the io.vertx.reactivex.core.Handler will be call when the timer is fired, it can be once or several times depending on the nature of the timer related to this stream. The will be called after the timer handler has been called.

Pausing the timer inhibits the timer shots until the stream is resumed. Setting a null handler callback cancels the timer.

NOTE: This class has been automatically generated from the io.vertx.core.TimeoutStream non RX-ified interface using Vert.x codegen.

io.vertx.config.vault.client.TokenRequest

The token request structure.

io.vertx.config.vault.client.TokenRequestConverter

Converter for io.vertx.config.vault.client.TokenRequest. NOTE: This class has been automatically generated from the io.vertx.config.vault.client.TokenRequest original class using Vert.x codegen.

io.vertx.ext.web.handler.sockjs.Transport

The available SockJS transports

io.vertx.ext.auth.oauth2.providers.TwitterAuth

Simplified factory to create an OAuth2Auth for Twitter.

io.vertx.rxjava.ext.auth.oauth2.providers.TwitterAuth

Simplified factory to create an for Twitter. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.TwitterAuth non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.oauth2.providers.TwitterAuth

Simplified factory to create an for Twitter. NOTE: This class has been automatically generated from the io.vertx.ext.auth.oauth2.providers.TwitterAuth non RX-ified interface using Vert.x codegen.

io.vertx.ext.consul.TxnErrorConverter

Converter for io.vertx.ext.consul.TxnError. NOTE: This class has been automatically generated from the io.vertx.ext.consul.TxnError original class using Vert.x codegen.

io.vertx.ext.consul.TxnKVOperationConverter

Converter for io.vertx.ext.consul.TxnKVOperation. NOTE: This class has been automatically generated from the io.vertx.ext.consul.TxnKVOperation original class using Vert.x codegen.

io.vertx.ext.consul.TxnOperationType

Represents the type of operation in a transaction. KV is the only available operation type, though other types of operations may be added in future versions of Consul to be mixed with key/value operations

io.vertx.lang.reactivex.TypeArg
io.vertx.core.cli.TypedArgument

An implementation of Argument for java specifying the type of object received by the argument. This allows converting the given raw value into the specified type.

io.vertx.core.cli.TypedOption

An implementation of Option for java specifying the type of object received by the option. This allows converting the given raw value into the specified type.

io.vertx.rx.java.UnmarshallerOperator

An operator

io.vertx.ext.sql.UpdateResultConverter

Converter for io.vertx.ext.sql.UpdateResult. NOTE: This class has been automatically generated from the io.vertx.ext.sql.UpdateResult original class using Vert.x codegen.

io.vertx.core.cli.UsageMessageFormatter

Usage message formatter.

io.vertx.ext.web.handler.UserSessionHandler

This handler should be used if you want to store the User object in the Session so it's available between different requests, without you having re-authenticate each time. It requires that the session handler is already present on previous matching routes. It requires an Auth provider so, if the user is deserialized from a clustered session it knows which Auth provider to associate the session with.

io.vertx.rxjava.ext.web.handler.UserSessionHandler

This handler should be used if you want to store the User object in the Session so it's available between different requests, without you having re-authenticate each time. It requires that the session handler is already present on previous matching routes. It requires an Auth provider so, if the user is deserialized from a clustered session it knows which Auth provider to associate the session with. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.UserSessionHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.UserSessionHandler

This handler should be used if you want to store the User object in the Session so it's available between different requests, without you having re-authenticate each time. It requires that the session handler is already present on previous matching routes. It requires an Auth provider so, if the user is deserialized from a clustered session it knows which Auth provider to associate the session with. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.UserSessionHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.api.validation.ValidationException

This is the main class for every Validation flow related errors

io.vertx.ext.web.api.validation.ValidationHandler

Base interface for validation. For basic HTTP Request Validator, use HTTPRequestValidationHandler

io.vertx.rxjava.ext.web.api.validation.ValidationHandler

Base interface for validation. For basic HTTP Request Validator, use io.vertx.rxjava.ext.web.api.validation.HTTPRequestValidationHandler NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.ValidationHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.api.validation.ValidationHandler

Base interface for validation. For basic HTTP Request Validator, use io.vertx.reactivex.ext.web.api.validation.HTTPRequestValidationHandler NOTE: This class has been automatically generated from the io.vertx.ext.web.api.validation.ValidationHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.httpservicefactory.ValidationPolicy
io.vertx.core.cli.converters.ValueOfBasedConverter

This 'default' converter tries to create objects using a static 'valueOf' method taking a single String argument. This converter is particularly convenient to for enumeration and primitive types.

io.vertx.config.vault.VaultConfigStore

An implementation of ConfigStore for Vault (https://www.vaultproject.io/).

io.vertx.config.vault.VaultConfigStoreFactory

Implementation of ConfigStoreFactory to create VaultConfigStore.

io.vertx.config.vault.client.VaultException

Exception used when an interaction with Vault failed.

io.vertx.ext.shell.command.base.VerticleDeploy
io.vertx.ext.shell.command.base.VerticleFactories
io.vertx.ext.shell.command.base.VerticleLs
io.vertx.lang.kotlin.VerticleScriptDefinition
io.vertx.ext.shell.command.base.VerticleUndeploy
io.vertx.core.Vertx (extensions in package io.vertx.kotlin.coroutines)
io.vertx.reactivex.core.Vertx

The entry point into the Vert.x Core API.

You use an instance of this class for functionality including:

  • Creating TCP clients and servers
  • Creating HTTP clients and servers
  • Creating DNS clients
  • Creating Datagram sockets
  • Setting and cancelling periodic and one-shot timers
  • Getting a reference to the event bus API
  • Getting a reference to the file system API
  • Getting a reference to the shared data API
  • Deploying and undeploying verticles

Most functionality in Vert.x core is fairly low level.

To create an instance of this class you can use the static factory methods: io.vertx.reactivex.core.Vertx#vertx, io.vertx.reactivex.core.Vertx#vertx and io.vertx.reactivex.core.Vertx#clusteredVertx.

Please see the user manual for more detailed usage information.

NOTE: This class has been automatically generated from the io.vertx.core.Vertx non RX-ified interface using Vert.x codegen.

io.vertx.grpc.VertxChannelBuilder
io.vertx.ext.auth.VertxContextPRNG

A secure non blocking random number generator isolated to the current context. The PRNG is bound to the vert.x context and setup to close when the context shuts down.

When applicable, use of VertxContextPRNG rather than create new PRNG objects is helpful to keep the system entropy usage to the minimum avoiding potential blocking across the application.

The use of VertxContextPRNG is particularly appropriate when multiple handlers use random numbers.

io.vertx.rxjava.ext.auth.VertxContextPRNG

A secure non blocking random number generator isolated to the current context. The PRNG is bound to the vert.x context and setup to close when the context shuts down.

When applicable, use of VertxContextPRNG rather than create new PRNG objects is helpful to keep the system entropy usage to the minimum avoiding potential blocking across the application.

The use of VertxContextPRNG is particularly appropriate when multiple handlers use random numbers.

NOTE: This class has been automatically generated from the io.vertx.ext.auth.VertxContextPRNG non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.auth.VertxContextPRNG

A secure non blocking random number generator isolated to the current context. The PRNG is bound to the vert.x context and setup to close when the context shuts down.

When applicable, use of VertxContextPRNG rather than create new PRNG objects is helpful to keep the system entropy usage to the minimum avoiding potential blocking across the application.

The use of VertxContextPRNG is particularly appropriate when multiple handlers use random numbers.

NOTE: This class has been automatically generated from the io.vertx.ext.auth.VertxContextPRNG non RX-ified interface using Vert.x codegen.

io.vertx.junit5.VertxExtension

JUnit 5 Vert.x extension that allows the injection of Vertx and VertxTestContext parameters as well as an automatic lifecycle on the VertxTestContext instance.

io.vertx.lang.groovy.VertxExtensionMethodBoostrap
io.vertx.ext.groovy.eventbus.bridge.tcp.VertxExtensionModule
io.vertx.core.spi.VertxFactory

Factory for creating Vertx instances.

Use this to create Vertx instances when embedding Vert.x core directly.

io.vertx.ext.hawkular.VertxHawkularOptionsConverter

Converter for io.vertx.ext.hawkular.VertxHawkularOptions. NOTE: This class has been automatically generated from the io.vertx.ext.hawkular.VertxHawkularOptions original class using Vert.x codegen.

io.vertx.micrometer.VertxInfluxDbOptions

Vert.x InfluxDb micrometer configuration.

io.vertx.micrometer.VertxInfluxDbOptionsConverter

Converter for io.vertx.micrometer.VertxInfluxDbOptions. NOTE: This class has been automatically generated from the io.vertx.micrometer.VertxInfluxDbOptions original class using Vert.x codegen.

io.vertx.micrometer.VertxJmxMetricsOptions

Options for Prometheus metrics backend.

io.vertx.micrometer.VertxJmxMetricsOptionsConverter

Converter for io.vertx.micrometer.VertxJmxMetricsOptions. NOTE: This class has been automatically generated from the io.vertx.micrometer.VertxJmxMetricsOptions original class using Vert.x codegen.

io.vertx.core.logging.VertxLoggerFormatter
io.vertx.core.spi.metrics.VertxMetrics

The main Vert.x metrics SPI which Vert.x will use internally. This interface serves two purposes, one to be called by Vert.x itself for events like verticles deployed, timers created, etc. The other to provide Vert.x with other metrics SPI's which will be used for specific components i.e. io.vertx.core.http.HttpServer, io.vertx.core.spi.metrics.EventBusMetrics, etc.

io.vertx.core.spi.VertxMetricsFactory

A factory for the plugable metrics SPI.

io.vertx.core.VertxOptions

Instances of this class are used to configure io.vertx.core.Vertx instances.

io.vertx.micrometer.VertxPrometheusOptions

Options for Prometheus metrics backend.

io.vertx.micrometer.VertxPrometheusOptionsConverter

Converter for io.vertx.micrometer.VertxPrometheusOptions. NOTE: This class has been automatically generated from the io.vertx.micrometer.VertxPrometheusOptions original class using Vert.x codegen.

io.vertx.kafka.client.serialization.VertxSerdes
io.vertx.grpc.VertxServer
io.vertx.grpc.VertxServerBuilder
io.vertx.junit5.VertxTestContext

A test context to wait on the outcomes of asynchronous operations.

io.vertx.lang.groovy.VertxTransformation
io.vertx.ext.unit.junit.VertxUnitRunner

A JUnit runner for writing asynchronous tests. Note : a runner is needed because when a rule statement is evaluated, it will run the before/test/after method and then test method is executed even if there are pending Async objects in the before method. The runner gives this necessary fine grained control.

io.vertx.ext.unit.junit.VertxUnitRunnerWithParameters
io.vertx.ext.unit.junit.VertxUnitRunnerWithParametersFactory

A org.junit.runners.parameterized.ParametersRunnerFactory for a io.vertx.ext.unit.junit.VertxUnitRunner for enabling Vert.x Unit parameterized tests.

io.vertx.ext.web.handler.VirtualHostHandler

Handler that will filter requests based on the request Host name.

io.vertx.rxjava.ext.web.handler.VirtualHostHandler

Handler that will filter requests based on the request Host name. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.VirtualHostHandler non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.handler.VirtualHostHandler

Handler that will filter requests based on the request Host name. NOTE: This class has been automatically generated from the io.vertx.ext.web.handler.VirtualHostHandler non RX-ified interface using Vert.x codegen.

io.vertx.ext.consul.Watch

Watches are a way of specifying a view of data (e.g. list of nodes, KV pairs, health checks) which is monitored for updates. When an update is detected, an Handler with AsyncResult is invoked. As an example, you could watch the status of health checks and notify when a check is critical.

io.vertx.rxjava.ext.consul.Watch

Watches are a way of specifying a view of data (e.g. list of nodes, KV pairs, health checks) which is monitored for updates. When an update is detected, an Handler with AsyncResult is invoked. As an example, you could watch the status of health checks and notify when a check is critical. NOTE: This class has been automatically generated from the io.vertx.ext.consul.Watch non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.consul.Watch

Watches are a way of specifying a view of data (e.g. list of nodes, KV pairs, health checks) which is monitored for updates. When an update is detected, an Handler with AsyncResult is invoked. As an example, you could watch the status of health checks and notify when a check is critical. NOTE: This class has been automatically generated from the io.vertx.ext.consul.Watch non RX-ified interface using Vert.x codegen.

io.vertx.rxjava.ext.web.client.WebClient

An asynchronous HTTP / HTTP/2 client called WebClient.

The web client makes easy to do HTTP request/response interactions with a web server, and provides advanced features like:

  • Json body encoding / decoding
  • request/response pumping
  • error handling

The web client does not deprecate the , it is actually based on it and therefore inherits its configuration and great features like pooling. The HttpClient should be used when fine grained control over the HTTP requests/response is necessary.

NOTE: This class has been automatically generated from the io.vertx.ext.web.client.WebClient non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.ext.web.client.WebClient

An asynchronous HTTP / HTTP/2 client called WebClient.

The web client makes easy to do HTTP request/response interactions with a web server, and provides advanced features like:

  • Json body encoding / decoding
  • request/response pumping
  • error handling

The web client does not deprecate the , it is actually based on it and therefore inherits its configuration and great features like pooling. The HttpClient should be used when fine grained control over the HTTP requests/response is necessary.

NOTE: This class has been automatically generated from the io.vertx.ext.web.client.WebClient non RX-ified interface using Vert.x codegen.

io.vertx.ext.web.client.WebClientOptionsConverter

Converter for io.vertx.ext.web.client.WebClientOptions. NOTE: This class has been automatically generated from the io.vertx.ext.web.client.WebClientOptions original class using Vert.x codegen.

io.vertx.core.http.WebSocket

Represents a client-side WebSocket.

io.vertx.rxjava.core.http.WebSocket

Represents a client-side WebSocket. NOTE: This class has been automatically generated from the io.vertx.core.http.WebSocket non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.WebSocket

Represents a client-side WebSocket. NOTE: This class has been automatically generated from the io.vertx.core.http.WebSocket non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.WebSocketBase

Base WebSocket implementation.

It implements both and so it can be used with io.vertx.reactivex.core.streams.Pump to pump data with flow control.

NOTE: This class has been automatically generated from the io.vertx.core.http.WebSocketBase non RX-ified interface using Vert.x codegen.

io.vertx.reactivex.core.http.WebSocketFrame

A WebSocket frame that represents either text or binary data.

A WebSocket message is composed of one or more WebSocket frames.

If there is a just a single frame in the message then a single text or binary frame should be created with final = true.

If there are more than one frames in the message, then the first frame should be a text or binary frame with final = false, followed by one or more continuation frames. The last continuation frame should have final = true.

NOTE: This class has been automatically generated from the io.vertx.core.http.WebSocketFrame non RX-ified interface using Vert.x codegen.

io.vertx.core.spi.WebSocketFrameFactory
io.vertx.core.http.WebsocketRejectedException
io.vertx.core.http.WebsocketVersion

Represents the WebSocket version

io.vertx.core.WorkerExecutor

An executor for executing blocking code in Vert.x .

It provides the same executeBlocking operation than io.vertx.core.Context and io.vertx.core.Vertx but on a separate worker pool.

io.vertx.reactivex.core.WorkerExecutor

An executor for executing blocking code in Vert.x .

It provides the same executeBlocking operation than io.vertx.reactivex.core.Context and io.vertx.reactivex.core.Vertx but on a separate worker pool.

NOTE: This class has been automatically generated from the io.vertx.core.WorkerExecutor non RX-ified interface using Vert.x codegen.

io.vertx.core.streams.WriteStream (extensions in package io.vertx.kotlin.coroutines)
io.vertx.reactivex.core.streams.WriteStream

Represents a stream of data that can be written to.

Any class that implements this interface can be used by a io.vertx.reactivex.core.streams.Pump to pump data from a ReadStream to it.

NOTE: This class has been automatically generated from the io.vertx.core.streams.WriteStream non RX-ified interface using Vert.x codegen.

io.vertx.config.yaml.YamlProcessor

A processor using Jackson and SnakeYaml to read Yaml files.

io.vertx.spi.cluster.zookeeper.ZookeeperClusterManager

A cluster manager that uses Zookeeper

io.vertx.config.zookeeper.ZookeeperConfigStore
io.vertx.config.zookeeper.ZookeeperConfigStoreFactory

Factory to create ZookeeperConfigStore instances.