/*
 * Copyright 2014 Red Hat, Inc.
 *
 * Red Hat licenses this file to you under the Apache License, version 2.0
 * (the "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

package io.vertx.rxjava.core.http;

import java.util.Map;
import rx.Observable;
import rx.Single;
import io.vertx.core.http.RequestOptions;
import io.vertx.core.http.WebsocketVersion;
import java.util.function.Function;
import java.util.List;
import io.vertx.core.http.HttpMethod;
import io.vertx.core.http.WebSocketConnectOptions;
import io.vertx.core.AsyncResult;
import io.vertx.core.Handler;

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 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 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 original non RX-ified interface using Vert.x codegen. /**
 * An asynchronous HTTP client.
 * <p>
 * It allows you to make requests to HTTP servers, and a single client can make requests to any server.
 * <p>
 * It also allows you to open WebSockets to servers.
 * <p>
 * The client can also pool HTTP connections.
 * <p>
 * For pooling to occur, keep-alive must be true on the {@link 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.
 * <p>
 * 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.
 * <p>
 * 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.
 * <p>
 * To enable pipe-lining, it must be enabled on the {@link io.vertx.core.http.HttpClientOptions} (default is false).
 * <p>
 * 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.
 * <p>
 * The client is designed to be reused between requests.
 *
 * <p/>
 * NOTE: This class has been automatically generated from the {@link io.vertx.core.http.HttpClient original} non RX-ified interface using Vert.x codegen.
 */

@io.vertx.lang.rx.RxGen(io.vertx.core.http.HttpClient.class)
public class HttpClient implements io.vertx.rxjava.core.metrics.Measured {

  @Override
  public String toString() {
    return delegate.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    HttpClient that = (HttpClient) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  public static final io.vertx.lang.rx.TypeArg<HttpClient> __TYPE_ARG = new io.vertx.lang.rx.TypeArg<>(    obj -> new HttpClient((io.vertx.core.http.HttpClient) obj),
    HttpClient::getDelegate
  );

  private final io.vertx.core.http.HttpClient delegate;
  
  public HttpClient(io.vertx.core.http.HttpClient delegate) {
    this.delegate = delegate;
  }

  public io.vertx.core.http.HttpClient getDelegate() {
    return delegate;
  }

  
Whether the metrics are enabled for this measured object
Returns:
true if metrics are enabled/**
   * Whether the metrics are enabled for this measured object
   * @return <code>true</code> if metrics are enabled
   */
  public boolean isMetricsEnabled() { 
    boolean ret = delegate.isMetricsEnabled();
    return ret;
  }

  
Like request using the serverAddress parameter to connect to the
server instead of the absoluteURI parameter.

The request host header will still be created from the options parameter.

Use  to connect to a unix domain socket server.
Params:
method – 
serverAddress – 
options – 
Returns:
/**
   * Like {@link io.vertx.rxjava.core.http.HttpClient#request} using the <code>serverAddress</code> parameter to connect to the
   * server instead of the <code>absoluteURI</code> parameter.
   * <p>
   * The request host header will still be created from the <code>options</code> parameter.
   * <p>
   * Use  to connect to a unix domain socket server.
   * @param method 
   * @param serverAddress 
   * @param options 
   * @return 
   */
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, io.vertx.rxjava.core.net.SocketAddress serverAddress, RequestOptions options) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, serverAddress.getDelegate(), options));
    return ret;
  }

  
Create an HTTP request to send to the server with the specified options.
Params:
method – the HTTP method
options – the request options
Returns:
an HTTP client request object/**
   * Create an HTTP request to send to the server with the specified options.
   * @param method the HTTP method
   * @param options the request options
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, RequestOptions options) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, options));
    return ret;
  }

  
Create an HTTP request to send to the server at the specified host and port.
Params:
method – the HTTP method
port – the port
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP request to send to the server at the specified host and port.
   * @param method the HTTP method
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, int port, String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, port, host, requestURI));
    return ret;
  }

  
Like request using the serverAddress parameter to connect to the
server instead of the absoluteURI parameter.

The request host header will still be created from the host and port parameters.

Use  to connect to a unix domain socket server.
Params:
method – 
serverAddress – 
port – 
host – 
requestURI – 
Returns:
/**
   * Like {@link io.vertx.rxjava.core.http.HttpClient#request} using the <code>serverAddress</code> parameter to connect to the
   * server instead of the <code>absoluteURI</code> parameter.
   * <p>
   * The request host header will still be created from the <code>host</code> and <code>port</code> parameters.
   * <p>
   * Use  to connect to a unix domain socket server.
   * @param method 
   * @param serverAddress 
   * @param port 
   * @param host 
   * @param requestURI 
   * @return 
   */
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, io.vertx.rxjava.core.net.SocketAddress serverAddress, int port, String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, serverAddress.getDelegate(), port, host, requestURI));
    return ret;
  }

  
Create an HTTP request to send to the server at the specified host and default port.
Params:
method – the HTTP method
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP request to send to the server at the specified host and default port.
   * @param method the HTTP method
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, host, requestURI));
    return ret;
  }

  
Create an HTTP request to send to the server with the specified options, specifying a response handler to receive
Params:
method – the HTTP method
options – the request options
responseHandler – 
Returns:
an HTTP client request object/**
   * Create an HTTP request to send to the server with the specified options, specifying a response handler to receive
   * @param method the HTTP method
   * @param options the request options
   * @param responseHandler 
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Like request using the serverAddress parameter to connect to the
server instead of the absoluteURI parameter.

The request host header will still be created from the options parameter.

Use  to connect to a unix domain socket server.
Params:
method – 
serverAddress – 
options – 
responseHandler – 
Returns:
/**
   * Like {@link io.vertx.rxjava.core.http.HttpClient#request} using the <code>serverAddress</code> parameter to connect to the
   * server instead of the <code>absoluteURI</code> parameter.
   * <p>
   * The request host header will still be created from the <code>options</code> parameter.
   * <p>
   * Use  to connect to a unix domain socket server.
   * @param method 
   * @param serverAddress 
   * @param options 
   * @param responseHandler 
   * @return 
   */
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, io.vertx.rxjava.core.net.SocketAddress serverAddress, RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, serverAddress.getDelegate(), options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP request to send to the server at the specified host and port, specifying a response handler to receive
the response
Params:
method – the HTTP method
port – the port
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP request to send to the server at the specified host and port, specifying a response handler to receive
   * the response
   * @param method the HTTP method
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Like request using the serverAddress parameter to connect to the
server instead of the absoluteURI parameter.

The request host header will still be created from the host and port parameters.

Use  to connect to a unix domain socket server.
Params:
method – 
serverAddress – 
port – 
host – 
requestURI – 
responseHandler – 
Returns:
/**
   * Like {@link io.vertx.rxjava.core.http.HttpClient#request} using the <code>serverAddress</code> parameter to connect to the
   * server instead of the <code>absoluteURI</code> parameter.
   * <p>
   * The request host header will still be created from the <code>host</code> and <code>port</code> parameters.
   * <p>
   * Use  to connect to a unix domain socket server.
   * @param method 
   * @param serverAddress 
   * @param port 
   * @param host 
   * @param requestURI 
   * @param responseHandler 
   * @return 
   */
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, io.vertx.rxjava.core.net.SocketAddress serverAddress, int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, serverAddress.getDelegate(), port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive
the response
Params:
method – the HTTP method
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive
   * the response
   * @param method the HTTP method
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP request to send to the server at the default host and port.
Params:
method – the HTTP method
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP request to send to the server at the default host and port.
   * @param method the HTTP method
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, requestURI));
    return ret;
  }

  
Create an HTTP request to send to the server at the default host and port, specifying a response handler to receive
the response
Params:
method – the HTTP method
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP request to send to the server at the default host and port, specifying a response handler to receive
   * the response
   * @param method the HTTP method
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest request(HttpMethod method, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request(method, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP request to send to the server using an absolute URI
Params:
method – the HTTP method
absoluteURI – the absolute URI
Returns:
an HTTP client request object/**
   * Create an HTTP request to send to the server using an absolute URI
   * @param method the HTTP method
   * @param absoluteURI the absolute URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest requestAbs(HttpMethod method, String absoluteURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.requestAbs(method, absoluteURI));
    return ret;
  }

  
Like requestAbs using the serverAddress parameter to connect to the
server instead of the absoluteURI parameter.

The request host header will still be created from the absoluteURI parameter.

Use  to connect to a unix domain socket server.
Params:
method – 
serverAddress – 
absoluteURI – 
Returns:
/**
   * Like {@link io.vertx.rxjava.core.http.HttpClient#requestAbs} using the <code>serverAddress</code> parameter to connect to the
   * server instead of the <code>absoluteURI</code> parameter.
   * <p>
   * The request host header will still be created from the <code>absoluteURI</code> parameter.
   * <p>
   * Use  to connect to a unix domain socket server.
   * @param method 
   * @param serverAddress 
   * @param absoluteURI 
   * @return 
   */
  public io.vertx.rxjava.core.http.HttpClientRequest requestAbs(HttpMethod method, io.vertx.rxjava.core.net.SocketAddress serverAddress, String absoluteURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.requestAbs(method, serverAddress.getDelegate(), absoluteURI));
    return ret;
  }

  
Create an HTTP request to send to the server using an absolute URI, specifying a response handler to receive
the response
Params:
method – the HTTP method
absoluteURI – the absolute URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP request to send to the server using an absolute URI, specifying a response handler to receive
   * the response
   * @param method the HTTP method
   * @param absoluteURI the absolute URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest requestAbs(HttpMethod method, String absoluteURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.requestAbs(method, absoluteURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Like requestAbs using the serverAddress parameter to connect to the
server instead of the absoluteURI parameter.

The request host header will still be created from the absoluteURI parameter.

Use  to connect to a unix domain socket server.
Params:
method – 
serverAddress – 
absoluteURI – 
responseHandler – 
Returns:
/**
   * Like {@link io.vertx.rxjava.core.http.HttpClient#requestAbs} using the <code>serverAddress</code> parameter to connect to the
   * server instead of the <code>absoluteURI</code> parameter.
   * <p>
   * The request host header will still be created from the <code>absoluteURI</code> parameter.
   * <p>
   * Use  to connect to a unix domain socket server.
   * @param method 
   * @param serverAddress 
   * @param absoluteURI 
   * @param responseHandler 
   * @return 
   */
  public io.vertx.rxjava.core.http.HttpClientRequest requestAbs(HttpMethod method, io.vertx.rxjava.core.net.SocketAddress serverAddress, String absoluteURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.requestAbs(method, serverAddress.getDelegate(), absoluteURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP GET request to send to the server with the specified options.
Params:
options – the request options
Returns:
an HTTP client request object/**
   * Create an HTTP GET request to send to the server with the specified options.
   * @param options the request options
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest get(RequestOptions options) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.get(options));
    return ret;
  }

  
Create an HTTP GET request to send to the server at the specified host and port.
Params:
port – the port
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP GET request to send to the server at the specified host and port.
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest get(int port, String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.get(port, host, requestURI));
    return ret;
  }

  
Create an HTTP GET request to send to the server at the specified host and default port.
Params:
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP GET request to send to the server at the specified host and default port.
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest get(String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.get(host, requestURI));
    return ret;
  }

  
Create an HTTP GET request to send to the server with the specified options, specifying a response handler to receive
the response
Params:
options – the request options
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP GET request to send to the server with the specified options, specifying a response handler to receive
   * the response
   * @param options the request options
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest get(RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.get(options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP GET request to send to the server at the specified host and port, specifying a response handler to receive
the response
Params:
port – the port
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP GET request to send to the server at the specified host and port, specifying a response handler to receive
   * the response
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest get(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.get(port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP GET request to send to the server at the specified host and default port, specifying a response handler to receive
the response
Params:
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP GET request to send to the server at the specified host and default port, specifying a response handler to receive
   * the response
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest get(String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.get(host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP GET request to send to the server at the default host and port.
Params:
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP GET request to send to the server at the default host and port.
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest get(String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.get(requestURI));
    return ret;
  }

  
Create an HTTP GET request to send to the server at the default host and port, specifying a response handler to receive
the response
Params:
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP GET request to send to the server at the default host and port, specifying a response handler to receive
   * the response
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest get(String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.get(requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP GET request to send to the server using an absolute URI
Params:
absoluteURI – the absolute URI
Returns:
an HTTP client request object/**
   * Create an HTTP GET request to send to the server using an absolute URI
   * @param absoluteURI the absolute URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest getAbs(String absoluteURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.getAbs(absoluteURI));
    return ret;
  }

  
Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive
the response
Params:
absoluteURI – the absolute URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive
   * the response
   * @param absoluteURI the absolute URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest getAbs(String absoluteURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.getAbs(absoluteURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Sends an HTTP GET request to the server with the specified options, specifying a response handler to receive
the response
Params:
options – the request options
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP GET request to the server with the specified options, specifying a response handler to receive
   * the response
   * @param options the request options
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient getNow(RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.getNow(options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive
the response
Params:
port – the port
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive
   * the response
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient getNow(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.getNow(port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive
the response
Params:
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive
   * the response
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient getNow(String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.getNow(host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Sends an HTTP GET request  to the server at the default host and port, specifying a response handler to receive
the response
Params:
requestURI – the relative URI
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP GET request  to the server at the default host and port, specifying a response handler to receive
   * the response
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient getNow(String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.getNow(requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Create an HTTP POST request to send to the server with the specified options.
Params:
options – the request options
Returns:
an HTTP client request object/**
   * Create an HTTP POST request to send to the server with the specified options.
   * @param options the request options
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest post(RequestOptions options) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.post(options));
    return ret;
  }

  
Create an HTTP POST request to send to the server at the specified host and port.
Params:
port – the port
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP POST request to send to the server at the specified host and port.
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest post(int port, String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.post(port, host, requestURI));
    return ret;
  }

  
Create an HTTP POST request to send to the server at the specified host and default port.
Params:
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP POST request to send to the server at the specified host and default port.
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest post(String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.post(host, requestURI));
    return ret;
  }

  
Create an HTTP POST request to send to the server with the specified options, specifying a response handler to receive
the response
Params:
options – the request options
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP POST request to send to the server with the specified options, specifying a response handler to receive
   * the response
   * @param options the request options
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest post(RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.post(options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive
the response
Params:
port – the port
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive
   * the response
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest post(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.post(port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive
the response
Params:
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive
   * the response
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest post(String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.post(host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP POST request to send to the server at the default host and port.
Params:
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP POST request to send to the server at the default host and port.
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest post(String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.post(requestURI));
    return ret;
  }

  
Create an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive
the response
Params:
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive
   * the response
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest post(String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.post(requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP POST request to send to the server using an absolute URI
Params:
absoluteURI – the absolute URI
Returns:
an HTTP client request object/**
   * Create an HTTP POST request to send to the server using an absolute URI
   * @param absoluteURI the absolute URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest postAbs(String absoluteURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.postAbs(absoluteURI));
    return ret;
  }

  
Create an HTTP POST request to send to the server using an absolute URI, specifying a response handler to receive
the response
Params:
absoluteURI – the absolute URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP POST request to send to the server using an absolute URI, specifying a response handler to receive
   * the response
   * @param absoluteURI the absolute URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest postAbs(String absoluteURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.postAbs(absoluteURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP HEAD request to send to the server with the specified options.
Params:
options – the request options
Returns:
an HTTP client request object/**
   * Create an HTTP HEAD request to send to the server with the specified options.
   * @param options the request options
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest head(RequestOptions options) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.head(options));
    return ret;
  }

  
Create an HTTP HEAD request to send to the server at the specified host and port.
Params:
port – the port
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP HEAD request to send to the server at the specified host and port.
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest head(int port, String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.head(port, host, requestURI));
    return ret;
  }

  
Create an HTTP HEAD request to send to the server at the specified host and default port.
Params:
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP HEAD request to send to the server at the specified host and default port.
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest head(String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.head(host, requestURI));
    return ret;
  }

  
Create an HTTP HEAD request to send to the server with the specified options, specifying a response handler to receive
the response
Params:
options – the request options
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP HEAD request to send to the server with the specified options, specifying a response handler to receive
   * the response
   * @param options the request options
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest head(RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.head(options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP HEAD request to send to the server at the specified host and port, specifying a response handler to receive
the response
Params:
port – the port
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP HEAD request to send to the server at the specified host and port, specifying a response handler to receive
   * the response
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest head(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.head(port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP HEAD request to send to the server at the specified host and default port, specifying a response handler to receive
the response
Params:
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP HEAD request to send to the server at the specified host and default port, specifying a response handler to receive
   * the response
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest head(String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.head(host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP HEAD request to send to the server at the default host and port.
Params:
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP HEAD request to send to the server at the default host and port.
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest head(String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.head(requestURI));
    return ret;
  }

  
Create an HTTP HEAD request to send to the server at the default host and port, specifying a response handler to receive
the response
Params:
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP HEAD request to send to the server at the default host and port, specifying a response handler to receive
   * the response
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest head(String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.head(requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP HEAD request to send to the server using an absolute URI
Params:
absoluteURI – the absolute URI
Returns:
an HTTP client request object/**
   * Create an HTTP HEAD request to send to the server using an absolute URI
   * @param absoluteURI the absolute URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest headAbs(String absoluteURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.headAbs(absoluteURI));
    return ret;
  }

  
Create an HTTP HEAD request to send to the server using an absolute URI, specifying a response handler to receive
the response
Params:
absoluteURI – the absolute URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP HEAD request to send to the server using an absolute URI, specifying a response handler to receive
   * the response
   * @param absoluteURI the absolute URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest headAbs(String absoluteURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.headAbs(absoluteURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Sends an HTTP HEAD request to the server with the specified options, specifying a response handler to receive
the response
Params:
options – the request options
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP HEAD request to the server with the specified options, specifying a response handler to receive
   * the response
   * @param options the request options
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient headNow(RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.headNow(options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive
the response
Params:
port – the port
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive
   * the response
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient headNow(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.headNow(port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive
the response
Params:
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive
   * the response
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient headNow(String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.headNow(host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Sends an HTTP HEAD request  to the server at the default host and port, specifying a response handler to receive
the response
Params:
requestURI – the relative URI
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP HEAD request  to the server at the default host and port, specifying a response handler to receive
   * the response
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient headNow(String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.headNow(requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Create an HTTP OPTIONS request to send to the server with the specified options.
Params:
options – the request options
Returns:
an HTTP client request object/**
   * Create an HTTP OPTIONS request to send to the server with the specified options.
   * @param options the request options
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest options(RequestOptions options) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.options(options));
    return ret;
  }

  
Create an HTTP OPTIONS request to send to the server at the specified host and port.
Params:
port – the port
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP OPTIONS request to send to the server at the specified host and port.
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest options(int port, String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.options(port, host, requestURI));
    return ret;
  }

  
Create an HTTP OPTIONS request to send to the server at the specified host and default port.
Params:
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP OPTIONS request to send to the server at the specified host and default port.
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest options(String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.options(host, requestURI));
    return ret;
  }

  
Create an HTTP OPTIONS request to send to the server with the specified options, specifying a response handler to receive
the response
Params:
options – the request options
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP OPTIONS request to send to the server with the specified options, specifying a response handler to receive
   * the response
   * @param options the request options
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest options(RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.options(options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive
the response
Params:
port – the port
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive
   * the response
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest options(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.options(port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive
the response
Params:
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive
   * the response
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest options(String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.options(host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP OPTIONS request to send to the server at the default host and port.
Params:
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP OPTIONS request to send to the server at the default host and port.
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest options(String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.options(requestURI));
    return ret;
  }

  
Create an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive
the response
Params:
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive
   * the response
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest options(String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.options(requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP OPTIONS request to send to the server using an absolute URI
Params:
absoluteURI – the absolute URI
Returns:
an HTTP client request object/**
   * Create an HTTP OPTIONS request to send to the server using an absolute URI
   * @param absoluteURI the absolute URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest optionsAbs(String absoluteURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.optionsAbs(absoluteURI));
    return ret;
  }

  
Create an HTTP OPTIONS request to send to the server using an absolute URI, specifying a response handler to receive
the response
Params:
absoluteURI – the absolute URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP OPTIONS request to send to the server using an absolute URI, specifying a response handler to receive
   * the response
   * @param absoluteURI the absolute URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest optionsAbs(String absoluteURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.optionsAbs(absoluteURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Sends an HTTP OPTIONS request to the server with the specified options, specifying a response handler to receive
the response
Params:
options – the request options
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP OPTIONS request to the server with the specified options, specifying a response handler to receive
   * the response
   * @param options the request options
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient optionsNow(RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.optionsNow(options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Sends an HTTP OPTIONS request to the server at the specified host and port, specifying a response handler to receive
the response
Params:
port – the port
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP OPTIONS request to the server at the specified host and port, specifying a response handler to receive
   * the response
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient optionsNow(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.optionsNow(port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Sends an HTTP OPTIONS request to the server at the specified host and default port, specifying a response handler to receive
the response
Params:
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP OPTIONS request to the server at the specified host and default port, specifying a response handler to receive
   * the response
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient optionsNow(String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.optionsNow(host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Sends an HTTP OPTIONS request  to the server at the default host and port, specifying a response handler to receive
the response
Params:
requestURI – the relative URI
responseHandler – the response handler
Returns:
a reference to this, so the API can be used fluently/**
   * Sends an HTTP OPTIONS request  to the server at the default host and port, specifying a response handler to receive
   * the response
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient optionsNow(String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    delegate.optionsNow(requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    });
    return this;
  }

  
Create an HTTP PUT request to send to the server with the specified options.
Params:
options – the request options
Returns:
an HTTP client request object/**
   * Create an HTTP PUT request to send to the server with the specified options.
   * @param options the request options
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest put(RequestOptions options) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.put(options));
    return ret;
  }

  
Create an HTTP PUT request to send to the server at the specified host and port.
Params:
port – the port
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP PUT request to send to the server at the specified host and port.
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest put(int port, String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.put(port, host, requestURI));
    return ret;
  }

  
Create an HTTP PUT request to send to the server at the specified host and default port.
Params:
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP PUT request to send to the server at the specified host and default port.
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest put(String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.put(host, requestURI));
    return ret;
  }

  
Create an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive
the response
Params:
options – the request options
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive
   * the response
   * @param options the request options
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest put(RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.put(options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive
the response
Params:
port – the port
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive
   * the response
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest put(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.put(port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive
the response
Params:
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive
   * the response
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest put(String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.put(host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP PUT request to send to the server at the default host and port.
Params:
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP PUT request to send to the server at the default host and port.
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest put(String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.put(requestURI));
    return ret;
  }

  
Create an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive
the response
Params:
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive
   * the response
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest put(String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.put(requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP PUT request to send to the server using an absolute URI
Params:
absoluteURI – the absolute URI
Returns:
an HTTP client request object/**
   * Create an HTTP PUT request to send to the server using an absolute URI
   * @param absoluteURI the absolute URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest putAbs(String absoluteURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.putAbs(absoluteURI));
    return ret;
  }

  
Create an HTTP PUT request to send to the server using an absolute URI, specifying a response handler to receive
the response
Params:
absoluteURI – the absolute URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP PUT request to send to the server using an absolute URI, specifying a response handler to receive
   * the response
   * @param absoluteURI the absolute URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest putAbs(String absoluteURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.putAbs(absoluteURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP DELETE request to send to the server with the specified options.
Params:
options – the request options
Returns:
an HTTP client request object/**
   * Create an HTTP DELETE request to send to the server with the specified options.
   * @param options the request options
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest delete(RequestOptions options) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.delete(options));
    return ret;
  }

  
Create an HTTP DELETE request to send to the server at the specified host and port.
Params:
port – the port
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP DELETE request to send to the server at the specified host and port.
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest delete(int port, String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.delete(port, host, requestURI));
    return ret;
  }

  
Create an HTTP DELETE request to send to the server at the specified host and default port.
Params:
host – the host
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP DELETE request to send to the server at the specified host and default port.
   * @param host the host
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest delete(String host, String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.delete(host, requestURI));
    return ret;
  }

  
Create an HTTP DELETE request to send to the server with the specified options, specifying a response handler to receive
the response
Params:
options – the request options
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP DELETE request to send to the server with the specified options, specifying a response handler to receive
   * the response
   * @param options the request options
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest delete(RequestOptions options, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.delete(options, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive
the response
Params:
port – the port
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive
   * the response
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest delete(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.delete(port, host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive
the response
Params:
host – the host
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive
   * the response
   * @param host the host
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest delete(String host, String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.delete(host, requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP DELETE request to send to the server at the default host and port.
Params:
requestURI – the relative URI
Returns:
an HTTP client request object/**
   * Create an HTTP DELETE request to send to the server at the default host and port.
   * @param requestURI the relative URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest delete(String requestURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.delete(requestURI));
    return ret;
  }

  
Create an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive
the response
Params:
requestURI – the relative URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive
   * the response
   * @param requestURI the relative URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest delete(String requestURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.delete(requestURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Create an HTTP DELETE request to send to the server using an absolute URI
Params:
absoluteURI – the absolute URI
Returns:
an HTTP client request object/**
   * Create an HTTP DELETE request to send to the server using an absolute URI
   * @param absoluteURI the absolute URI
   * @return an HTTP client request object
   */
  public io.vertx.rxjava.core.http.HttpClientRequest deleteAbs(String absoluteURI) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.deleteAbs(absoluteURI));
    return ret;
  }

  
Create an HTTP DELETE request to send to the server using an absolute URI, specifying a response handler to receive
the response
Params:
absoluteURI – the absolute URI
responseHandler – the response handler
Returns:
an HTTP client request object/**
   * Create an HTTP DELETE request to send to the server using an absolute URI, specifying a response handler to receive
   * the response
   * @param absoluteURI the absolute URI
   * @param responseHandler the response handler
   * @return an HTTP client request object
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClientRequest deleteAbs(String absoluteURI, Handler<io.vertx.rxjava.core.http.HttpClientResponse> responseHandler) { 
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.deleteAbs(absoluteURI, new Handler<io.vertx.core.http.HttpClientResponse>() {
      public void handle(io.vertx.core.http.HttpClientResponse event) {
        responseHandler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(event));
      }
    }));
    return ret;
  }

  
Connect a WebSocket with the specified options
Params:
options – the request options
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket with the specified options
   * @param options the request options
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(RequestOptions options, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(options, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket to the specified port, host and relative request URI
Params:
port – the port
host – the host
requestURI – the relative URI
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified port, host and relative request URI
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(port, host, requestURI, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket with the specified options
Params:
options – the request options
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket with the specified options
   * @param options the request options
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(RequestOptions options, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(options, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket to the specified port, host and relative request URI
Params:
port – the port
host – the host
requestURI – the relative URI
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified port, host and relative request URI
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(int port, String host, String requestURI, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(port, host, requestURI, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket to the host and relative request URI and default port
Params:
host – the host
requestURI – the relative URI
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the host and relative request URI and default port
   * @param host the host
   * @param requestURI the relative URI
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String host, String requestURI, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(host, requestURI, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket to the host and relative request URI and default port
Params:
host – the host
requestURI – the relative URI
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the host and relative request URI and default port
   * @param host the host
   * @param requestURI the relative URI
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String host, String requestURI, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(host, requestURI, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket with the specified options, and with the specified headers
Params:
options – the request options
headers – the headers
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket with the specified options, and with the specified headers
   * @param options the request options
   * @param headers the headers
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(RequestOptions options, io.vertx.rxjava.core.MultiMap headers, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(options, headers.getDelegate(), new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
Params:
port – the port
host – the host
requestURI – the relative URI
headers – the headers
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(int port, String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(port, host, requestURI, headers.getDelegate(), new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket with the specified options, and with the specified headers
Params:
options – the request options
headers – the headers
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket with the specified options, and with the specified headers
   * @param options the request options
   * @param headers the headers
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(RequestOptions options, io.vertx.rxjava.core.MultiMap headers, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(options, headers.getDelegate(), new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
Params:
port – the port
host – the host
requestURI – the relative URI
headers – the headers
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(int port, String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(port, host, requestURI, headers.getDelegate(), new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
Params:
host – the host
requestURI – the relative URI
headers – the headers
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(host, requestURI, headers.getDelegate(), new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
Params:
host – the host
requestURI – the relative URI
headers – the headers
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(host, requestURI, headers.getDelegate(), new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket with the specified optionsI, with the specified headers and using
the specified version of WebSockets
Params:
options – the request options
headers – the headers
version – the websocket version
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket with the specified optionsI, with the specified headers and using
   * the specified version of WebSockets
   * @param options the request options
   * @param headers the headers
   * @param version the websocket version
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(RequestOptions options, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(options, headers.getDelegate(), version, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using
the specified version of WebSockets
Params:
port – the port
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using
   * the specified version of WebSockets
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(int port, String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(port, host, requestURI, headers.getDelegate(), version, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket with the specified options, with the specified headers and using
the specified version of WebSockets
Params:
options – the request options
headers – the headers
version – the websocket version
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket with the specified options, with the specified headers and using
   * the specified version of WebSockets
   * @param options the request options
   * @param headers the headers
   * @param version the websocket version
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(RequestOptions options, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(options, headers.getDelegate(), version, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using
the specified version of WebSockets
Params:
port – the port
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using
   * the specified version of WebSockets
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(int port, String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(port, host, requestURI, headers.getDelegate(), version, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using
the specified version of WebSockets
Params:
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using
   * the specified version of WebSockets
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(host, requestURI, headers.getDelegate(), version, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using
the specified version of WebSockets
Params:
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using
   * the specified version of WebSockets
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(host, requestURI, headers.getDelegate(), version, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket with the specified options, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
Params:
options – the request options
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket with the specified options, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols
   * @param options the request options
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(RequestOptions options, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(options, headers.getDelegate(), version, subProtocols, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
Params:
port – the port
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(int port, String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(port, host, requestURI, headers.getDelegate(), version, subProtocols, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket with the specified absolute url, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols.
Params:
url – the absolute url
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket with the specified absolute url, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols.
   * @param url the absolute url
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocketAbs(String url, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocketAbs(url, headers.getDelegate(), version, subProtocols, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket with the specified options, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
Params:
options – the request options
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket with the specified options, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols
   * @param options the request options
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(RequestOptions options, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(options, headers.getDelegate(), version, subProtocols, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
Params:
port – the port
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(int port, String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(port, host, requestURI, headers.getDelegate(), version, subProtocols, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
Params:
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(host, requestURI, headers.getDelegate(), version, subProtocols, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
Params:
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(host, requestURI, headers.getDelegate(), version, subProtocols, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket at the relative request URI using the default host and port
Params:
requestURI – the relative URI
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket at the relative request URI using the default host and port
   * @param requestURI the relative URI
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String requestURI, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(requestURI, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket at the relative request URI using the default host and port
Params:
requestURI – the relative URI
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket at the relative request URI using the default host and port
   * @param requestURI the relative URI
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String requestURI, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(requestURI, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket at the relative request URI using the default host and port and the specified headers
Params:
requestURI – the relative URI
headers – the headers
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket at the relative request URI using the default host and port and the specified headers
   * @param requestURI the relative URI
   * @param headers the headers
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String requestURI, io.vertx.rxjava.core.MultiMap headers, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(requestURI, headers.getDelegate(), new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket at the relative request URI using the default host and port and the specified headers
Params:
requestURI – the relative URI
headers – the headers
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket at the relative request URI using the default host and port and the specified headers
   * @param requestURI the relative URI
   * @param headers the headers
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String requestURI, io.vertx.rxjava.core.MultiMap headers, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(requestURI, headers.getDelegate(), new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the
specified version of WebSockets
Params:
requestURI – the relative URI
headers – the headers
version – the websocket version
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the
   * specified version of WebSockets
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(requestURI, headers.getDelegate(), version, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the
specified version of WebSockets
Params:
requestURI – the relative URI
headers – the headers
version – the websocket version
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the
   * specified version of WebSockets
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(requestURI, headers.getDelegate(), version, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the
specified version of WebSockets and the specified sub protocols
Params:
requestURI – the relative URI
headers – the headers
version – the websocket version
subProtocols – the subprotocols
wsConnect – handler that will be called with the websocket when connected
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the
   * specified version of WebSockets and the specified sub protocols
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols
   * @param wsConnect handler that will be called with the websocket when connected
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect) { 
    delegate.websocket(requestURI, headers.getDelegate(), version, subProtocols, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    });
    return this;
  }

  
Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the
specified version of WebSockets and the specified sub protocols
Params:
requestURI – the relative URI
headers – the headers
version – the websocket version
subProtocols – the subprotocols
wsConnect – handler that will be called with the websocket when connected
failureHandler – handler that will be called if websocket connection fails
Returns:
a reference to this, so the API can be used fluently/**
   * Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the
   * specified version of WebSockets and the specified sub protocols
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols
   * @param wsConnect handler that will be called with the websocket when connected
   * @param failureHandler handler that will be called if websocket connection fails
   * @return a reference to this, so the API can be used fluently
   */
  @Deprecated()
  public io.vertx.rxjava.core.http.HttpClient websocket(String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols, Handler<io.vertx.rxjava.core.http.WebSocket> wsConnect, Handler<Throwable> failureHandler) { 
    delegate.websocket(requestURI, headers.getDelegate(), version, subProtocols, new Handler<io.vertx.core.http.WebSocket>() {
      public void handle(io.vertx.core.http.WebSocket event) {
        wsConnect.handle(io.vertx.rxjava.core.http.WebSocket.newInstance(event));
      }
    }, failureHandler);
    return this;
  }

  
Connect a WebSocket to the specified port, host and relative request URI
Params:
port – the port
host – the host
requestURI – the relative URI
handler – handler that will be called with the websocket when connected/**
   * Connect a WebSocket to the specified port, host and relative request URI
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param handler handler that will be called with the websocket when connected
   */
  public void webSocket(int port, String host, String requestURI, Handler<AsyncResult<io.vertx.rxjava.core.http.WebSocket>> handler) { 
    delegate.webSocket(port, host, requestURI, new Handler<AsyncResult<io.vertx.core.http.WebSocket>>() {
      public void handle(AsyncResult<io.vertx.core.http.WebSocket> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.core.http.WebSocket.newInstance(ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
  }

    
Connect a WebSocket to the specified port, host and relative request URI
Params:
port – the port
host – the host
requestURI – the relative URI
Returns:
Deprecated:
use rxWebSocket instead/**
   * Connect a WebSocket to the specified port, host and relative request URI
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @return 
   * @deprecated use {@link #rxWebSocket} instead
   */
  @Deprecated()
  public Observable<io.vertx.rxjava.core.http.WebSocket> webSocketObservable(int port, String host, String requestURI) { 
    io.vertx.rx.java.ObservableFuture<io.vertx.rxjava.core.http.WebSocket> handler = io.vertx.rx.java.RxHelper.observableFuture();
    webSocket(port, host, requestURI, handler.toHandler());
    return handler;
  }

  
Connect a WebSocket to the specified port, host and relative request URI
Params:
port – the port
host – the host
requestURI – the relative URI
Returns:
/**
   * Connect a WebSocket to the specified port, host and relative request URI
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @return 
   */
  public Single<io.vertx.rxjava.core.http.WebSocket> rxWebSocket(int port, String host, String requestURI) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      webSocket(port, host, requestURI, fut);
    }));
  }

  
Connect a WebSocket to the host and relative request URI and default port
Params:
host – the host
requestURI – the relative URI
handler – handler that will be called with the websocket when connected/**
   * Connect a WebSocket to the host and relative request URI and default port
   * @param host the host
   * @param requestURI the relative URI
   * @param handler handler that will be called with the websocket when connected
   */
  public void webSocket(String host, String requestURI, Handler<AsyncResult<io.vertx.rxjava.core.http.WebSocket>> handler) { 
    delegate.webSocket(host, requestURI, new Handler<AsyncResult<io.vertx.core.http.WebSocket>>() {
      public void handle(AsyncResult<io.vertx.core.http.WebSocket> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.core.http.WebSocket.newInstance(ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
  }

    
Connect a WebSocket to the host and relative request URI and default port
Params:
host – the host
requestURI – the relative URI
Returns:
Deprecated:
use rxWebSocket instead/**
   * Connect a WebSocket to the host and relative request URI and default port
   * @param host the host
   * @param requestURI the relative URI
   * @return 
   * @deprecated use {@link #rxWebSocket} instead
   */
  @Deprecated()
  public Observable<io.vertx.rxjava.core.http.WebSocket> webSocketObservable(String host, String requestURI) { 
    io.vertx.rx.java.ObservableFuture<io.vertx.rxjava.core.http.WebSocket> handler = io.vertx.rx.java.RxHelper.observableFuture();
    webSocket(host, requestURI, handler.toHandler());
    return handler;
  }

  
Connect a WebSocket to the host and relative request URI and default port
Params:
host – the host
requestURI – the relative URI
Returns:
/**
   * Connect a WebSocket to the host and relative request URI and default port
   * @param host the host
   * @param requestURI the relative URI
   * @return 
   */
  public Single<io.vertx.rxjava.core.http.WebSocket> rxWebSocket(String host, String requestURI) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      webSocket(host, requestURI, fut);
    }));
  }

  
Connect a WebSocket at the relative request URI using the default host and port
Params:
requestURI – the relative URI
handler – handler that will be called with the websocket when connected/**
   * Connect a WebSocket at the relative request URI using the default host and port
   * @param requestURI the relative URI
   * @param handler handler that will be called with the websocket when connected
   */
  public void webSocket(String requestURI, Handler<AsyncResult<io.vertx.rxjava.core.http.WebSocket>> handler) { 
    delegate.webSocket(requestURI, new Handler<AsyncResult<io.vertx.core.http.WebSocket>>() {
      public void handle(AsyncResult<io.vertx.core.http.WebSocket> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.core.http.WebSocket.newInstance(ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
  }

    
Connect a WebSocket at the relative request URI using the default host and port
Params:
requestURI – the relative URI
Returns:
Deprecated:
use rxWebSocket instead/**
   * Connect a WebSocket at the relative request URI using the default host and port
   * @param requestURI the relative URI
   * @return 
   * @deprecated use {@link #rxWebSocket} instead
   */
  @Deprecated()
  public Observable<io.vertx.rxjava.core.http.WebSocket> webSocketObservable(String requestURI) { 
    io.vertx.rx.java.ObservableFuture<io.vertx.rxjava.core.http.WebSocket> handler = io.vertx.rx.java.RxHelper.observableFuture();
    webSocket(requestURI, handler.toHandler());
    return handler;
  }

  
Connect a WebSocket at the relative request URI using the default host and port
Params:
requestURI – the relative URI
Returns:
/**
   * Connect a WebSocket at the relative request URI using the default host and port
   * @param requestURI the relative URI
   * @return 
   */
  public Single<io.vertx.rxjava.core.http.WebSocket> rxWebSocket(String requestURI) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      webSocket(requestURI, fut);
    }));
  }

  
Connect a WebSocket with the specified options.
Params:
options – the request options
handler – /**
   * Connect a WebSocket with the specified options.
   * @param options the request options
   * @param handler 
   */
  public void webSocket(WebSocketConnectOptions options, Handler<AsyncResult<io.vertx.rxjava.core.http.WebSocket>> handler) { 
    delegate.webSocket(options, new Handler<AsyncResult<io.vertx.core.http.WebSocket>>() {
      public void handle(AsyncResult<io.vertx.core.http.WebSocket> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.core.http.WebSocket.newInstance(ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
  }

    
Connect a WebSocket with the specified options.
Params:
options – the request options
Returns:
Deprecated:
use rxWebSocket instead/**
   * Connect a WebSocket with the specified options.
   * @param options the request options
   * @return 
   * @deprecated use {@link #rxWebSocket} instead
   */
  @Deprecated()
  public Observable<io.vertx.rxjava.core.http.WebSocket> webSocketObservable(WebSocketConnectOptions options) { 
    io.vertx.rx.java.ObservableFuture<io.vertx.rxjava.core.http.WebSocket> handler = io.vertx.rx.java.RxHelper.observableFuture();
    webSocket(options, handler.toHandler());
    return handler;
  }

  
Connect a WebSocket with the specified options.
Params:
options – the request options
Returns:
/**
   * Connect a WebSocket with the specified options.
   * @param options the request options
   * @return 
   */
  public Single<io.vertx.rxjava.core.http.WebSocket> rxWebSocket(WebSocketConnectOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      webSocket(options, fut);
    }));
  }

  
Connect a WebSocket with the specified absolute url, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols.
Params:
url – the absolute url
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
handler – handler that will be called if websocket connection fails/**
   * Connect a WebSocket with the specified absolute url, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols.
   * @param url the absolute url
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @param handler handler that will be called if websocket connection fails
   */
  public void webSocketAbs(String url, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, List<String> subProtocols, Handler<AsyncResult<io.vertx.rxjava.core.http.WebSocket>> handler) { 
    delegate.webSocketAbs(url, headers.getDelegate(), version, subProtocols, new Handler<AsyncResult<io.vertx.core.http.WebSocket>>() {
      public void handle(AsyncResult<io.vertx.core.http.WebSocket> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.core.http.WebSocket.newInstance(ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
  }

    
Connect a WebSocket with the specified absolute url, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols.
Params:
url – the absolute url
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
Returns:
Deprecated:
use rxWebSocketAbs instead/**
   * Connect a WebSocket with the specified absolute url, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols.
   * @param url the absolute url
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @return 
   * @deprecated use {@link #rxWebSocketAbs} instead
   */
  @Deprecated()
  public Observable<io.vertx.rxjava.core.http.WebSocket> webSocketAbsObservable(String url, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, List<String> subProtocols) { 
    io.vertx.rx.java.ObservableFuture<io.vertx.rxjava.core.http.WebSocket> handler = io.vertx.rx.java.RxHelper.observableFuture();
    webSocketAbs(url, headers, version, subProtocols, handler.toHandler());
    return handler;
  }

  
Connect a WebSocket with the specified absolute url, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols.
Params:
url – the absolute url
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
Returns:
/**
   * Connect a WebSocket with the specified absolute url, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols.
   * @param url the absolute url
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @return 
   */
  public Single<io.vertx.rxjava.core.http.WebSocket> rxWebSocketAbs(String url, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, List<String> subProtocols) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      webSocketAbs(url, headers, version, subProtocols, fut);
    }));
  }

  
Create a WebSocket stream with the specified options
Params:
options – the request options
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream with the specified options
   * @param options the request options
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(RequestOptions options) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(options), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream to the specified port, host and relative request URI
Params:
port – the port
host – the host
requestURI – the relative URI
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream to the specified port, host and relative request URI
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(int port, String host, String requestURI) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(port, host, requestURI), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream to the specified host, relative request URI and default port
Params:
host – the host
requestURI – the relative URI
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream to the specified host, relative request URI and default port
   * @param host the host
   * @param requestURI the relative URI
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(String host, String requestURI) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(host, requestURI), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream with the specified options, and with the specified headers
Params:
options – the request options
headers – the headers
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream with the specified options, and with the specified headers
   * @param options the request options
   * @param headers the headers
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(RequestOptions options, io.vertx.rxjava.core.MultiMap headers) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(options, headers.getDelegate()), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream to the specified port, host and relative request URI, and with the specified headers
Params:
port – the port
host – the host
requestURI – the relative URI
headers – the headers
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream to the specified port, host and relative request URI, and with the specified headers
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(int port, String host, String requestURI, io.vertx.rxjava.core.MultiMap headers) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(port, host, requestURI, headers.getDelegate()), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream to the specified host, relative request URI and default port and with the specified headers
Params:
host – the host
requestURI – the relative URI
headers – the headers
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream to the specified host, relative request URI and default port and with the specified headers
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(String host, String requestURI, io.vertx.rxjava.core.MultiMap headers) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(host, requestURI, headers.getDelegate()), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream with the specified options, with the specified headers and using
the specified version of WebSockets
Params:
options – the request options
headers – the headers
version – the websocket version
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream with the specified options, with the specified headers and using
   * the specified version of WebSockets
   * @param options the request options
   * @param headers the headers
   * @param version the websocket version
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(RequestOptions options, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(options, headers.getDelegate(), version), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream to the specified port, host and relative request URI, with the specified headers and using
the specified version of WebSockets
Params:
port – the port
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream to the specified port, host and relative request URI, with the specified headers and using
   * the specified version of WebSockets
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(int port, String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(port, host, requestURI, headers.getDelegate(), version), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream with the specified options and with the specified headers and using
the specified version of WebSockets
Params:
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream with the specified options and with the specified headers and using
   * the specified version of WebSockets
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(host, requestURI, headers.getDelegate(), version), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream with the specified absolute url, the specified headers, using the specified version of WebSockets,
and the specified websocket sub protocols.
Params:
url – the absolute url
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream with the specified absolute url, the specified headers, using the specified version of WebSockets,
   * and the specified websocket sub protocols.
   * @param url the absolute url
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStreamAbs(String url, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStreamAbs(url, headers.getDelegate(), version, subProtocols), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream to the specified port, host and relative request URI, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
Params:
options – the request options
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream to the specified port, host and relative request URI, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols
   * @param options the request options
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(RequestOptions options, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(options, headers.getDelegate(), version, subProtocols), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream to the specified port, host and relative request URI, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
Params:
port – the port
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream to the specified port, host and relative request URI, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols
   * @param port the port
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(int port, String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(port, host, requestURI, headers.getDelegate(), version, subProtocols), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream to the specified host, relative request URI and default port, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
Params:
host – the host
requestURI – the relative URI
headers – the headers
version – the websocket version
subProtocols – the subprotocols to use
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream to the specified host, relative request URI and default port, with the specified headers, using
   * the specified version of WebSockets, and the specified websocket sub protocols
   * @param host the host
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols to use
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(String host, String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(host, requestURI, headers.getDelegate(), version, subProtocols), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream at the relative request URI using the default host and port and the specified headers
Params:
requestURI – the relative URI
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream at the relative request URI using the default host and port and the specified headers
   * @param requestURI the relative URI
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(String requestURI) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(requestURI), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream at the relative request URI using the default host and port and the specified headers
Params:
requestURI – the relative URI
headers – the headers
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream at the relative request URI using the default host and port and the specified headers
   * @param requestURI the relative URI
   * @param headers the headers
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(String requestURI, io.vertx.rxjava.core.MultiMap headers) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(requestURI, headers.getDelegate()), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream at the relative request URI using the default host and port, the specified headers and the
specified version of WebSockets
Params:
requestURI – the relative URI
headers – the headers
version – the websocket version
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream at the relative request URI using the default host and port, the specified headers and the
   * specified version of WebSockets
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(requestURI, headers.getDelegate(), version), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Create a WebSocket stream at the relative request URI using the default host and port, the specified headers, the
specified version of WebSockets and the specified sub protocols
Params:
requestURI – the relative URI
headers – the headers
version – the websocket version
subProtocols – the subprotocols
Returns:
a stream emitting a WebSocket event when the client connection has been upgraded to a websocket/**
   * Create a WebSocket stream at the relative request URI using the default host and port, the specified headers, the
   * specified version of WebSockets and the specified sub protocols
   * @param requestURI the relative URI
   * @param headers the headers
   * @param version the websocket version
   * @param subProtocols the subprotocols
   * @return a stream emitting a WebSocket event when the client connection has been upgraded to a websocket
   */
  @Deprecated()
  public io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> websocketStream(String requestURI, io.vertx.rxjava.core.MultiMap headers, WebsocketVersion version, String subProtocols) { 
    io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.http.WebSocket> ret = io.vertx.rxjava.core.streams.ReadStream.newInstance(delegate.websocketStream(requestURI, headers.getDelegate(), version, subProtocols), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.http.WebSocket.__TYPE_ARG);
    return ret;
  }

  
Set a connection handler for the client. This handler is called when a new connection is established.
Params:
handler – 
Returns:
a reference to this, so the API can be used fluently/**
   * Set a connection handler for the client. This handler is called when a new connection is established.
   * @param handler 
   * @return a reference to this, so the API can be used fluently
   */
  public io.vertx.rxjava.core.http.HttpClient connectionHandler(Handler<io.vertx.rxjava.core.http.HttpConnection> handler) { 
    delegate.connectionHandler(new Handler<io.vertx.core.http.HttpConnection>() {
      public void handle(io.vertx.core.http.HttpConnection event) {
        handler.handle(io.vertx.rxjava.core.http.HttpConnection.newInstance(event));
      }
    });
    return this;
  }

  
Set a redirect handler for the http client.

The redirect handler is called when a 3xx response is received and the request is configured to follow redirects with HttpClientRequest.setFollowRedirects. 
 The redirect handler is passed the HttpClientResponse, it can return an HttpClientRequest or null.

  
when null is returned, the original response is processed by the original request response handler
  
when a new Future is returned, the client will send this new request

The new request will get a copy of the previous request headers unless headers are set. In this case,
the client assumes that the redirect handler exclusively managers the headers of the new request.

The handler must return a Future unsent so the client can further configure it and send it.
Params:
handler – the new redirect handler
Returns:
a reference to this, so the API can be used fluently/**
   * Set a redirect handler for the http client.
   * <p>
   * The redirect handler is called when a <code>3xx</code> response is received and the request is configured to
   * follow redirects with {@link io.vertx.rxjava.core.http.HttpClientRequest#setFollowRedirects}.
   * <p>
   * The redirect handler is passed the {@link io.vertx.rxjava.core.http.HttpClientResponse}, it can return an {@link io.vertx.rxjava.core.http.HttpClientRequest} or <code>null</code>.
   * <ul>
   *   <li>when null is returned, the original response is processed by the original request response handler</li>
   *   <li>when a new <code>Future<HttpClientRequest></code> is returned, the client will send this new request</li>
   * </ul>
   * The new request will get a copy of the previous request headers unless headers are set. In this case,
   * the client assumes that the redirect handler exclusively managers the headers of the new request.
   * <p>
   * The handler must return a <code>Future<HttpClientRequest></code> unsent so the client can further configure it and send it.
   * @param handler the new redirect handler
   * @return a reference to this, so the API can be used fluently
   */
  public io.vertx.rxjava.core.http.HttpClient redirectHandler(Function<io.vertx.rxjava.core.http.HttpClientResponse, io.vertx.rxjava.core.Future<io.vertx.rxjava.core.http.HttpClientRequest>> handler) { 
    delegate.redirectHandler(new java.util.function.Function<io.vertx.core.http.HttpClientResponse,io.vertx.core.Future<io.vertx.core.http.HttpClientRequest>>() {
      public io.vertx.core.Future<io.vertx.core.http.HttpClientRequest> apply(io.vertx.core.http.HttpClientResponse arg) {
        io.vertx.rxjava.core.Future<io.vertx.rxjava.core.http.HttpClientRequest> ret = handler.apply(io.vertx.rxjava.core.http.HttpClientResponse.newInstance(arg));
        return ret.getDelegate();
      }
    });
    return this;
  }

  
Close the client. Closing will close down any pooled connections.
Clients should always be closed after use.
/**
   * Close the client. Closing will close down any pooled connections.
   * Clients should always be closed after use.
   */
  public void close() { 
    delegate.close();
  }


  public static  HttpClient newInstance(io.vertx.core.http.HttpClient arg) {
    return arg != null ? new HttpClient(arg) : null;
  }
}