Various API cleanups

Author: vietj

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

@@ -102,14 +102,14 @@ public void init() {
   protected <R> void doSchedule(CommandBase<R> cmd, Completable<R> handler) {
     if (cmd instanceof TxCommand) {
       TxCommand<R> txCmd = (TxCommand<R>) cmd;
-      if (txCmd.kind == TxCommand.Kind.BEGIN) {
+      if (txCmd.kind() == TxCommand.Kind.BEGIN) {
         // DB2 always implicitly starts a transaction with each query, and does
         // not support the 'BEGIN' keyword. Instead we can no-op BEGIN commands
-        handler.succeed(txCmd.result);
+        handler.succeed(txCmd.result());
       } else {
-        SimpleQueryCommand<Void> cmd2 = new SimpleQueryCommand<>(txCmd.kind.sql, false, false,
-            QueryCommandBase.NULL_COLLECTOR, QueryResultHandler.NOOP_HANDLER);
-        super.doSchedule(cmd2, (res, err) -> handler.complete(txCmd.result, err));
+        SimpleQueryCommand<Void> cmd2 = new SimpleQueryCommand<>(txCmd.kind().sql(), false, false,
+            SocketConnectionBase.NULL_COLLECTOR, QueryResultHandler.NOOP_HANDLER);
+        super.doSchedule(cmd2, (res, err) -> handler.complete(txCmd.result(), err));
 
       }
     } else {

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

@@ -14,10 +14,8 @@
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.ChannelPromise;
 import io.netty.handler.ssl.SslHandler;
-import io.vertx.core.AsyncResult;
 import io.vertx.core.Completable;
 import io.vertx.core.Future;
-import io.vertx.core.Handler;
 import io.vertx.core.internal.ContextInternal;
 import io.vertx.core.internal.PromiseInternal;
 import io.vertx.core.internal.tls.SslContextManager;
@@ -166,14 +164,14 @@ public void init() {
   protected <R> void doSchedule(CommandBase<R> cmd, Completable<R> handler) {
     if (cmd instanceof TxCommand) {
       TxCommand<R> tx = (TxCommand<R>) cmd;
-      String sql = tx.kind == BEGIN ? "BEGIN TRANSACTION":tx.kind.sql;
+      String sql = tx.kind() == BEGIN ? "BEGIN TRANSACTION" : tx.kind().sql();
       SimpleQueryCommand<Void> cmd2 = new SimpleQueryCommand<>(
         sql,
         false,
         false,
-        QueryCommandBase.NULL_COLLECTOR,
+        SocketConnectionBase.NULL_COLLECTOR,
         QueryResultHandler.NOOP_HANDLER);
-      super.doSchedule(cmd2, (res, err) -> handler.complete(tx.result, err));
+      super.doSchedule(cmd2, (res, err) -> handler.complete(tx.result(), err));
     } else {
       super.doSchedule(cmd, handler);
     }

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

@@ -43,7 +43,6 @@
 import io.vertx.sqlclient.impl.SocketConnectionBase;
 import io.vertx.sqlclient.internal.command.CommandBase;
 import io.vertx.sqlclient.internal.command.ExtendedQueryCommand;
-import io.vertx.sqlclient.internal.command.QueryCommandBase;
 import io.vertx.sqlclient.internal.command.SimpleQueryCommand;
 import io.vertx.sqlclient.internal.command.TxCommand;
 import io.vertx.sqlclient.spi.DatabaseMetadata;
@@ -122,12 +121,12 @@ protected <R> void doSchedule(CommandBase<R> cmd, Completable<R> handler) {
     if (cmd instanceof TxCommand) {
       TxCommand<R> tx = (TxCommand<R>) cmd;
       SimpleQueryCommand<Void> cmd2 = new SimpleQueryCommand<>(
-        tx.kind.sql,
+        tx.kind().sql(),
         false,
         false,
-        QueryCommandBase.NULL_COLLECTOR,
+        SocketConnectionBase.NULL_COLLECTOR,
         QueryResultHandler.NOOP_HANDLER);
-      super.doSchedule(cmd2, (res, err) -> handler.complete(tx.result, err));
+      super.doSchedule(cmd2, (res, err) -> handler.complete(tx.result(), err));
     } else {
       super.doSchedule(cmd, handler);
     }

vertx-oracle-client/src/main/java/io/vertx/oracleclient/impl/commands/OracleTransactionCommand.java

@@ -35,14 +35,14 @@ public static <U> OracleTransactionCommand<U> create(OracleConnection oracleConn
   @Override
   protected Future<R> execute() {
     Future<Void> result;
-    if (op.kind == BEGIN) {
+    if (op.kind() == BEGIN) {
       result = begin();
-    } else if (op.kind == COMMIT) {
+    } else if (op.kind() == COMMIT) {
       result = commit();
     } else {
       result = rollback();
     }
-    return result.map(op.result);
+    return result.map(op.result());
   }
 
   private Future<Void> begin() {

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

@@ -163,12 +163,12 @@ protected <R> void doSchedule(CommandBase<R> cmd, Completable<R> handler) {
     if (cmd instanceof TxCommand) {
       TxCommand<R> tx = (TxCommand<R>) cmd;
       SimpleQueryCommand<Void> cmd2 = new SimpleQueryCommand<>(
-        tx.kind.sql,
+        tx.kind().sql(),
         false,
         false,
-        QueryCommandBase.NULL_COLLECTOR,
+        SocketConnectionBase.NULL_COLLECTOR,
         QueryResultHandler.NOOP_HANDLER);
-      super.doSchedule(cmd2, (res, err) -> handler.complete(tx.result, err));
+      super.doSchedule(cmd2, (res, err) -> handler.complete(tx.result(), err));
     } else {
       super.doSchedule(cmd, handler);
     }

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

@@ -29,6 +29,7 @@
 import io.vertx.core.tracing.TracingPolicy;
 import io.vertx.core.internal.ContextInternal;
 import io.vertx.core.internal.net.NetSocketInternal;
+import io.vertx.sqlclient.Row;
 import io.vertx.sqlclient.SqlConnectOptions;
 import io.vertx.sqlclient.impl.cache.PreparedStatementCache;
 import io.vertx.sqlclient.impl.codec.InvalidCachedStatementEvent;
@@ -39,13 +40,16 @@
 
 import java.util.ArrayDeque;
 import java.util.List;
+import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.stream.Collector;
 
 /**
  * @author <a href="mailto:[email protected]">Julien Viet</a>
  */
 public abstract class SocketConnectionBase implements Connection {
 
+  public static final Collector<Row, Void, Void> NULL_COLLECTOR = Collector.of(() -> null, (v, row) -> {}, (v1, v2) -> null, Function.identity());
   private static final Completable<?> NULL_HANDLER = (res, err) -> {};
 
   public static final Logger logger = LoggerFactory.getLogger(SocketConnectionBase.class);

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

@@ -20,7 +20,6 @@
 import io.vertx.sqlclient.Row;
 import io.vertx.sqlclient.internal.QueryResultHandler;
 
-import java.util.function.Function;
 import java.util.stream.Collector;
 
 /**
@@ -29,8 +28,6 @@
 
 public abstract class QueryCommandBase<T> extends CommandBase<Boolean> {
 
-  public static final Collector<Row, Void, Void> NULL_COLLECTOR = Collector.of(() -> null, (v,row) -> {}, (v1, v2) -> null, Function.identity());
-
   private final QueryResultHandler<T> resultHandler;
   private final Collector<Row, ?, T> collector;
   private final boolean autoCommit;

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

@@ -17,18 +17,30 @@ public enum Kind {
 
     BEGIN(), ROLLBACK(), COMMIT();
 
-    public final String sql;
+    private final String sql;
 
     Kind() {
       this.sql = name();
     }
+
+    public String sql() {
+      return sql;
+    }
   }
 
-  public final R result;
-  public final Kind kind;
+  private final R result;
+  private final Kind kind;
 
   public TxCommand(Kind kind, R result) {
     this.kind = kind;
     this.result = result;
   }
+
+  public R result() {
+    return result;
+  }
+
+  public Kind kind() {
+    return kind;
+  }
 }