/*
 * Copyright (c) 2011-2018 Contributors to the Eclipse Foundation
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
 * which is available at https://www.apache.org/licenses/LICENSE-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 */

package io.vertx.core;

import io.vertx.codegen.annotations.DataObject;
import io.vertx.core.dns.AddressResolverOptions;
import io.vertx.core.eventbus.EventBusOptions;
import io.vertx.core.file.FileSystemOptions;
import io.vertx.core.impl.cpu.CpuCoreSensor;
import io.vertx.core.json.JsonObject;
import io.vertx.core.metrics.MetricsOptions;
import io.vertx.core.spi.cluster.ClusterManager;

import java.util.Objects;
import java.util.concurrent.TimeUnit;

import static io.vertx.core.file.FileSystemOptions.DEFAULT_FILE_CACHING_ENABLED;

Instances of this class are used to configure Vertx instances. 
Author:
Tim Fox/**
 * Instances of this class are used to configure {@link io.vertx.core.Vertx} instances.
 *
 * @author <a href="http://tfox.org">Tim Fox</a>
 */
@DataObject(generateConverter = true, publicConverter = false)
public class VertxOptions {

  
The default number of event loop threads to be used  = 2 * number of cores on the machine
/**
   * The default number of event loop threads to be used  = 2 * number of cores on the machine
   */
  public static final int DEFAULT_EVENT_LOOP_POOL_SIZE = 2 * CpuCoreSensor.availableProcessors();

  
The default number of threads in the worker pool = 20
/**
   * The default number of threads in the worker pool = 20
   */
  public static final int DEFAULT_WORKER_POOL_SIZE = 20;

  
The default number of threads in the internal blocking  pool (used by some internal operations) = 20
/**
   * The default number of threads in the internal blocking  pool (used by some internal operations) = 20
   */
  public static final int DEFAULT_INTERNAL_BLOCKING_POOL_SIZE = 20;

  
The default value of whether Vert.x is clustered = false.
Deprecated:
as of 3.7, use EventBusOptions.DEFAULT_CLUSTERED instead/**
   * The default value of whether Vert.x is clustered = false.
   *
   * @deprecated as of 3.7, use {@link EventBusOptions#DEFAULT_CLUSTERED} instead
   */
  @Deprecated
  public static final boolean DEFAULT_CLUSTERED = false;

  
The default hostname to use when clustering = "localhost"
Deprecated:
as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_HOST instead/**
   * The default hostname to use when clustering = "localhost"
   *
   * @deprecated as of 3.7, use {@link EventBusOptions#DEFAULT_CLUSTER_HOST} instead
   */
  @Deprecated
  public static final String DEFAULT_CLUSTER_HOST = "localhost";

  
The default port to use when clustering = 0 (meaning assign a random port)
Deprecated:
as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_PORT instead/**
   * The default port to use when clustering = 0 (meaning assign a random port)
   *
   * @deprecated as of 3.7, use {@link EventBusOptions#DEFAULT_CLUSTER_PORT} instead
   */
  @Deprecated
  public static final int DEFAULT_CLUSTER_PORT = 0;

  
The default cluster public host to use = null which means use the same as the cluster host
Deprecated:
as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_PUBLIC_HOST instead/**
   * The default cluster public host to use = null which means use the same as the cluster host
   *
   * @deprecated as of 3.7, use {@link EventBusOptions#DEFAULT_CLUSTER_PUBLIC_HOST} instead
   */
  @Deprecated
  public static final String DEFAULT_CLUSTER_PUBLIC_HOST = null;

  
The default cluster public port to use = -1 which means use the same as the cluster port
Deprecated:
as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_PUBLIC_PORT instead/**
   * The default cluster public port to use = -1 which means use the same as the cluster port
   *
   * @deprecated as of 3.7, use {@link EventBusOptions#DEFAULT_CLUSTER_PUBLIC_PORT} instead
   */
  @Deprecated
  public static final int DEFAULT_CLUSTER_PUBLIC_PORT = -1;

  
The default value of cluster ping interval = 20000 ms.
Deprecated:
as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_PING_INTERVAL instead/**
   * The default value of cluster ping interval = 20000 ms.
   *
   * @deprecated as of 3.7, use {@link EventBusOptions#DEFAULT_CLUSTER_PING_INTERVAL} instead
   */
  @Deprecated
  public static final long DEFAULT_CLUSTER_PING_INTERVAL = 20000;

  
The default value of cluster ping reply interval = 20000 ms.
Deprecated:
as of 3.7, use EventBusOptions.DEFAULT_CLUSTER_PING_REPLY_INTERVAL instead/**
   * The default value of cluster ping reply interval = 20000 ms.
   *
   * @deprecated as of 3.7, use {@link EventBusOptions#DEFAULT_CLUSTER_PING_REPLY_INTERVAL} instead
   */
  @Deprecated
  public static final long DEFAULT_CLUSTER_PING_REPLY_INTERVAL = 20000;

  
The default value of blocked thread check interval = 1000 ms.
/**
   * The default value of blocked thread check interval = 1000 ms.
   */
  public static final long DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL = 1000;

  
The default value of blocked thread check interval unit = TimeUnit.NANOSECONDS
/**
   * The default value of blocked thread check interval unit = TimeUnit.NANOSECONDS
   */
  public static final TimeUnit DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL_UNIT = TimeUnit.MILLISECONDS;

  
The default value of max event loop execute time = 2000000000 ns (2 seconds)
/**
   * The default value of max event loop execute time = 2000000000 ns (2 seconds)
   */
  public static final long DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME = 2L * 1000 * 1000000;

  
The default value of max event loop execute time unit = TimeUnit.NANOSECONDS
/**
   * The default value of max event loop execute time unit = TimeUnit.NANOSECONDS
   */
  public static final TimeUnit DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME_UNIT = TimeUnit.NANOSECONDS;

  
The default value of max worker execute time = 60000000000 ns (60 seconds)
/**
   * The default value of max worker execute time = 60000000000 ns (60 seconds)
   */
  public static final long DEFAULT_MAX_WORKER_EXECUTE_TIME = 60L * 1000 * 1000000;

  
The default value of max worker execute time unit = TimeUnit.NANOSECONDS
/**
   * The default value of max worker execute time unit = TimeUnit.NANOSECONDS
   */
  public static final TimeUnit DEFAULT_MAX_WORKER_EXECUTE_TIME_UNIT = TimeUnit.NANOSECONDS;

  
The default value of quorum size = 1
/**
   * The default value of quorum size = 1
   */
  public static final int DEFAULT_QUORUM_SIZE = 1;

  
The default value of Ha group is "__DEFAULT__"
/**
   * The default value of Ha group is "__DEFAULT__"
   */
  public static final String DEFAULT_HA_GROUP = "__DEFAULT__";

  
The default value of HA enabled = false
/**
   * The default value of HA enabled = false
   */
  public static final boolean DEFAULT_HA_ENABLED = false;

  
The default value for preferring native transport = false
/**
   * The default value for preferring native transport = false
   */
  public static final boolean DEFAULT_PREFER_NATIVE_TRANSPORT = false;

  
The default value of warning exception time 5000000000 ns (5 seconds)
If a thread is blocked longer than this threshold, the warning log
contains a stack trace
/**
   * The default value of warning exception time 5000000000 ns (5 seconds)
   * If a thread is blocked longer than this threshold, the warning log
   * contains a stack trace
   */
  private static final long DEFAULT_WARNING_EXCEPTION_TIME = TimeUnit.SECONDS.toNanos(5);

  
The default value of warning exception time unit = TimeUnit.NANOSECONDS
/**
   * The default value of warning exception time unit = TimeUnit.NANOSECONDS
   */
  public static final TimeUnit DEFAULT_WARNING_EXCEPTION_TIME_UNIT = TimeUnit.NANOSECONDS;

  private int eventLoopPoolSize = DEFAULT_EVENT_LOOP_POOL_SIZE;
  private int workerPoolSize = DEFAULT_WORKER_POOL_SIZE;
  private int internalBlockingPoolSize = DEFAULT_INTERNAL_BLOCKING_POOL_SIZE;
  private long blockedThreadCheckInterval = DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL;
  private long maxEventLoopExecuteTime = DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME;
  private long maxWorkerExecuteTime = DEFAULT_MAX_WORKER_EXECUTE_TIME;
  private ClusterManager clusterManager;
  private boolean haEnabled = DEFAULT_HA_ENABLED;
  private int quorumSize = DEFAULT_QUORUM_SIZE;
  private String haGroup = DEFAULT_HA_GROUP;
  private MetricsOptions metricsOptions = new MetricsOptions();
  private FileSystemOptions fileSystemOptions = new FileSystemOptions();
  private long warningExceptionTime = DEFAULT_WARNING_EXCEPTION_TIME;
  private EventBusOptions eventBusOptions = new EventBusOptions();
  private AddressResolverOptions addressResolverOptions = new AddressResolverOptions();
  private boolean preferNativeTransport = DEFAULT_PREFER_NATIVE_TRANSPORT;
  private TimeUnit maxEventLoopExecuteTimeUnit = DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME_UNIT;
  private TimeUnit maxWorkerExecuteTimeUnit = DEFAULT_MAX_WORKER_EXECUTE_TIME_UNIT;
  private TimeUnit warningExceptionTimeUnit = DEFAULT_WARNING_EXCEPTION_TIME_UNIT;
  private TimeUnit blockedThreadCheckIntervalUnit = DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL_UNIT;

  
Default constructor
/**
   * Default constructor
   */
  public VertxOptions() {
  }

  
Copy constructor
Params:
other – The other VertxOptions to copy when creating this/**
   * Copy constructor
   *
   * @param other The other {@code VertxOptions} to copy when creating this
   */
  public VertxOptions(VertxOptions other) {
    this.eventLoopPoolSize = other.getEventLoopPoolSize();
    this.workerPoolSize = other.getWorkerPoolSize();
    this.blockedThreadCheckInterval = other.getBlockedThreadCheckInterval();
    this.maxEventLoopExecuteTime = other.getMaxEventLoopExecuteTime();
    this.maxWorkerExecuteTime = other.getMaxWorkerExecuteTime();
    this.internalBlockingPoolSize = other.getInternalBlockingPoolSize();
    this.clusterManager = other.getClusterManager();
    this.haEnabled = other.isHAEnabled();
    this.quorumSize = other.getQuorumSize();
    this.haGroup = other.getHAGroup();
    this.metricsOptions = other.getMetricsOptions() != null ? new MetricsOptions(other.getMetricsOptions()) : null;
    this.fileSystemOptions = other.getFileSystemOptions() != null ? new FileSystemOptions(other.getFileSystemOptions()) : null;
    this.warningExceptionTime = other.warningExceptionTime;
    this.eventBusOptions = new EventBusOptions(other.eventBusOptions);
    this.addressResolverOptions = other.addressResolverOptions != null ? new AddressResolverOptions() : null;
    this.maxEventLoopExecuteTimeUnit = other.maxEventLoopExecuteTimeUnit;
    this.maxWorkerExecuteTimeUnit = other.maxWorkerExecuteTimeUnit;
    this.warningExceptionTimeUnit = other.warningExceptionTimeUnit;
    this.blockedThreadCheckIntervalUnit = other.blockedThreadCheckIntervalUnit;
  }

  
Create an instance from a JsonObject 
Params:
json – the JsonObject to create it from/**
   * Create an instance from a {@link io.vertx.core.json.JsonObject}
   *
   * @param json the JsonObject to create it from
   */
  public VertxOptions(JsonObject json) {
    this();
    VertxOptionsConverter.fromJson(json, this);
  }

  
Get the number of event loop threads to be used by the Vert.x instance.
Returns:
the number of threads/**
   * Get the number of event loop threads to be used by the Vert.x instance.
   *
   * @return the number of threads
   */
  public int getEventLoopPoolSize() {
    return eventLoopPoolSize;
  }

  
Set the number of event loop threads to be used by the Vert.x instance.
Params:
eventLoopPoolSize – the number of threads
Returns:
a reference to this, so the API can be used fluently/**
   * Set the number of event loop threads to be used by the Vert.x instance.
   *
   * @param eventLoopPoolSize the number of threads
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setEventLoopPoolSize(int eventLoopPoolSize) {
    if (eventLoopPoolSize < 1) {
      throw new IllegalArgumentException("eventLoopPoolSize must be > 0");
    }
    this.eventLoopPoolSize = eventLoopPoolSize;
    return this;
  }

  
Get the maximum number of worker threads to be used by the Vert.x instance.

Worker threads are used for running blocking code and worker verticles.
Returns:
the maximum number of worker threads/**
   * Get the maximum number of worker threads to be used by the Vert.x instance.
   * <p>
   * Worker threads are used for running blocking code and worker verticles.
   *
   * @return the maximum number of worker threads
   */
  public int getWorkerPoolSize() {
    return workerPoolSize;
  }

  
Set the maximum number of worker threads to be used by the Vert.x instance.
Params:
workerPoolSize – the number of threads
Returns:
a reference to this, so the API can be used fluently/**
   * Set the maximum number of worker threads to be used by the Vert.x instance.
   *
   * @param workerPoolSize the number of threads
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setWorkerPoolSize(int workerPoolSize) {
    if (workerPoolSize < 1) {
      throw new IllegalArgumentException("workerPoolSize must be > 0");
    }
    this.workerPoolSize = workerPoolSize;
    return this;
  }

  
Is the Vert.x instance clustered?
Returns:
true if clustered, false if not
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.isClustered() instead/**
   * Is the Vert.x instance clustered?
   *
   * @return true if clustered, false if not
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#isClustered()} instead
   */
  @Deprecated
  public boolean isClustered() {
    return eventBusOptions.isClustered();
  }

  
Set whether or not the Vert.x instance will be clustered.
Params:
clustered – if true, the Vert.x instance will be clustered, otherwise not
Returns:
a reference to this, so the API can be used fluently
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.setClustered(boolean) instead/**
   * Set whether or not the Vert.x instance will be clustered.
   *
   * @param clustered if true, the Vert.x instance will be clustered, otherwise not
   * @return a reference to this, so the API can be used fluently
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#setClustered(boolean)} instead
   */
  @Deprecated
  public VertxOptions setClustered(boolean clustered) {
    eventBusOptions.setClustered(clustered);
    return this;
  }

  
Get the host name to be used for clustering.
Returns:
The host name
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.getHost() instead/**
   * Get the host name to be used for clustering.
   *
   * @return The host name
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#getHost()} instead
   */
  @Deprecated
  public String getClusterHost() {
    return eventBusOptions.getHost();
  }

  
Set the hostname to be used for clustering.
Params:
clusterHost – the host name to use
Returns:
a reference to this, so the API can be used fluently
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.setHost(String) instead/**
   * Set the hostname to be used for clustering.
   *
   * @param clusterHost the host name to use
   * @return a reference to this, so the API can be used fluently
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#setHost(String)} instead
   */
  @Deprecated
  public VertxOptions setClusterHost(String clusterHost) {
    this.eventBusOptions.setHost(clusterHost);
    return this;
  }

  
Get the public facing hostname to be used when clustering.
Returns:
the public facing hostname
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.getClusterPublicHost() instead/**
   * Get the public facing hostname to be used when clustering.
   *
   * @return the public facing hostname
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#getClusterPublicHost()} instead
   */
  @Deprecated
  public String getClusterPublicHost() {
    return getEventBusOptions().getClusterPublicHost();
  }

  
Set the public facing hostname to be used for clustering.
Sometimes, e.g. when running on certain clouds, the local address the server listens on for clustering is not the same
address that other nodes connect to it at, as the OS / cloud infrastructure does some kind of proxying.
If this is the case you can specify a public hostname which is different from the hostname the server listens at.
The default value is null which means use the same as the cluster hostname.
Params:
clusterPublicHost – the public host name to use
Returns:
a reference to this, so the API can be used fluently
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.setClusterPublicHost(String) instead/**
   * Set the public facing hostname to be used for clustering.
   * Sometimes, e.g. when running on certain clouds, the local address the server listens on for clustering is not the same
   * address that other nodes connect to it at, as the OS / cloud infrastructure does some kind of proxying.
   * If this is the case you can specify a public hostname which is different from the hostname the server listens at.
   * The default value is null which means use the same as the cluster hostname.
   *
   * @param clusterPublicHost the public host name to use
   * @return a reference to this, so the API can be used fluently
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#setClusterPublicHost(String)} instead
   */
  @Deprecated
  public VertxOptions setClusterPublicHost(String clusterPublicHost) {
    getEventBusOptions().setClusterPublicHost(clusterPublicHost);
    return this;
  }

  
Get the port to be used for clustering
Returns:
the port
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.getPort() instead/**
   * Get the port to be used for clustering
   *
   * @return the port
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#getPort()} instead
   */
  @Deprecated
  public int getClusterPort() {
    return eventBusOptions.getPort();
  }

  
Set the port to be used for clustering.
Params:
clusterPort – the port
Returns:
a reference to this, so the API can be used fluently
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.setPort(int) instead/**
   * Set the port to be used for clustering.
   *
   * @param clusterPort the port
   * @return a reference to this, so the API can be used fluently
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#setPort(int)} instead
   */
  @Deprecated
  public VertxOptions setClusterPort(int clusterPort) {
    eventBusOptions.setPort(clusterPort);
    return this;
  }

  
Get the public facing port to be used when clustering.
Returns:
the public facing port
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.getClusterPublicPort() instead/**
   * Get the public facing port to be used when clustering.
   *
   * @return the public facing port
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#getClusterPublicPort()} instead
   */
  @Deprecated
  public int getClusterPublicPort() {
    return eventBusOptions.getClusterPublicPort();
  }

  
See setClusterPublicHost(String) for an explanation. 
Params:
clusterPublicPort – the public port to use
Returns:
a reference to this, so the API can be used fluently
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.setClusterPublicPort(int) instead/**
   * See {@link #setClusterPublicHost(String)} for an explanation.
   *
   * @param clusterPublicPort the public port to use
   * @return a reference to this, so the API can be used fluently
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#setClusterPublicPort(int)} instead
   */
  @Deprecated
  public VertxOptions setClusterPublicPort(int clusterPublicPort) {
    getEventBusOptions().setClusterPublicPort(clusterPublicPort);
    return this;
  }

  
Get the value of cluster ping interval, in ms.

Nodes in the cluster ping each other at this interval to determine whether they are still running.
Returns:
The value of cluster ping interval
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.getClusterPingInterval() instead/**
   * Get the value of cluster ping interval, in ms.
   * <p>
   * Nodes in the cluster ping each other at this interval to determine whether they are still running.
   *
   * @return The value of cluster ping interval
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#getClusterPingInterval()} instead
   */
  @Deprecated
  public long getClusterPingInterval() {
    return getEventBusOptions().getClusterPingInterval();
  }

  
Set the value of cluster ping interval, in ms.
Params:
clusterPingInterval – The value of cluster ping interval, in ms.
Returns:
a reference to this, so the API can be used fluently
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.setClusterPingInterval(long) instead/**
   * Set the value of cluster ping interval, in ms.
   *
   * @param clusterPingInterval The value of cluster ping interval, in ms.
   * @return a reference to this, so the API can be used fluently
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#setClusterPingInterval(long)} instead
   */
  @Deprecated
  public VertxOptions setClusterPingInterval(long clusterPingInterval) {
    eventBusOptions.setClusterPingInterval(clusterPingInterval);
    return this;
  }

  
Get the value of cluster ping reply interval, in ms.

After sending a ping, if a pong is not received in this time, the node will be considered dead.
Returns:
the value of cluster ping reply interval
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.getClusterPingReplyInterval() instead/**
   * Get the value of cluster ping reply interval, in ms.
   * <p>
   * After sending a ping, if a pong is not received in this time, the node will be considered dead.
   *
   * @return the value of cluster ping reply interval
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#getClusterPingReplyInterval()} instead
   */
  @Deprecated
  public long getClusterPingReplyInterval() {
    return eventBusOptions.getClusterPingReplyInterval();
  }

  
Set the value of cluster ping reply interval, in ms.
Params:
clusterPingReplyInterval – The value of cluster ping reply interval, in ms.
Returns:
a reference to this, so the API can be used fluently
Deprecated:
as of 3.7, use getEventBusOptions() and then EventBusOptions.setClusterPingReplyInterval(long) instead/**
   * Set the value of cluster ping reply interval, in ms.
   *
   * @param clusterPingReplyInterval The value of cluster ping reply interval, in ms.
   * @return a reference to this, so the API can be used fluently
   *
   * @deprecated as of 3.7, use {@link #getEventBusOptions()} and then {@link EventBusOptions#setClusterPingReplyInterval(long)} instead
   */
  @Deprecated
  public VertxOptions setClusterPingReplyInterval(long clusterPingReplyInterval) {
    eventBusOptions.setClusterPingReplyInterval(clusterPingReplyInterval);
    return this;
  }

  
Get the value of blocked thread check period, in blockedThreadCheckIntervalUnit. 

This setting determines how often Vert.x will check whether event loop threads are executing for too long.
 The default value of blockedThreadCheckIntervalUnit is TimeUnit.MILLISECONDS. 
Returns:
the value of blocked thread check period, in blockedThreadCheckIntervalUnit./**
   * Get the value of blocked thread check period, in {@link VertxOptions#setBlockedThreadCheckIntervalUnit blockedThreadCheckIntervalUnit}.
   * <p>
   * This setting determines how often Vert.x will check whether event loop threads are executing for too long.
   * <p>
   * The default value of {@link VertxOptions#setBlockedThreadCheckIntervalUnit blockedThreadCheckIntervalUnit} is {@link TimeUnit#MILLISECONDS}.
   *
   * @return the value of blocked thread check period, in {@link VertxOptions#setBlockedThreadCheckIntervalUnit blockedThreadCheckIntervalUnit}.
   */
  public long getBlockedThreadCheckInterval() {
    return blockedThreadCheckInterval;
  }

  
Sets the value of blocked thread check period, in blockedThreadCheckIntervalUnit. 
 The default value of blockedThreadCheckIntervalUnit is TimeUnit.MILLISECONDS 
Params:
blockedThreadCheckInterval – the value of blocked thread check period, in blockedThreadCheckIntervalUnit.
Returns:
a reference to this, so the API can be used fluently/**
   * Sets the value of blocked thread check period, in {@link VertxOptions#setBlockedThreadCheckIntervalUnit blockedThreadCheckIntervalUnit}.
   * <p>
   * The default value of {@link VertxOptions#setBlockedThreadCheckIntervalUnit blockedThreadCheckIntervalUnit} is {@link TimeUnit#MILLISECONDS}
   *
   * @param blockedThreadCheckInterval the value of blocked thread check period, in {@link VertxOptions#setBlockedThreadCheckIntervalUnit blockedThreadCheckIntervalUnit}.
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setBlockedThreadCheckInterval(long blockedThreadCheckInterval) {
    if (blockedThreadCheckInterval < 1) {
      throw new IllegalArgumentException("blockedThreadCheckInterval must be > 0");
    }
    this.blockedThreadCheckInterval = blockedThreadCheckInterval;
    return this;
  }

  
Get the value of max event loop execute time, in maxEventLoopExecuteTimeUnit. 

Vert.x will automatically log a warning if it detects that event loop threads haven't returned within this time.

This can be used to detect where the user is blocking an event loop thread, contrary to the Golden Rule of the
holy Event Loop.
 The default value of maxEventLoopExecuteTimeUnit is TimeUnit.NANOSECONDS 
Returns:
the value of max event loop execute time, in maxEventLoopExecuteTimeUnit./**
   * Get the value of max event loop execute time, in {@link VertxOptions#setMaxEventLoopExecuteTimeUnit maxEventLoopExecuteTimeUnit}.
   * <p>
   * Vert.x will automatically log a warning if it detects that event loop threads haven't returned within this time.
   * <p>
   * This can be used to detect where the user is blocking an event loop thread, contrary to the Golden Rule of the
   * holy Event Loop.
   * <p>
   * The default value of {@link VertxOptions#setMaxEventLoopExecuteTimeUnit maxEventLoopExecuteTimeUnit} is {@link TimeUnit#NANOSECONDS}
   *
   * @return the value of max event loop execute time, in {@link VertxOptions#setMaxEventLoopExecuteTimeUnit maxEventLoopExecuteTimeUnit}.
   */
  public long getMaxEventLoopExecuteTime() {
    return maxEventLoopExecuteTime;
  }

  
Sets the value of max event loop execute time, in maxEventLoopExecuteTimeUnit. 
 The default value of maxEventLoopExecuteTimeUnitis TimeUnit.NANOSECONDS 
Params:
maxEventLoopExecuteTime – the value of max event loop execute time, in maxEventLoopExecuteTimeUnit.
Returns:
a reference to this, so the API can be used fluently/**
   * Sets the value of max event loop execute time, in {@link VertxOptions#setMaxEventLoopExecuteTimeUnit maxEventLoopExecuteTimeUnit}.
   * <p>
   * The default value of {@link VertxOptions#setMaxEventLoopExecuteTimeUnit maxEventLoopExecuteTimeUnit}is {@link TimeUnit#NANOSECONDS}
   *
   * @param maxEventLoopExecuteTime the value of max event loop execute time, in {@link VertxOptions#setMaxEventLoopExecuteTimeUnit maxEventLoopExecuteTimeUnit}.
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setMaxEventLoopExecuteTime(long maxEventLoopExecuteTime) {
    if (maxEventLoopExecuteTime < 1) {
      throw new IllegalArgumentException("maxEventLoopExecuteTime must be > 0");
    }
    this.maxEventLoopExecuteTime = maxEventLoopExecuteTime;
    return this;
  }

  
Get the value of max worker execute time, in maxWorkerExecuteTimeUnit. 

Vert.x will automatically log a warning if it detects that worker threads haven't returned within this time.

This can be used to detect where the user is blocking a worker thread for too long. Although worker threads
can be blocked longer than event loop threads, they shouldn't be blocked for long periods of time.
 The default value of maxWorkerExecuteTimeUnit is TimeUnit.NANOSECONDS 
Returns:
The value of max worker execute time, in maxWorkerExecuteTimeUnit./**
   * Get the value of max worker execute time, in {@link VertxOptions#setMaxWorkerExecuteTimeUnit maxWorkerExecuteTimeUnit}.
   * <p>
   * Vert.x will automatically log a warning if it detects that worker threads haven't returned within this time.
   * <p>
   * This can be used to detect where the user is blocking a worker thread for too long. Although worker threads
   * can be blocked longer than event loop threads, they shouldn't be blocked for long periods of time.
   * <p>
   * The default value of {@link VertxOptions#setMaxWorkerExecuteTimeUnit maxWorkerExecuteTimeUnit} is {@link TimeUnit#NANOSECONDS}
   *
   * @return The value of max worker execute time, in {@link VertxOptions#setMaxWorkerExecuteTimeUnit maxWorkerExecuteTimeUnit}.
   */
  public long getMaxWorkerExecuteTime() {
    return maxWorkerExecuteTime;
  }

  
Sets the value of max worker execute time, in maxWorkerExecuteTimeUnit. 
 The default value of maxWorkerExecuteTimeUnit is TimeUnit.NANOSECONDS 
Params:
maxWorkerExecuteTime – the value of max worker execute time, in maxWorkerExecuteTimeUnit.
Returns:
a reference to this, so the API can be used fluently/**
   * Sets the value of max worker execute time, in {@link VertxOptions#setMaxWorkerExecuteTimeUnit maxWorkerExecuteTimeUnit}.
   * <p>
   * The default value of {@link VertxOptions#setMaxWorkerExecuteTimeUnit maxWorkerExecuteTimeUnit} is {@link TimeUnit#NANOSECONDS}
   *
   * @param maxWorkerExecuteTime the value of max worker execute time, in {@link VertxOptions#setMaxWorkerExecuteTimeUnit maxWorkerExecuteTimeUnit}.
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setMaxWorkerExecuteTime(long maxWorkerExecuteTime) {
    if (maxWorkerExecuteTime < 1) {
      throw new IllegalArgumentException("maxWorkerpExecuteTime must be > 0");
    }
    this.maxWorkerExecuteTime = maxWorkerExecuteTime;
    return this;
  }

  
Get the cluster manager to be used when clustering.

If the cluster manager has been programmatically set here, then that will be used when clustering.

Otherwise Vert.x attempts to locate a cluster manager on the classpath.
Returns:
the cluster manager./**
   * Get the cluster manager to be used when clustering.
   * <p>
   * If the cluster manager has been programmatically set here, then that will be used when clustering.
   * <p>
   * Otherwise Vert.x attempts to locate a cluster manager on the classpath.
   *
   * @return the cluster manager.
   */
  public ClusterManager getClusterManager() {
    return clusterManager;
  }

  
Programmatically set the cluster manager to be used when clustering.

Only valid if clustered = true.

Normally Vert.x will look on the classpath for a cluster manager, but if you want to set one
programmatically you can use this method.
Params:
clusterManager – the cluster manager
Returns:
a reference to this, so the API can be used fluently/**
   * Programmatically set the cluster manager to be used when clustering.
   * <p>
   * Only valid if clustered = true.
   * <p>
   * Normally Vert.x will look on the classpath for a cluster manager, but if you want to set one
   * programmatically you can use this method.
   *
   * @param clusterManager the cluster manager
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setClusterManager(ClusterManager clusterManager) {
    this.clusterManager = clusterManager;
    return this;
  }

  
Get the value of internal blocking pool size.

Vert.x maintains a pool for internal blocking operations
Returns:
the value of internal blocking pool size/**
   * Get the value of internal blocking pool size.
   * <p>
   * Vert.x maintains a pool for internal blocking operations
   *
   * @return the value of internal blocking pool size
   */
  public int getInternalBlockingPoolSize() {
    return internalBlockingPoolSize;
  }

  
Set the value of internal blocking pool size
Params:
internalBlockingPoolSize – the maximumn number of threads in the internal blocking pool
Returns:
a reference to this, so the API can be used fluently/**
   * Set the value of internal blocking pool size
   *
   * @param internalBlockingPoolSize the maximumn number of threads in the internal blocking pool
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setInternalBlockingPoolSize(int internalBlockingPoolSize) {
    if (internalBlockingPoolSize < 1) {
      throw new IllegalArgumentException("internalBlockingPoolSize must be > 0");
    }
    this.internalBlockingPoolSize = internalBlockingPoolSize;
    return this;
  }

  
Will HA be enabled on the Vert.x instance?
Returns:
true if HA enabled, false otherwise/**
   * Will HA be enabled on the Vert.x instance?
   *
   * @return true if HA enabled, false otherwise
   */
  public boolean isHAEnabled() {
    return haEnabled;
  }

  
Set whether HA will be enabled on the Vert.x instance.
Params:
haEnabled – true if enabled, false if not.
Returns:
a reference to this, so the API can be used fluently/**
   * Set whether HA will be enabled on the Vert.x instance.
   *
   * @param haEnabled true if enabled, false if not.
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setHAEnabled(boolean haEnabled) {
    this.haEnabled = haEnabled;
    return this;
  }

  
Get the quorum size to be used when HA is enabled.
Returns:
the quorum size/**
   * Get the quorum size to be used when HA is enabled.
   *
   * @return the quorum size
   */
  public int getQuorumSize() {
    return quorumSize;
  }

  
Set the quorum size to be used when HA is enabled.
Params:
quorumSize – the quorum size
Returns:
a reference to this, so the API can be used fluently/**
   * Set the quorum size to be used when HA is enabled.
   *
   * @param quorumSize the quorum size
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setQuorumSize(int quorumSize) {
    if (quorumSize < 1) {
      throw new IllegalArgumentException("quorumSize should be >= 1");
    }
    this.quorumSize = quorumSize;
    return this;
  }

  
Get the HA group to be used when HA is enabled.
Returns:
the HA group/**
   * Get the HA group to be used when HA is enabled.
   *
   * @return the HA group
   */
  public String getHAGroup() {
    return haGroup;
  }

  
Set the HA group to be used when HA is enabled.
Params:
haGroup – the HA group to use
Returns:
a reference to this, so the API can be used fluently/**
   * Set the HA group to be used when HA is enabled.
   *
   * @param haGroup the HA group to use
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setHAGroup(String haGroup) {
    Objects.requireNonNull(haGroup, "ha group cannot be null");
    this.haGroup = haGroup;
    return this;
  }

  
Returns:
the metrics options/**
   * @return the metrics options
   */
  public MetricsOptions getMetricsOptions() {
    return metricsOptions;
  }

  
Returns:
the file system options/**
   * @return the file system options
   */
  public FileSystemOptions getFileSystemOptions() {
    return fileSystemOptions;
  }

  
Set the metrics options
Params:
metrics – the options
Returns:
a reference to this, so the API can be used fluently/**
   * Set the metrics options
   *
   * @param metrics the options
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setMetricsOptions(MetricsOptions metrics) {
    this.metricsOptions = metrics;
    return this;
  }

  
Set the file system options
Params:
fileSystemOptions – the options
Returns:
a reference to this, so the API can be used fluently/**
   * Set the file system options
   *
   * @param fileSystemOptions the options
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setFileSystemOptions(FileSystemOptions fileSystemOptions) {
    this.fileSystemOptions = fileSystemOptions;
    return this;
  }

  
Get the threshold value above this, the blocked warning contains a stack trace. in warningExceptionTimeUnit. 
 The default value of warningExceptionTimeUnit is TimeUnit.NANOSECONDS 
Returns:
the warning exception time threshold/**
   * Get the threshold value above this, the blocked warning contains a stack trace. in {@link VertxOptions#setWarningExceptionTimeUnit warningExceptionTimeUnit}.
   * <p>
   * The default value of {@link VertxOptions#setWarningExceptionTimeUnit warningExceptionTimeUnit} is {@link TimeUnit#NANOSECONDS}
   *
   * @return the warning exception time threshold
   */
  public long getWarningExceptionTime() {
    return warningExceptionTime;
  }

  
Set the threshold value above this, the blocked warning contains a stack trace. in warningExceptionTimeUnit. The default value of warningExceptionTimeUnit is TimeUnit.NANOSECONDS 
Params:
warningExceptionTime – 
Returns:
a reference to this, so the API can be used fluently/**
   * Set the threshold value above this, the blocked warning contains a stack trace. in {@link VertxOptions#setWarningExceptionTimeUnit warningExceptionTimeUnit}.
   * The default value of {@link VertxOptions#setWarningExceptionTimeUnit warningExceptionTimeUnit} is {@link TimeUnit#NANOSECONDS}
   *
   * @param warningExceptionTime
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setWarningExceptionTime(long warningExceptionTime) {
    if (warningExceptionTime < 1) {
      throw new IllegalArgumentException("warningExceptionTime must be > 0");
    }
    this.warningExceptionTime = warningExceptionTime;
    return this;
  }

  
Returns:
the event bus option to configure the event bus communication (host, port, ssl...)/**
   * @return the event bus option to configure the event bus communication (host, port, ssl...)
   */
  public EventBusOptions getEventBusOptions() {
    return eventBusOptions;
  }

  
Sets the event bus configuration to configure the host, port, ssl...
Params:
options – the event bus options
Returns:
a reference to this, so the API can be used fluently/**
   * Sets the event bus configuration to configure the host, port, ssl...
   *
   * @param options the event bus options
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setEventBusOptions(EventBusOptions options) {
    Objects.requireNonNull(options);
    this.eventBusOptions = options;
    return this;
  }

  
Returns:
the address resolver options to configure resolving DNS servers, cache TTL, etc.../**
   * @return the address resolver options to configure resolving DNS servers, cache TTL, etc...
   */
  public AddressResolverOptions getAddressResolverOptions() {
    return addressResolverOptions;
  }

  
Sets the address resolver configuration to configure resolving DNS servers, cache TTL, etc...
Params:
addressResolverOptions – the address resolver options
Returns:
a reference to this, so the API can be used fluently/**
   * Sets the address resolver configuration to configure resolving DNS servers, cache TTL, etc...
   *
   * @param addressResolverOptions the address resolver options
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setAddressResolverOptions(AddressResolverOptions addressResolverOptions) {
    this.addressResolverOptions = addressResolverOptions;
    return this;
  }

  
Returns:
whether the file resolver uses caching
Deprecated:
use getFileSystemOptions().getFileCachingEnabled() instead/**
   * @return whether the file resolver uses caching
   * @deprecated use {@link FileSystemOptions#setFileCachingEnabled(boolean) getFileSystemOptions().getFileCachingEnabled()} instead
   */
  @Deprecated
  public boolean isFileResolverCachingEnabled() {
    if (fileSystemOptions == null) {
      return DEFAULT_FILE_CACHING_ENABLED;
    }
    return fileSystemOptions.isFileCachingEnabled();
  }

  
Set whether the Vert.x file resolver uses caching for classpath resources.
Params:
fileResolverCachingEnabled – true when the file resolver caches resources
Returns:
a reference to this, so the API can be used fluently
Deprecated:
use getFileSystemOptions().setFileCachingEnabled(val) instead/**
   * Set whether the Vert.x file resolver uses caching for classpath resources.
   *
   * @param fileResolverCachingEnabled true when the file resolver caches resources
   * @return a reference to this, so the API can be used fluently
   * @deprecated use {@link FileSystemOptions#setFileCachingEnabled(boolean) getFileSystemOptions().setFileCachingEnabled(val)} instead
   */
  @Deprecated
  public VertxOptions setFileResolverCachingEnabled(boolean fileResolverCachingEnabled) {
    if (fileSystemOptions == null) {
      fileSystemOptions = new FileSystemOptions();
    }
    this.fileSystemOptions.setFileCachingEnabled(fileResolverCachingEnabled);
    return this;
  }

  
Returns:
wether to prefer the native transport to the JDK transport/**
   * @return wether to prefer the native transport to the JDK transport
   */
  public boolean getPreferNativeTransport() {
    return preferNativeTransport;
  }

  
Set wether to prefer the native transport to the JDK transport.
Params:
preferNativeTransport – true to prefer the native transport
Returns:
a reference to this, so the API can be used fluently/**
   * Set wether to prefer the native transport to the JDK transport.
   *
   * @param preferNativeTransport {@code true} to prefer the native transport
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setPreferNativeTransport(boolean preferNativeTransport) {
    this.preferNativeTransport = preferNativeTransport;
    return this;
  }

  
Returns:
the time unit of maxEventLoopExecuteTime/**
   * @return the time unit of {@code maxEventLoopExecuteTime}
   */
  public TimeUnit getMaxEventLoopExecuteTimeUnit() {
    return maxEventLoopExecuteTimeUnit;
  }

  
Set the time unit of maxEventLoopExecuteTime. 
Params:
maxEventLoopExecuteTimeUnit – the time unit of maxEventLoopExecuteTime
Returns:
a reference to this, so the API can be used fluently/**
   * Set the time unit of {@code maxEventLoopExecuteTime}.
   *
   * @param maxEventLoopExecuteTimeUnit the time unit of {@code maxEventLoopExecuteTime}
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setMaxEventLoopExecuteTimeUnit(TimeUnit maxEventLoopExecuteTimeUnit) {
    this.maxEventLoopExecuteTimeUnit = maxEventLoopExecuteTimeUnit;
    return this;
  }

  
Returns:
the time unit of maxWorkerExecuteTime/**
   * @return the time unit of {@code maxWorkerExecuteTime}
   */
  public TimeUnit getMaxWorkerExecuteTimeUnit() {
    return maxWorkerExecuteTimeUnit;
  }

  
Set the time unit of maxWorkerExecuteTime. 
Params:
maxWorkerExecuteTimeUnit – the time unit of maxWorkerExecuteTime
Returns:
a reference to this, so the API can be used fluently/**
   * Set the time unit of {@code maxWorkerExecuteTime}.
   *
   * @param maxWorkerExecuteTimeUnit the time unit of {@code maxWorkerExecuteTime}
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setMaxWorkerExecuteTimeUnit(TimeUnit maxWorkerExecuteTimeUnit) {
    this.maxWorkerExecuteTimeUnit = maxWorkerExecuteTimeUnit;
    return this;
  }

  
Returns:
the time unit of warningExceptionTime/**
   * @return the time unit of {@code warningExceptionTime}
   */
  public TimeUnit getWarningExceptionTimeUnit() {
    return warningExceptionTimeUnit;
  }

  
Set the time unit of warningExceptionTime. 
Params:
warningExceptionTimeUnit – the time unit of warningExceptionTime
Returns:
a reference to this, so the API can be used fluently/**
   * Set the time unit of {@code warningExceptionTime}.
   *
   * @param warningExceptionTimeUnit the time unit of {@code warningExceptionTime}
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setWarningExceptionTimeUnit(TimeUnit warningExceptionTimeUnit) {
    this.warningExceptionTimeUnit = warningExceptionTimeUnit;
    return this;
  }

  
Returns:
the time unit of blockedThreadCheckInterval/**
   * @return the time unit of {@code blockedThreadCheckInterval}
   */
  public TimeUnit getBlockedThreadCheckIntervalUnit() {
    return blockedThreadCheckIntervalUnit;
  }

  
Set the time unit of blockedThreadCheckInterval. 
Params:
blockedThreadCheckIntervalUnit – the time unit of warningExceptionTime
Returns:
a reference to this, so the API can be used fluently/**
   * Set the time unit of {@code blockedThreadCheckInterval}.
   *
   * @param blockedThreadCheckIntervalUnit the time unit of {@code warningExceptionTime}
   * @return a reference to this, so the API can be used fluently
   */
  public VertxOptions setBlockedThreadCheckIntervalUnit(TimeUnit blockedThreadCheckIntervalUnit) {
    this.blockedThreadCheckIntervalUnit = blockedThreadCheckIntervalUnit;
    return this;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    VertxOptions that = (VertxOptions) o;

    if (eventLoopPoolSize != that.eventLoopPoolSize) return false;
    if (workerPoolSize != that.workerPoolSize) return false;
    if (internalBlockingPoolSize != that.internalBlockingPoolSize) return false;
    if (blockedThreadCheckInterval != that.blockedThreadCheckInterval) return false;
    if (blockedThreadCheckIntervalUnit != that.blockedThreadCheckIntervalUnit) return false;
    if (maxEventLoopExecuteTime != that.maxEventLoopExecuteTime) return false;
    if (maxEventLoopExecuteTimeUnit != that.maxEventLoopExecuteTimeUnit) return false;
    if (maxWorkerExecuteTime != that.maxWorkerExecuteTime) return false;
    if (maxWorkerExecuteTimeUnit != that.maxWorkerExecuteTimeUnit) return false;
    if (haEnabled != that.haEnabled) return false;
    if (quorumSize != that.quorumSize) return false;
    if (warningExceptionTime != that.warningExceptionTime) return false;
    if (warningExceptionTimeUnit != that.warningExceptionTimeUnit) return false;
    if (clusterManager != null ? !clusterManager.equals(that.clusterManager) : that.clusterManager != null)
      return false;
    if (haGroup != null ? !haGroup.equals(that.haGroup) : that.haGroup != null) return false;
    if (eventBusOptions != null ? !eventBusOptions.equals(that.eventBusOptions) : that.eventBusOptions != null)
      return false;
    if (addressResolverOptions != null ? !addressResolverOptions.equals(that.addressResolverOptions) : that.addressResolverOptions != null)
      return false;
    if (preferNativeTransport != that.preferNativeTransport) return false;
    if (fileSystemOptions != null ? !fileSystemOptions.equals(that.fileSystemOptions) : that.fileSystemOptions != null) {
      return false;
    }
    return !(metricsOptions != null ? !metricsOptions.equals(that.metricsOptions) : that.metricsOptions != null);
  }

  @Override
  public int hashCode() {
    int result = eventLoopPoolSize;
    result = 31 * result + workerPoolSize;
    result = 31 * result + internalBlockingPoolSize;
    result = 31 * result + (int) (blockedThreadCheckInterval ^ (blockedThreadCheckInterval >>> 32));
    result = 31 * result + (int) (maxEventLoopExecuteTime ^ (maxEventLoopExecuteTime >>> 32));
    result = 31 * result + (int) (maxWorkerExecuteTime ^ (maxWorkerExecuteTime >>> 32));
    result = 31 * result + (clusterManager != null ? clusterManager.hashCode() : 0);
    result = 31 * result + (haEnabled ? 1 : 0);
    result = 31 * result + (preferNativeTransport ? 1 : 0);
    result = 31 * result + quorumSize;
    result = 31 * result + (haGroup != null ? haGroup.hashCode() : 0);
    result = 31 * result + (metricsOptions != null ? metricsOptions.hashCode() : 0);
    result = 31 * result + (fileSystemOptions != null ? fileSystemOptions.hashCode() : 0);
    result = 31 * result + (eventBusOptions != null ? eventBusOptions.hashCode() : 0);
    result = 31 * result + (addressResolverOptions != null ? addressResolverOptions.hashCode() : 0);
    result = 31 * result + (int) (warningExceptionTime ^ (warningExceptionTime >>> 32));
    result = 31 * result + (maxEventLoopExecuteTimeUnit != null ? maxEventLoopExecuteTimeUnit.hashCode() : 0);
    result = 31 * result + (maxWorkerExecuteTimeUnit != null ? maxWorkerExecuteTimeUnit.hashCode() : 0);
    result = 31 * result + (warningExceptionTimeUnit != null ? warningExceptionTimeUnit.hashCode() : 0);
    result = 31 * result + (blockedThreadCheckIntervalUnit != null ? blockedThreadCheckIntervalUnit.hashCode() : 0);
    return result;
  }

  @Override
  public String toString() {
    return "VertxOptions{" +
        "eventLoopPoolSize=" + eventLoopPoolSize +
        ", workerPoolSize=" + workerPoolSize +
        ", internalBlockingPoolSize=" + internalBlockingPoolSize +
        ", blockedThreadCheckIntervalUnit=" + blockedThreadCheckIntervalUnit +
        ", blockedThreadCheckInterval=" + blockedThreadCheckInterval +
        ", maxEventLoopExecuteTimeUnit=" + maxEventLoopExecuteTimeUnit +
        ", maxEventLoopExecuteTime=" + maxEventLoopExecuteTime +
        ", maxWorkerExecuteTimeUnit=" + maxWorkerExecuteTimeUnit +
        ", maxWorkerExecuteTime=" + maxWorkerExecuteTime +
        ", clusterManager=" + clusterManager +
        ", haEnabled=" + haEnabled +
        ", preferNativeTransport=" + preferNativeTransport +
        ", quorumSize=" + quorumSize +
        ", haGroup='" + haGroup + '\'' +
        ", metrics=" + metricsOptions +
        ", fileSystemOptions=" + fileSystemOptions +
        ", addressResolver=" + addressResolverOptions.toJson() +
        ", addressResolver=" + addressResolverOptions.toJson() +
        ", eventbus=" + eventBusOptions.toJson() +
        ", warningExceptionTimeUnit=" + warningExceptionTimeUnit +
        ", warningExceptionTime=" + warningExceptionTime +
        '}';
  }
}