Maximum variables made private

Author: marat-gainullin

TODO.md

@@ -1,6 +1,7 @@
 ## Refactoring
 * Make futures completable through arbitrary executor.
-* Make maximum number of all variables private.
+
+##Review
 * Review all round trips.
 
 ## Tests

src/main/java/com/github/pgasync/ConnectionPoolBuilder.java

@@ -28,7 +28,7 @@
  */
 public class ConnectionPoolBuilder {
 
-    final PoolProperties properties = new PoolProperties();
+    private final PoolProperties properties = new PoolProperties();
 
     /**
      * @return Pool ready for use

src/main/java/com/github/pgasync/impl/PgColumn.java

@@ -21,13 +21,25 @@
  */
 public class PgColumn {
 
-    final int index;
-    final String name;
-    final Oid type;
+    private final int index;
+    private final String name;
+    private final Oid type;
 
     public PgColumn(int index, String name, Oid type) {
         this.index = index;
         this.name = name;
         this.type = type;
     }
+
+    public Oid getType() {
+        return type;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int at() {
+        return index;
+    }
 }

src/main/java/com/github/pgasync/impl/PgConnection.java

@@ -62,7 +62,7 @@ public class PgPreparedStatement implements PreparedStatement {
         private final String sname;
         private final String pname;
 
-        public PgPreparedStatement(String sname, String pname) {
+        PgPreparedStatement(String sname, String pname) {
             this.sname = sname;
             this.pname = pname;
         }
@@ -117,10 +117,10 @@ private String next() {
     private static final NameSequence preparedStatementNames = new NameSequence("s-");
     private static final NameSequence portalNames = new NameSequence("p-");
 
-    final PgProtocolStream stream;
-    final DataConverter dataConverter;
+    private final PgProtocolStream stream;
+    private final DataConverter dataConverter;
 
-    public PgConnection(PgProtocolStream stream, DataConverter dataConverter) {
+    PgConnection(PgProtocolStream stream, DataConverter dataConverter) {
         this.stream = stream;
         this.dataConverter = dataConverter;
     }
@@ -132,7 +132,7 @@ CompletableFuture<Connection> connect(String username, String password, String d
                 .thenApply(authenticationOk -> PgConnection.this);
     }
 
-    CompletableFuture<? extends Message> authenticate(String username, String password, Message message) {
+    private CompletableFuture<? extends Message> authenticate(String username, String password, Message message) {
         return message instanceof Authentication && !((Authentication) message).isAuthenticationOk()
                 ? stream.authenticate(new PasswordMessage(username, password, ((Authentication) message).getMd5Salt()))
                 : CompletableFuture.completedFuture(message);
@@ -216,7 +216,7 @@ public CompletableFuture<Void> close() {
         return stream.close();
     }
 
-    static Map<String, PgColumn> calcColumns(ColumnDescription[] descriptions) {
+    private static Map<String, PgColumn> calcColumns(ColumnDescription[] descriptions) {
         Map<String, PgColumn> columns = new LinkedHashMap<>();
         for (int i = 0; i < descriptions.length; i++) {
             columns.put(descriptions[i].getName().toUpperCase(), new PgColumn(i, descriptions[i].getName(), descriptions[i].getType()));

src/main/java/com/github/pgasync/impl/PgConnectionPool.java

@@ -142,23 +142,23 @@ public CompletableFuture<Integer> fetch(Consumer<Map<String, PgColumn>> onColumn
         }
     }
 
-    final int maxConnections;
-    final int maxStatements;
-    final ReentrantLock lock = new ReentrantLock();
+    private final int maxConnections;
+    private final int maxStatements;
+    private final ReentrantLock lock = new ReentrantLock();
     @GuardedBy("lock")
-    int size;
+    private int size;
     @GuardedBy("lock")
-    boolean closed;
+    private boolean closed;
     @GuardedBy("lock")
-    final Queue<CompletableFuture<? super Connection>> subscribers = new LinkedList<>();
+    private final Queue<CompletableFuture<? super Connection>> subscribers = new LinkedList<>();
     @GuardedBy("lock")
-    final Queue<PooledPgConnection> connections = new LinkedList<>();
+    private final Queue<PooledPgConnection> connections = new LinkedList<>();
 
-    final InetSocketAddress address;
-    final String username;
-    final String password;
-    final String database;
-    final DataConverter dataConverter;
+    private final InetSocketAddress address;
+    private final String username;
+    private final String password;
+    private final String database;
+    private final DataConverter dataConverter;
 
     public PgConnectionPool(PoolProperties properties) {
         this.address = InetSocketAddress.createUnresolved(properties.getHostname(), properties.getPort());

src/main/java/com/github/pgasync/impl/PgResultSet.java

@@ -26,9 +26,9 @@
  */
 public class PgResultSet implements ResultSet {
 
-    final List<Row> rows;
-    final Map<String, PgColumn> columns;
-    final int affectedRows;
+    private final List<Row> rows;
+    private final Map<String, PgColumn> columns;
+    private final int affectedRows;
 
     public PgResultSet(Map<String, PgColumn> columns, List<Row> rows, int affectedRows) {
         this.columns = columns;

src/main/java/com/github/pgasync/impl/PgRow.java

@@ -33,12 +33,12 @@
  */
 public class PgRow implements Row {
 
-    final DataRow data;
-    final DataConverter dataConverter;
-    final Map<String, PgColumn> columns;
-    final PgColumn[] pgColumns;
+    private final DataRow data;
+    private final DataConverter dataConverter;
+    private final Map<String, PgColumn> columns;
+    private final PgColumn[] pgColumns;
 
-    public PgRow(DataRow data, Map<String, PgColumn> columns, DataConverter dataConverter) {
+    PgRow(DataRow data, Map<String, PgColumn> columns, DataConverter dataConverter) {
         this.data = data;
         this.dataConverter = dataConverter;
         this.columns = columns;
@@ -47,190 +47,190 @@ public PgRow(DataRow data, Map<String, PgColumn> columns, DataConverter dataConv
 
     @Override
     public String getString(int index) {
-        return dataConverter.toString(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toString(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public String getString(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toString(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toString(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Character getChar(int index) {
-        return dataConverter.toChar(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toChar(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public Character getChar(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toChar(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toChar(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Byte getByte(int index) {
-        return dataConverter.toByte(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toByte(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public Byte getByte(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toByte(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toByte(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Short getShort(int index) {
-        return dataConverter.toShort(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toShort(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public Short getShort(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toShort(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toShort(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Integer getInt(int index) {
-        return dataConverter.toInteger(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toInteger(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public Integer getInt(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toInteger(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toInteger(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Long getLong(int index) {
-        return dataConverter.toLong(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toLong(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public Long getLong(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toLong(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toLong(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public BigInteger getBigInteger(int index) {
-        return dataConverter.toBigInteger(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toBigInteger(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public BigInteger getBigInteger(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toBigInteger(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toBigInteger(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public BigDecimal getBigDecimal(int index) {
-        return dataConverter.toBigDecimal(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toBigDecimal(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public BigDecimal getBigDecimal(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toBigDecimal(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toBigDecimal(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Double getDouble(int index) {
-        return dataConverter.toDouble(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toDouble(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public Double getDouble(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toDouble(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toDouble(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Date getDate(int index) {
-        return dataConverter.toDate(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toDate(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public Date getDate(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toDate(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toDate(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Time getTime(int index) {
-        return dataConverter.toTime(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toTime(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public Time getTime(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toTime(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toTime(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Timestamp getTimestamp(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toTimestamp(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toTimestamp(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Timestamp getTimestamp(int index) {
-        return dataConverter.toTimestamp(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toTimestamp(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public byte[] getBytes(int index) {
-        return dataConverter.toBytes(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toBytes(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public byte[] getBytes(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toBytes(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toBytes(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public Boolean getBoolean(int index) {
-        return dataConverter.toBoolean(pgColumns[index].type, data.getValue(index));
+        return dataConverter.toBoolean(pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public Boolean getBoolean(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toBoolean(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toBoolean(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public <TArray> TArray getArray(String column, Class<TArray> arrayType) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toArray(arrayType, pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toArray(arrayType, pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     @Override
     public <TArray> TArray getArray(int index, Class<TArray> arrayType) {
-        return dataConverter.toArray(arrayType, pgColumns[index].type, data.getValue(index));
+        return dataConverter.toArray(arrayType, pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public <T> T get(int index, Class<T> type) {
-        return dataConverter.toObject(type, pgColumns[index].type, data.getValue(index));
+        return dataConverter.toObject(type, pgColumns[index].getType(), data.getValue(index));
     }
 
     @Override
     public <T> T get(String column, Class<T> type) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toObject(type, pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toObject(type, pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     public Object get(String column) {
         PgColumn pgColumn = getColumn(column);
-        return dataConverter.toObject(pgColumn.type, data.getValue(pgColumn.index));
+        return dataConverter.toObject(pgColumn.getType(), data.getValue(pgColumn.at()));
     }
 
     public Map<String, PgColumn> getColumns() {
         return columns;
     }
 
-    PgColumn getColumn(String name) {
+    private PgColumn getColumn(String name) {
         if (name == null) {
             throw new IllegalArgumentException("Column name is required");
         }