/** * Set the key/cert options. * * @param options the key store options * @return a reference to this, so the API can be used fluently */ @GenIgnore public TCPSSLOptions setKeyCertOptions(KeyCertOptions options) { this.keyCertOptions = options; return this; }
/** * Generates the usage / help of the current {@link CLI}. * * @param builder the string builder in which the help is going to be printed * @return the current {@link CLI} instance */ @GenIgnore CLI usage(StringBuilder builder);
/** * Like {@link #deployVerticle(Verticle)} but {@link io.vertx.core.DeploymentOptions} are provided to configure the * deployment. * * @param verticle the verticle instance to deploy * @param options the deployment options. */ @GenIgnore(GenIgnore.PERMITTED_TYPE) void deployVerticle(Verticle verticle, DeploymentOptions options);
/** * Like {@link #deployVerticle(Verticle, DeploymentOptions)} but {@link Verticle} instance is created by invoking the * default constructor of {@code verticleClass}. */ @GenIgnore void deployVerticle(Class<? extends Verticle> verticleClass, DeploymentOptions options);
/** * Like {@link #deployVerticle(Verticle, DeploymentOptions, Handler)} but {@link Verticle} instance is created by * invoking the {@code verticleSupplier}. * <p> * The supplier will be invoked as many times as {@link DeploymentOptions#getInstances()}. * It must not return the same instance twice. * <p> * Note that the supplier will be invoked on the caller thread. */ @GenIgnore(GenIgnore.PERMITTED_TYPE) void deployVerticle(Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler);
/** * Copies all of the mappings from the specified map to this map. The effect of this call is equivalent to that * of calling {@link #put(Object, Object) put(k, v)} on this map once for each mapping from key {@code k} to value * {@code v} in the specified map. The behavior of this operation is undefined if the specified map is modified * while the operation is in progress. * * @param m mappings to be stored in this map */ @GenIgnore @Override void putAll(Map<? extends K, ? extends V> m);
/** * Replaces each entry's value with the result of invoking the given * function on that entry until all entries have been processed or the * function throws an exception. Exceptions thrown by the function are * relayed to the caller. * * @param function the function to apply to each entry */ @GenIgnore @Override void replaceAll(BiFunction<? super K, ? super V, ? extends V> function); }
/** * Get the entries of the map, asynchronously. * <p> * Use this method with care as the map may contain a large number of entries, * which may not fit entirely in memory of a single node. * In this case, the invocation will result in an {@link OutOfMemoryError}. * * @param resultHandler invoked when the operation completes */ @GenIgnore void entries(Handler<AsyncResult<Map<K, V>>> resultHandler); }
/** * Close the event bus and release any resources held. This would not normally be called in user code * * @param completionHandler may be {@code null} */ @GenIgnore void close(Handler<AsyncResult<Void>> completionHandler);
/** * Deploy a verticle instance that you have created yourself. * <p> * Vert.x will assign the verticle a context and start the verticle. * <p> * The actual deploy happens asynchronously and may not complete until after the call has returned. * * @param verticle the verticle instance to deploy. */ @GenIgnore(GenIgnore.PERMITTED_TYPE) void deployVerticle(Verticle verticle);
/** * Like {@link #deployVerticle(Verticle, DeploymentOptions, Handler)} but {@link Verticle} instance is created by * invoking the default constructor of {@code verticleClass}. */ @GenIgnore void deployVerticle(Class<? extends Verticle> verticleClass, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler);
/** * Register a {@code VerticleFactory} that can be used for deploying Verticles based on an identifier. * * @param factory the factory to register */ @GenIgnore(GenIgnore.PERMITTED_TYPE) void registerVerticleFactory(VerticleFactory factory);
/** * Unregister a default message codec. * <p> * @param clazz the class for which the codec was registered * @return a reference to this, so the API can be used fluently */ @GenIgnore EventBus unregisterDefaultCodec(Class clazz);
/** * Gets the values of an option with the matching name (can be the long name, short name or arg name). * * @param name the name * @param <T> the expected component type * @return the values, {@code null} if not set * @see #getRawValuesForOption(Option) */ @GenIgnore <T> List<T> getOptionValues(String name);
/** * @return the current redirect handler. */ @GenIgnore Function<HttpClientResponse, Future<HttpClientRequest>> redirectHandler();
/** * Set the extra setting used for extending HTTP/2 * * @param settings the new extra settings * @return a reference to this, so the API can be used fluently */ @GenIgnore public Http2Settings setExtraSettings(Map<Integer, Long> settings) { extraSettings = settings; return this; }
/** * Set message headers from a multi-map. * * @param headers the headers * @return a reference to this, so the API can be used fluently */ @GenIgnore public DeliveryOptions setHeaders(MultiMap headers) { this.headers = headers; return this; }
/** * Like {@link #putTrailer(String, Iterable)} but with CharSequence Iterable */ @GenIgnore(GenIgnore.PERMITTED_TYPE) @Fluent HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value);
/** * Transfers the content of the Buffer starting at position {@code start} and ending at position {@code end - 1} * into a {@code byte[]}. * * @param dst the destination byte array * @throws IndexOutOfBoundsException if the content of the Buffer cannot fit into the destination byte array */ @GenIgnore(GenIgnore.PERMITTED_TYPE) @Fluent Buffer getBytes(int start, int end, byte[] dst);
/** * Cleans and set all values of the given instance * * @return a reference to this, so the API can be used fluently */ @GenIgnore(GenIgnore.PERMITTED_TYPE) @Fluent MultiMap setAll(Map<String, String> headers);