Updated names / documentation based on new conventions

Refs: JAVA-1659

Author: rozza

driver-async/src/main/com/mongodb/async/client/FindIterableImpl.java

@@ -27,7 +27,6 @@
 import com.mongodb.operation.AsyncOperationExecutor;
 import com.mongodb.operation.FindOperation;
 import org.bson.BsonDocument;
-import org.bson.codecs.Codec;
 import org.bson.codecs.configuration.CodecRegistry;
 import org.bson.conversions.Bson;
 
@@ -166,12 +165,8 @@ private MongoIterable<TResult> execute(final FindOperation<TResult> operation) {
         return new OperationIterable<TResult>(operation, readPreference, executor);
     }
 
-    private <C> Codec<C> getCodec(final Class<C> clazz) {
-        return codecRegistry.get(clazz);
-    }
-
     private FindOperation<TResult> createQueryOperation() {
-        return new FindOperation<TResult>(namespace, getCodec(resultClass))
+        return new FindOperation<TResult>(namespace, codecRegistry.get(resultClass))
                .filter(toBsonDocument(filter))
                .batchSize(findOptions.getBatchSize())
                .skip(findOptions.getSkip())

driver-async/src/main/com/mongodb/async/client/ListCollectionsIterableImpl.java

@@ -24,7 +24,6 @@
 import com.mongodb.operation.AsyncOperationExecutor;
 import com.mongodb.operation.ListCollectionsOperation;
 import org.bson.BsonDocument;
-import org.bson.codecs.Codec;
 import org.bson.codecs.configuration.CodecRegistry;
 import org.bson.conversions.Bson;
 
@@ -107,12 +106,8 @@ private MongoIterable<TResult> execute(final ListCollectionsOperation<TResult> o
         return new OperationIterable<TResult>(operation, readPreference, executor);
     }
 
-    private <C> Codec<C> getCodec(final Class<C> clazz) {
-        return codecRegistry.get(clazz);
-    }
-
     private ListCollectionsOperation<TResult> createListCollectionsOperation() {
-        return new ListCollectionsOperation<TResult>(databaseName, getCodec(resultClass))
+        return new ListCollectionsOperation<TResult>(databaseName, codecRegistry.get(resultClass))
                 .filter(toBsonDocument(filter))
                 .batchSize(batchSize)
                 .maxTime(maxTimeMS, MILLISECONDS);

driver-async/src/main/com/mongodb/async/client/ListDatabasesIterableImpl.java

@@ -19,11 +19,10 @@
 import com.mongodb.Block;
 import com.mongodb.Function;
 import com.mongodb.ReadPreference;
-import com.mongodb.async.SingleResultCallback;
 import com.mongodb.async.AsyncBatchCursor;
+import com.mongodb.async.SingleResultCallback;
 import com.mongodb.operation.AsyncOperationExecutor;
 import com.mongodb.operation.ListDatabasesOperation;
-import org.bson.codecs.Codec;
 import org.bson.codecs.configuration.CodecRegistry;
 
 import java.util.Collection;
@@ -32,73 +31,69 @@
 import static com.mongodb.assertions.Assertions.notNull;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 
-final class ListDatabasesIterableImpl<T> implements ListDatabasesIterable<T> {
-    private final Class<T> clazz;
+final class ListDatabasesIterableImpl<TResult> implements ListDatabasesIterable<TResult> {
+    private final Class<TResult> resultClass;
     private final ReadPreference readPreference;
     private final CodecRegistry codecRegistry;
     private final AsyncOperationExecutor executor;
 
     private long maxTimeMS;
 
-    ListDatabasesIterableImpl(final Class<T> clazz, final CodecRegistry codecRegistry,
+    ListDatabasesIterableImpl(final Class<TResult> resultClass, final CodecRegistry codecRegistry,
                               final ReadPreference readPreference, final AsyncOperationExecutor executor) {
-        this.clazz = notNull("clazz", clazz);
+        this.resultClass = notNull("resultClass", resultClass);
         this.codecRegistry = notNull("codecRegistry", codecRegistry);
         this.readPreference = notNull("readPreference", readPreference);
         this.executor = notNull("executor", executor);
     }
 
     @Override
-    public ListDatabasesIterable<T> maxTime(final long maxTime, final TimeUnit timeUnit) {
+    public ListDatabasesIterable<TResult> maxTime(final long maxTime, final TimeUnit timeUnit) {
         notNull("timeUnit", timeUnit);
         this.maxTimeMS = MILLISECONDS.convert(maxTime, timeUnit);
         return this;
     }
 
     @Override
-    public void first(final SingleResultCallback<T> callback) {
+    public void first(final SingleResultCallback<TResult> callback) {
         execute(createListDatabasesOperation()).first(callback);
     }
 
     @Override
-    public void forEach(final Block<? super T> block, final SingleResultCallback<Void> callback) {
+    public void forEach(final Block<? super TResult> block, final SingleResultCallback<Void> callback) {
         execute().forEach(block, callback);
     }
 
     @Override
-    public <A extends Collection<? super T>> void into(final A target, final SingleResultCallback<A> callback) {
+    public <A extends Collection<? super TResult>> void into(final A target, final SingleResultCallback<A> callback) {
         execute().into(target, callback);
     }
 
     @Override
-    public <U> MongoIterable<U> map(final Function<T, U> mapper) {
-        return new MappingIterable<T, U>(this, mapper);
+    public <U> MongoIterable<U> map(final Function<TResult, U> mapper) {
+        return new MappingIterable<TResult, U>(this, mapper);
     }
 
     @Override
-    public ListDatabasesIterableImpl<T> batchSize(final int batchSize) {
+    public ListDatabasesIterableImpl<TResult> batchSize(final int batchSize) {
         // Noop - not supported by listDatabasesIterable
         return this;
     }
 
     @Override
-    public void batchCursor(final SingleResultCallback<AsyncBatchCursor<T>> callback) {
+    public void batchCursor(final SingleResultCallback<AsyncBatchCursor<TResult>> callback) {
         execute().batchCursor(callback);
     }
 
-    private MongoIterable<T> execute() {
+    private MongoIterable<TResult> execute() {
         return execute(createListDatabasesOperation());
     }
 
-    private MongoIterable<T> execute(final ListDatabasesOperation<T> operation) {
-        return new OperationIterable<T>(operation, readPreference, executor);
-    }
-
-    private <C> Codec<C> getCodec(final Class<C> clazz) {
-        return codecRegistry.get(clazz);
+    private MongoIterable<TResult> execute(final ListDatabasesOperation<TResult> operation) {
+        return new OperationIterable<TResult>(operation, readPreference, executor);
     }
 
-    private ListDatabasesOperation<T> createListDatabasesOperation() {
-        return new ListDatabasesOperation<T>(getCodec(clazz)).maxTime(maxTimeMS, MILLISECONDS);
+    private ListDatabasesOperation<TResult> createListDatabasesOperation() {
+        return new ListDatabasesOperation<TResult>(codecRegistry.get(resultClass)).maxTime(maxTimeMS, MILLISECONDS);
     }
 }

driver-async/src/main/com/mongodb/async/client/ListIndexesIterableImpl.java

@@ -24,7 +24,6 @@
 import com.mongodb.async.SingleResultCallback;
 import com.mongodb.operation.AsyncOperationExecutor;
 import com.mongodb.operation.ListIndexesOperation;
-import org.bson.codecs.Codec;
 import org.bson.codecs.configuration.CodecRegistry;
 
 import java.util.Collection;
@@ -98,12 +97,8 @@ private MongoIterable<TResult> execute(final ListIndexesOperation<TResult> opera
         return new OperationIterable<TResult>(operation, readPreference, executor);
     }
 
-    private <C> Codec<C> getCodec(final Class<C> clazz) {
-        return codecRegistry.get(clazz);
-    }
-
     private ListIndexesOperation<TResult> createListIndexesOperation() {
-        return new ListIndexesOperation<TResult>(namespace, getCodec(resultClass))
+        return new ListIndexesOperation<TResult>(namespace, codecRegistry.get(resultClass))
                 .batchSize(batchSize)
                 .maxTime(maxTimeMS, MILLISECONDS);
     }

driver-async/src/main/com/mongodb/async/client/MongoClient.java

@@ -73,10 +73,10 @@ public interface MongoClient extends Closeable {
     /**
      * Gets the list of databases
      *
-     * @param clazz the class to cast the database documents to
-     * @param <T>   the type of the class to use instead of {@code Document}.
+     * @param resultClass the class to cast the database documents to
+     * @param <TResult>   the type of the class to use instead of {@code Document}.
      * @return the list databases iterable interface
      */
-    <T> ListDatabasesIterable<T> listDatabases(Class<T> clazz);
+    <TResult> ListDatabasesIterable<TResult> listDatabases(Class<TResult> resultClass);
 
 }

driver-async/src/main/com/mongodb/async/client/MongoClientImpl.java

@@ -107,8 +107,8 @@ public ListDatabasesIterable<Document> listDatabases() {
     }
 
     @Override
-    public <T> ListDatabasesIterable<T> listDatabases(final Class<T> clazz) {
-        return new ListDatabasesIterableImpl<T>(clazz, options.getCodecRegistry(), ReadPreference.primary(), executor);
+    public <T> ListDatabasesIterable<T> listDatabases(final Class<T> resultClass) {
+        return new ListDatabasesIterableImpl<T>(resultClass, options.getCodecRegistry(), ReadPreference.primary(), executor);
     }
 
     Cluster getCluster() {

driver-async/src/main/com/mongodb/async/client/MongoCollection.java

@@ -42,7 +42,7 @@
 
 /**
  * The MongoCollection interface.
- *
+ * <p/>
  * <p>Note: Additions to this interface will not be considered to break binary compatibility.</p>
  *
  * @param <TDocument> The type that this collection will encode documents from and decode documents to.
@@ -89,11 +89,11 @@ public interface MongoCollection<TDocument> {
     /**
      * Create a new MongoCollection instance with a different default class to cast any documents returned from the database into..
      *
-     * @param clazz the default class to cast any documents returned from the database into.
-     * @param <NewTDocument> The type that the new collection will encode documents from and decode documents to
+     * @param newDocumentClass the default class to cast any documents returned from the database into.
+     * @param <NewTDocument>   the type that the new collection will encode documents from and decode documents to
      * @return a new MongoCollection instance with the different default class
      */
-    <NewTDocument> MongoCollection<NewTDocument> withDocumentClass(Class<NewTDocument> clazz);
+    <NewTDocument> MongoCollection<NewTDocument> withDocumentClass(Class<NewTDocument> newDocumentClass);
 
     /**
      * Create a new MongoCollection instance with a different codec registry.
@@ -146,13 +146,13 @@ public interface MongoCollection<TDocument> {
     /**
      * Gets the distinct values of the specified field name.
      *
-     * @param fieldName the field name
-     * @param clazz     the default class to cast any distinct items into.
-     * @param <TResult>       the target type of the iterable.
+     * @param fieldName   the field name
+     * @param resultClass the default class to cast any distinct items into.
+     * @param <TResult>   the target type of the iterable.
      * @return an iterable of distinct values
      * @mongodb.driver.manual reference/command/distinct/ Distinct
      */
-    <TResult> DistinctIterable<TResult> distinct(String fieldName, Class<TResult> clazz);
+    <TResult> DistinctIterable<TResult> distinct(String fieldName, Class<TResult> resultClass);
 
     /**
      * Finds all documents in the collection.
@@ -165,12 +165,12 @@ public interface MongoCollection<TDocument> {
     /**
      * Finds all documents in the collection.
      *
-     * @param clazz the class to decode each document into
+     * @param resultClass the class to decode each document into
      * @param <TResult>   the target document type of the iterable.
      * @return the find iterable interface
      * @mongodb.driver.manual tutorial/query-documents/ Find
      */
-    <TResult> FindIterable<TResult> find(Class<TResult> clazz);
+    <TResult> FindIterable<TResult> find(Class<TResult> resultClass);
 
     /**
      * Finds all documents in the collection.
@@ -184,13 +184,13 @@ public interface MongoCollection<TDocument> {
     /**
      * Finds all documents in the collection.
      *
-     * @param filter the query filter
-     * @param clazz  the class to decode each document into
-     * @param <TResult>    the target document type of the iterable.
+     * @param filter      the query filter
+     * @param resultClass the class to decode each document into
+     * @param <TResult>   the target document type of the iterable.
      * @return the find iterable interface
      * @mongodb.driver.manual tutorial/query-documents/ Find
      */
-    <TResult> FindIterable<TResult> find(Bson filter, Class<TResult> clazz);
+    <TResult> FindIterable<TResult> find(Bson filter, Class<TResult> resultClass);
 
     /**
      * Aggregates documents according to the specified aggregation pipeline.  If the pipeline ends with a $out stage, the returned
@@ -208,13 +208,13 @@ public interface MongoCollection<TDocument> {
      * iterable will be a query of the collection that the aggregation was written to.  Note that in this case the pipeline will be
      * executed even if the iterable is never iterated.
      *
-     * @param pipeline the aggregate pipeline
-     * @param clazz    the class to decode each document into
-     * @param <TResult>      the target document type of the iterable.
+     * @param pipeline    the aggregate pipeline
+     * @param resultClass the class to decode each document into
+     * @param <TResult>   the target document type of the iterable.
      * @return an iterable containing the result of the aggregation operation
      * @mongodb.driver.manual aggregation/ Aggregation
      */
-    <TResult> AggregateIterable<TResult> aggregate(List<? extends Bson> pipeline, Class<TResult> clazz);
+    <TResult> AggregateIterable<TResult> aggregate(List<? extends Bson> pipeline, Class<TResult> resultClass);
 
     /**
      * Aggregates documents according to the specified map-reduce function.
@@ -231,12 +231,12 @@ public interface MongoCollection<TDocument> {
      *
      * @param mapFunction    A JavaScript function that associates or "maps" a value with a key and emits the key and value pair.
      * @param reduceFunction A JavaScript function that "reduces" to a single object all the values associated with a particular key.
-     * @param clazz          the class to decode each resulting document into.
-     * @param <TResult>            the target document type of the iterable.
+     * @param resultClass    the class to decode each resulting document into.
+     * @param <TResult>      the target document type of the iterable.
      * @return an iterable containing the result of the map-reduce operation
      * @mongodb.driver.manual reference/command/mapReduce/ map-reduce
      */
-    <TResult> MapReduceIterable<TResult> mapReduce(String mapFunction, String reduceFunction, Class<TResult> clazz);
+    <TResult> MapReduceIterable<TResult> mapReduce(String mapFunction, String reduceFunction, Class<TResult> resultClass);
 
     /**
      * Executes a mix of inserts, updates, replaces, and deletes.
@@ -500,12 +500,12 @@ void bulkWrite(List<? extends WriteModel<? extends TDocument>> requests, BulkWri
     /**
      * Get all the indexes in this collection.
      *
-     * @param clazz    the class to decode each document into
-     * @param <TResult>      the target document type of the iterable.
+     * @param resultClass the class to decode each document into
+     * @param <TResult>   the target document type of the iterable.
      * @return the list indexes iterable interface
      * @mongodb.driver.manual reference/command/listIndexes/ listIndexes
      */
-    <TResult> ListIndexesIterable<TResult> listIndexes(Class<TResult> clazz);
+    <TResult> ListIndexesIterable<TResult> listIndexes(Class<TResult> resultClass);
 
     /**
      * Drops the given index.

driver-async/src/main/com/mongodb/async/client/MongoCollectionImpl.java

@@ -121,8 +121,8 @@ public WriteConcern getWriteConcern() {
     }
 
     @Override
-    public <NewTDocument> MongoCollection<NewTDocument> withDocumentClass(final Class<NewTDocument> documentClass) {
-        return new MongoCollectionImpl<NewTDocument>(namespace, documentClass, codecRegistry, readPreference, writeConcern, executor);
+    public <NewTDocument> MongoCollection<NewTDocument> withDocumentClass(final Class<NewTDocument> newDocumentClass) {
+        return new MongoCollectionImpl<NewTDocument>(namespace, newDocumentClass, codecRegistry, readPreference, writeConcern, executor);
     }
 
     @Override