### 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: `#close` `#closeHandler` `#exceptionHandler`
io.vertx.rxjava.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#close` `io.vertx.rxjava.core.http.HttpConnection#closeHandler` `io.vertx.rxjava.core.http.HttpConnection#exceptionHandler` 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: `io.vertx.reactivex.core.http.HttpConnection#close` `io.vertx.reactivex.core.http.HttpConnection#closeHandler` `io.vertx.reactivex.core.http.HttpConnection#exceptionHandler` 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 `#send(Handler)` `#sendStream(ReadStream, Handler)` `#sendJson(Object, Handler)` ()} `#sendForm(MultiMap, Handler)` 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: `io.vertx.rxjava.ext.web.client.HttpResponse#statusCode` the HTTP status code `io.vertx.rxjava.ext.web.client.HttpResponse#statusMessage` the HTTP status message `io.vertx.rxjava.ext.web.client.HttpResponse#headers` the HTTP headers `io.vertx.rxjava.ext.web.client.HttpResponse#version` the HTTP version 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: `io.vertx.reactivex.ext.web.client.HttpResponse#statusCode` the HTTP status code `io.vertx.reactivex.ext.web.client.HttpResponse#statusMessage` the HTTP status message `io.vertx.reactivex.ext.web.client.HttpResponse#headers` the HTTP headers `io.vertx.reactivex.ext.web.client.HttpResponse#version` the HTTP version 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)`: If parameter is valid, call `RequestParameter#create(Object)` 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 (`ValidationException#ValidationException(String)`) and/or with io.vertx.ext.web.api.validation.ValidationException.ErrorType (`ValidationException#ValidationException(String, ValidationException.ErrorType)`). As for value, the validation flow will care about setting all other ValidationException fields
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#upgrade`ed.
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#upgrade`ed. 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#upgrade`ed. 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.