Remove callback methods and use only futures

Author: vietj

vertx-db2-client/src/main/java/io/vertx/db2client/DB2Connection.java

@@ -15,14 +15,11 @@
  */
 package io.vertx.db2client;
 
-import io.vertx.codegen.annotations.Fluent;
 import io.vertx.codegen.annotations.VertxGen;
-import io.vertx.core.AsyncResult;
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
 import io.vertx.core.Vertx;
 import io.vertx.db2client.impl.DB2ConnectionImpl;
-import io.vertx.sqlclient.PreparedStatement;
 import io.vertx.sqlclient.SqlConnection;
 
 import static io.vertx.db2client.DB2ConnectOptions.fromUri;
@@ -38,45 +35,20 @@ public interface DB2Connection extends SqlConnection {
    *
    * @param vertx          the vertx instance
    * @param connectOptions the options for the connection
-   * @param handler        the handler called with the connection or the failure
-   */
-  @Deprecated
-  static void connect(Vertx vertx, DB2ConnectOptions connectOptions, Handler<AsyncResult<DB2Connection>> handler) {
-    Future<DB2Connection> fut = connect(vertx, connectOptions);
-    if (handler != null) {
-      fut.onComplete(handler);
-    }
-  }
-
-  /**
-   * Like {@link #connect(Vertx, DB2ConnectOptions, Handler)} but returns a
-   * {@code Future} of the asynchronous result
+   * @return a future notified with the connection or the failure
    */
   static Future<DB2Connection> connect(Vertx vertx, DB2ConnectOptions connectOptions) {
     return DB2ConnectionImpl.connect(vertx, connectOptions);
   }
 
   /**
-   * Like {@link #connect(Vertx, DB2ConnectOptions, Handler)} with options build
+   * Like {@link #connect(Vertx, DB2ConnectOptions)} with options build
    * from {@code connectionUri}.
    */
-  @Deprecated
-  static void connect(Vertx vertx, String connectionUri, Handler<AsyncResult<DB2Connection>> handler) {
-    connect(vertx, fromUri(connectionUri), handler);
-  }
-
-  /**
-   * Like {@link #connect(Vertx, String, Handler)} but returns a {@code Future} of
-   * the asynchronous result
-   */
   static Future<DB2Connection> connect(Vertx vertx, String connectionUri) {
     return connect(vertx, fromUri(connectionUri));
   }
 
-  @Override
-  @Deprecated
-  DB2Connection prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler);
-
   @Override
   DB2Connection exceptionHandler(Handler<Throwable> handler);
 
@@ -86,32 +58,14 @@ static Future<DB2Connection> connect(Vertx vertx, String connectionUri) {
   /**
    * Send a PING command to check if the server is alive.
    *
-   * @param handler the handler notified when the server responses to client
-   * @return a reference to this, so the API can be used fluently
-   */
-  @Fluent
-  @Deprecated
-  DB2Connection ping(Handler<AsyncResult<Void>> handler);
-
-  /**
-   * Like {@link #ping(Handler)} but returns a {@code Future} of the asynchronous
-   * result
+   * @return a future notified with the server response
    */
   Future<Void> ping();
 
   /**
    * Send a DEBUG command to dump debug information to the server's stdout.
    *
-   * @param handler the handler notified with the execution result
-   * @return a reference to this, so the API can be used fluently
-   */
-  @Fluent
-  @Deprecated
-  DB2Connection debug(Handler<AsyncResult<Void>> handler);
-
-  /**
-   * Like {@link #debug(Handler)} but returns a {@code Future} of the asynchronous
-   * result
+   * @return a future notified with the execution result
    */
   Future<Void> debug();
 

vertx-db2-client/src/main/java/io/vertx/db2client/impl/DB2ConnectionImpl.java

@@ -15,9 +15,7 @@
  */
 package io.vertx.db2client.impl;
 
-import io.vertx.core.AsyncResult;
 import io.vertx.core.Future;
-import io.vertx.core.Handler;
 import io.vertx.core.Vertx;
 import io.vertx.core.impl.ContextInternal;
 import io.vertx.core.spi.metrics.ClientMetrics;
@@ -48,25 +46,11 @@ public DB2ConnectionImpl(ContextInternal context, ConnectionFactory factory, Con
     super(context, factory, conn, DB2Driver.INSTANCE, tracer, metrics);
   }
 
-  @Override
-  public DB2Connection ping(Handler<AsyncResult<Void>> handler) {
-    Future<Void> fut = ping();
-    if (handler != null) {
-      fut.onComplete(handler);
-    }
-    return this;
-  }
-
   @Override
   public Future<Void> ping() {
     return schedule(context, new PingCommand());
   }
 
-  @Override
-  public DB2Connection debug(Handler<AsyncResult<Void>> handler) {
-    throw new UnsupportedOperationException("Debug command not implemented");
-  }
-
   @Override
   public Future<Void> debug() {
     throw new UnsupportedOperationException("Debug command not implemented");

vertx-db2-client/src/main/java/io/vertx/db2client/package-info.java

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-@ModuleGen(name = "vertx-db2-client", groupPackage = "io.vertx", checkCallbackDeprecation = true)
+@ModuleGen(name = "vertx-db2-client", groupPackage = "io.vertx", useFutures = true)
 package io.vertx.db2client;
 
 import io.vertx.codegen.annotations.ModuleGen;

vertx-mssql-client/src/main/java/io/vertx/mssqlclient/MSSQLConnection.java

@@ -13,7 +13,6 @@
 
 import io.vertx.codegen.annotations.Fluent;
 import io.vertx.codegen.annotations.VertxGen;
-import io.vertx.core.AsyncResult;
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
 import io.vertx.core.Vertx;
@@ -34,46 +33,19 @@ public interface MSSQLConnection extends SqlConnection {
    *
    * @param vertx          the vertx instance
    * @param connectOptions the options for the connection
-   * @param handler        the handler called with the connection or the failure
-   */
-  @Deprecated
-  static void connect(Vertx vertx, MSSQLConnectOptions connectOptions, Handler<AsyncResult<MSSQLConnection>> handler) {
-    Future<MSSQLConnection> fut = MSSQLConnectionImpl.connect(vertx, connectOptions);
-    if (handler != null) {
-      fut.onComplete(handler);
-    }
-  }
-
-  /**
-   * Like {@link #connect(Vertx, MSSQLConnectOptions, Handler)} but returns a {@code Future} of the asynchronous result
+   * @return a future notified with the connection or the failure
    */
   static Future<MSSQLConnection> connect(Vertx vertx, MSSQLConnectOptions connectOptions) {
     return MSSQLConnectionImpl.connect(vertx, connectOptions);
   }
 
   /**
-   * Like {@link #connect(Vertx, MSSQLConnectOptions, Handler)} with options built from {@code connectionUri}.
-   */
-  @Deprecated
-  static void connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MSSQLConnection>> handler) {
-    connect(vertx, fromUri(connectionUri), handler);
-  }
-
-  /**
-   * Like {@link #connect(Vertx, String, Handler)} but returns a {@code Future} of the asynchronous result
+   * Like {@link #connect(Vertx, MSSQLConnectOptions)} with options built from {@code connectionUri}.
    */
   static Future<MSSQLConnection> connect(Vertx vertx, String connectionUri) {
     return connect(vertx, fromUri(connectionUri));
   }
 
-  /**
-   * {@inheritDoc}
-   */
-  @Fluent
-  @Override
-  @Deprecated
-  MSSQLConnection prepare(String s, Handler<AsyncResult<PreparedStatement>> handler);
-
   /**
    * {@inheritDoc}
    */

vertx-mssql-client/src/main/java/io/vertx/mssqlclient/package-info.java

@@ -9,7 +9,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
  */
 
-@ModuleGen(name = "vertx-mssql-client", groupPackage = "io.vertx", checkCallbackDeprecation = true)
+@ModuleGen(name = "vertx-mssql-client", groupPackage = "io.vertx", useFutures = true)
 package io.vertx.mssqlclient;
 
 import io.vertx.codegen.annotations.ModuleGen;

vertx-mysql-client/src/main/java/io/vertx/mysqlclient/MySQLConnection.java

@@ -13,13 +13,11 @@
 
 import io.vertx.codegen.annotations.Fluent;
 import io.vertx.codegen.annotations.VertxGen;
-import io.vertx.core.AsyncResult;
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
 import io.vertx.core.Vertx;
 import io.vertx.core.impl.ContextInternal;
 import io.vertx.mysqlclient.impl.MySQLConnectionImpl;
-import io.vertx.sqlclient.PreparedStatement;
 import io.vertx.sqlclient.SqlConnection;
 
 import static io.vertx.mysqlclient.MySQLConnectOptions.fromUri;
@@ -42,51 +40,25 @@
  */
 @VertxGen
 public interface MySQLConnection extends SqlConnection {
+
   /**
    * Create a connection to MySQL server with the given {@code connectOptions}.
    *
    * @param vertx the vertx instance
    * @param connectOptions the options for the connection
-   * @param handler the handler called with the connection or the failure
-   */
-  @Deprecated
-  static void connect(Vertx vertx, MySQLConnectOptions connectOptions, Handler<AsyncResult<MySQLConnection>> handler) {
-    Future<MySQLConnection> fut = connect(vertx, connectOptions);
-    if (handler != null) {
-      fut.onComplete(handler);
-    }
-  }
-
-  /**
-   * Like {@link #connect(Vertx, MySQLConnectOptions, Handler)} but returns a {@code Future} of the asynchronous result
+   * @return a future notified with the connection or the failure
    */
   static Future<MySQLConnection> connect(Vertx vertx, MySQLConnectOptions connectOptions) {
     return MySQLConnectionImpl.connect((ContextInternal) vertx.getOrCreateContext(), connectOptions);
   }
 
   /**
-   * Like {@link #connect(Vertx, MySQLConnectOptions, Handler)} with options built from {@code connectionUri}.
-   */
-  @Deprecated
-  static void connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MySQLConnection>> handler) {
-    connect(vertx, fromUri(connectionUri), handler);
-  }
-
-  /**
-   * Like {@link #connect(Vertx, String, Handler)} but returns a {@code Future} of the asynchronous result
+   * Like {@link #connect(Vertx, MySQLConnectOptions)} with options built from {@code connectionUri}.
    */
   static Future<MySQLConnection> connect(Vertx vertx, String connectionUri) {
     return connect(vertx, fromUri(connectionUri));
   }
 
-  /**
-   * {@inheritDoc}
-   */
-  @Fluent
-  @Override
-  @Deprecated
-  MySQLConnection prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler);
-
   /**
    * {@inheritDoc}
    */
@@ -104,46 +76,22 @@ static Future<MySQLConnection> connect(Vertx vertx, String connectionUri) {
   /**
    * Send a PING command to check if the server is alive.
    *
-   * @param handler the handler notified when the server responses to client
-   * @return a reference to this, so the API can be used fluently
-   */
-  @Fluent
-  @Deprecated
-  MySQLConnection ping(Handler<AsyncResult<Void>> handler);
-
-  /**
-   * Like {@link #ping(Handler)} but returns a {@code Future} of the asynchronous result
+   * @return a future notified with the server response
    */
   Future<Void> ping();
 
   /**
    * Send a INIT_DB command to change the default schema of the connection.
    *
    * @param schemaName name of the schema to change to
-   * @param handler the handler notified with the execution result
-   * @return a reference to this, so the API can be used fluently
-   */
-  @Fluent
-  @Deprecated
-  MySQLConnection specifySchema(String schemaName, Handler<AsyncResult<Void>> handler);
-
-  /**
-   * Like {@link #specifySchema(String, Handler)} but returns a {@code Future} of the asynchronous result
+   * @return a future notified with the execution result
    */
   Future<Void> specifySchema(String schemaName);
 
   /**
    * Send a STATISTICS command to get a human readable string of the server internal status.
    *
-   * @param handler the handler notified with the execution result
-   * @return a reference to this, so the API can be used fluently
-   */
-  @Fluent
-  @Deprecated
-  MySQLConnection getInternalStatistics(Handler<AsyncResult<String>> handler);
-
-  /**
-   * Like {@link #getInternalStatistics(Handler)} but returns a {@code Future} of the asynchronous result
+   * @return a future notified with the execution result
    */
   Future<String> getInternalStatistics();
 
@@ -152,61 +100,28 @@ static Future<MySQLConnection> connect(Vertx vertx, String connectionUri) {
    * Send a SET_OPTION command to set options for the current connection.
    *
    * @param option the options to set
-   * @param handler the handler notified with the execution result
-   * @return a reference to this, so the API can be used fluently
-   */
-  @Fluent
-  @Deprecated
-  MySQLConnection setOption(MySQLSetOption option, Handler<AsyncResult<Void>> handler);
-
-  /**
-   * Like {@link #setOption(MySQLSetOption, Handler)} but returns a {@code Future} of the asynchronous result
+   * @return a future notified with the execution result
    */
   Future<Void> setOption(MySQLSetOption option);
 
   /**
    * Send a RESET_CONNECTION command to reset the session state.
    *
-   * @param handler the handler notified with the execution result
-   * @return a reference to this, so the API can be used fluently
-   */
-  @Fluent
-  @Deprecated
-  MySQLConnection resetConnection(Handler<AsyncResult<Void>> handler);
-
-  /**
-   * Like {@link #resetConnection(Handler)} but returns a {@code Future} of the asynchronous result
+   * @return a future notified with the execution result
    */
   Future<Void> resetConnection();
 
   /**
    * Send a DEBUG command to dump debug information to the server's stdout.
    *
-   * @param handler the handler notified with the execution result
-   * @return a reference to this, so the API can be used fluently
-   */
-  @Fluent
-  @Deprecated
-  MySQLConnection debug(Handler<AsyncResult<Void>> handler);
-
-  /**
-   * Like {@link #debug(Handler)} but returns a {@code Future} of the asynchronous result
+   * @return a future notified with the execution result
    */
   Future<Void> debug();
 
   /**
    * Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
    *
-   * @param options authentication options
-   * @param handler the handler
-   * @return a reference to this, so the API can be used fluently
-   */
-  @Fluent
-  @Deprecated
-  MySQLConnection changeUser(MySQLAuthOptions options, Handler<AsyncResult<Void>> handler);
-
-  /**
-   * Like {@link #changeUser(MySQLAuthOptions, Handler)} but returns a {@code Future} of the asynchronous result
+   * @return a future notified with the execution result
    */
   Future<Void> changeUser(MySQLAuthOptions options);