Avoid dealing with the command base handler when we can, since we want to remove it.

Author: vietj

vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/codec/TdsMessageCodec.java

@@ -65,10 +65,7 @@ private void fail(Throwable cause) {
   }
 
   private void fail(MSSQLCommandCodec<?, ?> codec, Throwable cause) {
-    Completable<?> handler = codec.cmd.handler;
-    if (handler != null) {
-      handler.complete(null, cause);
-    }
+    codec.cmd.fail(cause);
   }
 
   @Override

vertx-mysql-client/src/main/java/io/vertx/mysqlclient/impl/codec/MySQLCodec.java

@@ -81,10 +81,7 @@ private void clearInflightCommands(Throwable cause) {
   private void fail(CommandCodec<?, ?> codec, Throwable cause) {
     if (failure == null) {
       failure = cause;
-      Completable<?> handler = codec.cmd.handler;
-      if (handler != null) {
-        handler.complete(null, cause);
-      }
+      codec.cmd.fail(cause);
     }
   }
 

vertx-pg-client/src/main/java/io/vertx/pgclient/impl/codec/PgCodec.java

@@ -83,10 +83,7 @@ private void fail(Throwable cause) {
   }
 
   private void fail(PgCommandCodec<?, ?> codec, Throwable cause) {
-    Completable<?> handler = codec.cmd.handler;
-    if (handler != null) {
-      handler.complete(null, cause);
-    }
+    codec.cmd.fail(cause);
   }
 
   @Override

vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/SocketConnectionBase.java

@@ -213,7 +213,7 @@ protected <R> void doSchedule(CommandBase<R> cmd, Completable<R> handler) {
         CompositeCommand composite = (CompositeCommand) cmd;
         List<CommandBase<?>> commands = composite.commands();
         pending.addAll(commands);
-        composite.handler.succeed();
+        composite.succeed();
       } else {
         pending.add(cmd);
       }

vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/TransactionImpl.java

@@ -46,17 +46,15 @@ public TransactionImpl(ContextInternal context, Handler<Void> endHandler, Connec
   public Future<Transaction> begin() {
     PromiseInternal<Transaction> promise = context.promise();
     TxCommand<Transaction> begin = new TxCommand<>(TxCommand.Kind.BEGIN, this);
-    begin.handler = wrap(begin, promise);
-    schedule(begin);
+    scheduleInternal(begin, wrap(begin, promise));
     return promise.future();
   }
 
   public void fail() {
     failed = true;
   }
 
-  private <R> void execute(CommandBase<R> cmd) {
-    Completable<R> handler = cmd.handler;
+  private <R> void execute(CommandBase<R> cmd, Completable<R> handler) {
     connection.schedule(cmd, handler);
   }
 
@@ -71,35 +69,42 @@ private <T> Completable<T> wrap(CommandBase<?> cmd, Completable<T> handler) {
   }
 
   public <R> void schedule(CommandBase<R> cmd, Completable<R> handler) {
-    cmd.handler = wrap(cmd, handler);
-    if (!schedule(cmd)) {
+    if (!scheduleInternal(cmd, wrap(cmd, handler))) {
       handler.fail("Transaction already completed");
     }
   }
 
-  public <R> boolean schedule(CommandBase<R> b) {
+  public <R> boolean scheduleInternal(CommandBase<R> b, Completable<R> handler) {
     synchronized (this) {
       if (ended) {
         return false;
       }
       pendingQueries++;
     }
-    execute(b);
+    execute(b, handler);
     return true;
   }
 
   private void checkEnd() {
-    TxCommand<?> cmd;
+    TxCommand<Void> cmd;
+    Completable<Void> handler;
     synchronized (this) {
       if (pendingQueries > 0 || !ended || endCommand != null) {
         return;
       }
       TxCommand.Kind kind = failed ? TxCommand.Kind.ROLLBACK : TxCommand.Kind.COMMIT;
-      endCommand = txCommand(kind);
-      cmd = endCommand;
+      cmd = new TxCommand<>(kind, null);
+      handler = (res, err) -> {
+        if (err == null) {
+          completion.complete(kind);
+        } else {
+          completion.fail(err);
+        }
+      };
+      endCommand = cmd;
     }
     endHandler.handle(null);
-    execute(cmd);
+    execute(cmd, handler);
   }
 
   private Future<TxCommand.Kind> end(boolean rollback) {
@@ -144,18 +149,6 @@ public void rollback(Handler<AsyncResult<Void>> handler) {
     }
   }
 
-  private TxCommand<Void> txCommand(TxCommand.Kind kind) {
-    TxCommand<Void> cmd = new TxCommand<>(kind, null);
-    cmd.handler = (res, err) -> {
-      if (err == null) {
-        completion.complete(kind);
-      } else {
-        completion.fail(err);
-      }
-    };
-    return cmd;
-  }
-
   @Override
   public Future<Void> completion() {
     return completion.future().flatMap(k -> {

vertx-sql-client/src/main/java/io/vertx/sqlclient/internal/command/CommandBase.java

@@ -28,7 +28,6 @@
 
 public abstract class CommandBase<R> {
 
-  // Todo : hide this
   public Completable<R> handler;
 
   public final void fail(Throwable err) {

vertx-sql-client/src/main/java/io/vertx/sqlclient/internal/command/CompositeCommand.java

@@ -20,4 +20,8 @@ public <R> void add(CommandBase<R> cmd, Completable<R> handler) {
   public List<CommandBase<?>> commands() {
     return commands;
   }
+
+  public final void succeed() {
+    handler.succeed();
+  }
 }