Coverage Report

Coverage Report - com.allanbank.mongodb.client.AbstractAsyncMongoCollection

Classes in this File
Line Coverage
Branch Coverage
Complexity
AbstractAsyncMongoCollection
94%
257/271
N/A
 /*
  * #%L
  * AbstractAsyncMongoCollection.java - mongodb-async-driver - Allanbank Consulting, Inc.
  * %%
  * Copyright (C) 2011 - 2014 Allanbank Consulting, Inc.
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * 
  *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * #L%
  */
 package com.allanbank.mongodb.client;
 
 import java.util.Collection;
 
 import com.allanbank.mongodb.AsyncMongoCollection;
 import com.allanbank.mongodb.Callback;
 import com.allanbank.mongodb.Durability;
 import com.allanbank.mongodb.LambdaCallback;
 import com.allanbank.mongodb.ListenableFuture;
 import com.allanbank.mongodb.LockType;
 import com.allanbank.mongodb.MongoCollection;
 import com.allanbank.mongodb.MongoCursorControl;
 import com.allanbank.mongodb.MongoDatabase;
 import com.allanbank.mongodb.MongoDbException;
 import com.allanbank.mongodb.MongoIterator;
 import com.allanbank.mongodb.ReadPreference;
 import com.allanbank.mongodb.StreamCallback;
 import com.allanbank.mongodb.bson.Document;
 import com.allanbank.mongodb.bson.DocumentAssignable;
 import com.allanbank.mongodb.bson.Element;
 import com.allanbank.mongodb.bson.builder.BuilderFactory;
 import com.allanbank.mongodb.builder.Aggregate;
 import com.allanbank.mongodb.builder.BatchedWrite;
 import com.allanbank.mongodb.builder.ConditionBuilder;
 import com.allanbank.mongodb.builder.Count;
 import com.allanbank.mongodb.builder.Distinct;
 import com.allanbank.mongodb.builder.Find;
 import com.allanbank.mongodb.builder.FindAndModify;
 import com.allanbank.mongodb.builder.GroupBy;
 import com.allanbank.mongodb.builder.MapReduce;
 import com.allanbank.mongodb.builder.ParallelScan;
 
 /**
  * Helper class for forward all methods to the canonical version (which is
  * abstract in this class).
  * <p>
  * This class keeps the clutter in the derived class to a minimum and also deals
  * with the conversion of the asynchronous method invocations into synchronous
  * methods for those uses cases that do not require an asynchronous interface.
  * </p>
  * 
  * @api.no This class is <b>NOT</b> part of the drivers API. This class may be
  *         mutated in incompatible ways between any two releases of the driver.
  * @copyright 2011-2013, Allanbank Consulting, Inc., All Rights Reserved
  */
 public abstract class AbstractAsyncMongoCollection extends
         AbstractMongoOperations implements AsyncMongoCollection {
 
     /**
      * Create a new AbstractAsyncMongoCollection.
      * 
      * @param client
      *            The client for interacting with MongoDB.
      * @param database
      *            The database we interact with.
      * @param name
      *            The name of the collection we interact with.
      */
     public AbstractAsyncMongoCollection(final Client client,
             final MongoDatabase database, final String name) {
         super(client, database, name);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #aggregateAsync(Callback, Aggregate)}.
      * </p>
      * 
      * @see #aggregateAsync(Callback, Aggregate)
      */
     @Override
     public ListenableFuture<MongoIterator<Document>> aggregateAsync(
             final Aggregate command) throws MongoDbException {
         final FutureCallback<MongoIterator<Document>> future;
 
         future = new FutureCallback<MongoIterator<Document>>(getLockType());
 
         aggregateAsync(future, command);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #aggregateAsync(Aggregate)}.
      * </p>
      */
     @Override
     public ListenableFuture<MongoIterator<Document>> aggregateAsync(
             final Aggregate.Builder command) throws MongoDbException {
         return aggregateAsync(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #aggregateAsync(Callback, Aggregate)}.
      * </p>
      */
     @Override
     public void aggregateAsync(final Callback<MongoIterator<Document>> results,
             final Aggregate.Builder command) throws MongoDbException {
         aggregateAsync(results, command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #aggregateAsync(Callback, Aggregate)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void aggregateAsync(
             final LambdaCallback<MongoIterator<Document>> results,
             final Aggregate command) throws MongoDbException {
         aggregateAsync(new LambdaCallbackAdapter<MongoIterator<Document>>(
                 results), command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #aggregateAsync(Callback, Aggregate.Builder)} method with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void aggregateAsync(
             final LambdaCallback<MongoIterator<Document>> results,
             final Aggregate.Builder command) throws MongoDbException {
         aggregateAsync(new LambdaCallbackAdapter<MongoIterator<Document>>(
                 results), command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #countAsync(DocumentAssignable,ReadPreference)} method with
      * {@link #getReadPreference()} as the <tt>readPreference</tt> argument and
      * an empty {@code query} document.
      * </p>
      */
     @Override
     public ListenableFuture<Long> countAsync() throws MongoDbException {
         return countAsync(BuilderFactory.start(), getReadPreference());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #countAsync(Callback,DocumentAssignable,ReadPreference)} method
      * with {@link #getReadPreference()} as the <tt>readPreference</tt> argument
      * and an empty {@code query} document.
      * </p>
      */
     @Override
     public void countAsync(final Callback<Long> results)
             throws MongoDbException {
         countAsync(results, BuilderFactory.start(), getReadPreference());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #countAsync(Callback, Count)
      * countAsync(results, count.build())}.
      * </p>
      */
     @Override
     public void countAsync(final Callback<Long> results,
             final Count.Builder count) throws MongoDbException {
         countAsync(results, count.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #countAsync(Callback, DocumentAssignable, ReadPreference)} method
      * with {@link #getReadPreference()} as the <tt>readPreference</tt>
      * argument.
      * </p>
      */
     @Override
     public void countAsync(final Callback<Long> results,
             final DocumentAssignable query) throws MongoDbException {
         countAsync(results, query, getReadPreference());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #countAsync(Callback, Count)} method with
      * the query and read preferences set.
      * </p>
      */
     @Override
     public void countAsync(final Callback<Long> results,
             final DocumentAssignable query, final ReadPreference readPreference)
             throws MongoDbException {
         countAsync(results,
                 Count.builder().query(query).readPreference(readPreference)
                         .build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #countAsync(Callback,DocumentAssignable,ReadPreference)} method
      * with an empty {@code query} document.
      * </p>
      */
     @Override
     public void countAsync(final Callback<Long> results,
             final ReadPreference readPreference) throws MongoDbException {
         countAsync(results, BuilderFactory.start(), readPreference);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #countAsync(Callback, Count)}.
      * </p>
      * On an error counting the documents.
      */
     @Override
     public ListenableFuture<Long> countAsync(final Count count)
             throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         countAsync(future, count);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #countAsync(Count)
      * countAsync(count.build())}.
      * </p>
      */
     @Override
     public ListenableFuture<Long> countAsync(final Count.Builder count)
             throws MongoDbException {
         return countAsync(count.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #countAsync(Callback, DocumentAssignable, ReadPreference)} method
      * with {@link #getReadPreference()} as the <tt>readPreference</tt>
      * argument.
      * </p>
      * 
      * @param query
      *            The query document.
      * @return A future that will be updated with the number of matching
      *         documents.
      * @throws MongoDbException
      *             On an error finding the documents.
      */
     @Override
     public ListenableFuture<Long> countAsync(final DocumentAssignable query)
             throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         countAsync(future, query, getReadPreference());
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #countAsync(Callback, DocumentAssignable, ReadPreference)} method.
      * </p>
      */
     @Override
     public ListenableFuture<Long> countAsync(final DocumentAssignable query,
             final ReadPreference readPreference) throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         countAsync(future, query, readPreference);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #countAsync(Callback)} method with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void countAsync(final LambdaCallback<Long> results)
             throws MongoDbException {
         countAsync(new LambdaCallbackAdapter<Long>(results));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #countAsync(Callback, Count)} method with
      * an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void countAsync(final LambdaCallback<Long> results, final Count count)
             throws MongoDbException {
         countAsync(new LambdaCallbackAdapter<Long>(results), count);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #countAsync(Callback, Count.Builder)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void countAsync(final LambdaCallback<Long> results,
             final Count.Builder count) throws MongoDbException {
         countAsync(new LambdaCallbackAdapter<Long>(results), count);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #countAsync(Callback, DocumentAssignable)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void countAsync(final LambdaCallback<Long> results,
             final DocumentAssignable query) throws MongoDbException {
         countAsync(new LambdaCallbackAdapter<Long>(results), query);
 
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #countAsync(Callback, DocumentAssignable, ReadPreference)} method
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void countAsync(final LambdaCallback<Long> results,
             final DocumentAssignable query, final ReadPreference readPreference)
             throws MongoDbException {
         countAsync(new LambdaCallbackAdapter<Long>(results), query,
                 readPreference);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #countAsync(Callback, ReadPreference)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void countAsync(final LambdaCallback<Long> results,
             final ReadPreference readPreference) throws MongoDbException {
         countAsync(new LambdaCallbackAdapter<Long>(results), readPreference);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #countAsync(DocumentAssignable,ReadPreference)} method with an
      * empty {@code query} document.
      * </p>
      */
     @Override
     public ListenableFuture<Long> countAsync(final ReadPreference readPreference)
             throws MongoDbException {
         return countAsync(BuilderFactory.start(), readPreference);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #deleteAsync(Callback, DocumentAssignable, boolean, Durability)}
      * method with false as the <tt>singleDelete</tt> argument and the
      * {@link #getDurability() default durability}.
      * </p>
      * 
      * @see #deleteAsync(Callback, DocumentAssignable, boolean, Durability)
      */
     @Override
     public void deleteAsync(final Callback<Long> results,
             final DocumentAssignable query) throws MongoDbException {
         deleteAsync(results, query, DELETE_SINGLE_DELETE_DEFAULT,
                 getDurability());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #deleteAsync(Callback, DocumentAssignable, boolean, Durability)}
      * method with the {@link #getDurability() default durability}.
      * </p>
      * 
      * @see MongoCollection#deleteAsync(Callback, DocumentAssignable)
      */
     @Override
     public void deleteAsync(final Callback<Long> results,
             final DocumentAssignable query, final boolean singleDelete)
             throws MongoDbException {
         deleteAsync(results, query, singleDelete, getDurability());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #deleteAsync(Callback, DocumentAssignable, boolean, Durability)}
      * method with false as the <tt>singleDelete</tt> argument.
      * </p>
      * 
      * @see MongoCollection#deleteAsync(Callback, DocumentAssignable, boolean)
      */
     @Override
     public void deleteAsync(final Callback<Long> results,
             final DocumentAssignable query, final Durability durability)
             throws MongoDbException {
         deleteAsync(results, query, DELETE_SINGLE_DELETE_DEFAULT, durability);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #deleteAsync(Callback, DocumentAssignable, boolean, Durability)}
      * method with false as the <tt>singleDelete</tt> argument and the
      * {@link #getDurability() default durability}.
      * </p>
      * 
      * @see MongoCollection#deleteAsync(Callback, DocumentAssignable)
      */
     @Override
     public ListenableFuture<Long> deleteAsync(final DocumentAssignable query)
             throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         deleteAsync(future, query, DELETE_SINGLE_DELETE_DEFAULT,
                 getDurability());
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #deleteAsync(Callback, DocumentAssignable, boolean, Durability)}
      * method with the {@link #getDurability() default durability}.
      * </p>
      * 
      * @see MongoCollection#deleteAsync(Callback, DocumentAssignable)
      */
     @Override
     public ListenableFuture<Long> deleteAsync(final DocumentAssignable query,
             final boolean singleDelete) throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         deleteAsync(future, query, singleDelete, getDurability());
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #deleteAsync(Callback, DocumentAssignable)}
      * method.
      * </p>
      * 
      * @see MongoCollection#deleteAsync(Callback, DocumentAssignable)
      */
     @Override
     public ListenableFuture<Long> deleteAsync(final DocumentAssignable query,
             final boolean singleDelete, final Durability durability)
             throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         deleteAsync(future, query, singleDelete, durability);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #deleteAsync(Callback, DocumentAssignable)}
      * method with false as the <tt>singleDelete</tt> argument.
      * </p>
      * 
      * @see MongoCollection#deleteAsync(Callback, DocumentAssignable)
      */
     @Override
     public ListenableFuture<Long> deleteAsync(final DocumentAssignable query,
             final Durability durability) throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         deleteAsync(future, query, DELETE_SINGLE_DELETE_DEFAULT, durability);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #deleteAsync(Callback, DocumentAssignable)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void deleteAsync(final LambdaCallback<Long> results,
             final DocumentAssignable query) throws MongoDbException {
         deleteAsync(new LambdaCallbackAdapter<Long>(results), query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #deleteAsync(Callback, DocumentAssignable, boolean)} method with
      * an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void deleteAsync(final LambdaCallback<Long> results,
             final DocumentAssignable query, final boolean singleDelete)
             throws MongoDbException {
         deleteAsync(new LambdaCallbackAdapter<Long>(results), query,
                 singleDelete);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #deleteAsync(Callback, DocumentAssignable, boolean, Durability)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void deleteAsync(final LambdaCallback<Long> results,
             final DocumentAssignable query, final boolean singleDelete,
             final Durability durability) throws MongoDbException {
         deleteAsync(new LambdaCallbackAdapter<Long>(results), query,
                 singleDelete, durability);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #deleteAsync(Callback, DocumentAssignable, Durability)} method
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void deleteAsync(final LambdaCallback<Long> results,
             final DocumentAssignable query, final Durability durability)
             throws MongoDbException {
         deleteAsync(new LambdaCallbackAdapter<Long>(results), query, durability);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #distinctAsync(Callback, Distinct)}.
      * </p>
      */
     @Override
     public void distinctAsync(final Callback<MongoIterator<Element>> results,
             final Distinct.Builder command) throws MongoDbException {
         distinctAsync(results, command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #distinctAsync(Callback, Distinct)}.
      * </p>
      */
     @Override
     public ListenableFuture<MongoIterator<Element>> distinctAsync(
             final Distinct command) throws MongoDbException {
         final FutureCallback<MongoIterator<Element>> future = new FutureCallback<MongoIterator<Element>>(
                 getLockType());
 
         distinctAsync(future, command);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #distinctAsync(Distinct)}.
      * </p>
      */
     @Override
     public ListenableFuture<MongoIterator<Element>> distinctAsync(
             final Distinct.Builder command) throws MongoDbException {
         return distinctAsync(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #distinctAsync(Callback, Distinct)} method
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void distinctAsync(
             final LambdaCallback<MongoIterator<Element>> results,
             final Distinct command) throws MongoDbException {
         distinctAsync(
                 new LambdaCallbackAdapter<MongoIterator<Element>>(results),
                 command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #distinctAsync(Callback, Distinct.Builder)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void distinctAsync(
             final LambdaCallback<MongoIterator<Element>> results,
             final Distinct.Builder command) throws MongoDbException {
         distinctAsync(
                 new LambdaCallbackAdapter<MongoIterator<Element>>(results),
                 command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Callback,Aggregate)} method.
      * </p>
      */
     @Override
     public ListenableFuture<Document> explainAsync(final Aggregate aggregation)
             throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         explainAsync(future, aggregation);
 
         return future;
 
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Callback,Aggregate)} method.
      * </p>
      */
     @Override
     public ListenableFuture<Document> explainAsync(
             final Aggregate.Builder aggregation) throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         explainAsync(future, aggregation.build());
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Callback,Aggregate)} method.
      * </p>
      */
     @Override
     public void explainAsync(final Callback<Document> results,
             final Aggregate.Builder aggregation) throws MongoDbException {
         explainAsync(results, aggregation.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Callback,Find)} method.
      * </p>
      */
     @Override
     public void explainAsync(final Callback<Document> results,
             final Find.Builder query) throws MongoDbException {
         explainAsync(results, query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Callback,Find)} method.
      * </p>
      * 
      * @see #explainAsync(Callback,Find)
      */
     @Override
     public ListenableFuture<Document> explainAsync(final Find query)
             throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         explainAsync(future, query);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Find)} method.
      * </p>
      */
     @Override
     public ListenableFuture<Document> explainAsync(final Find.Builder query)
             throws MongoDbException {
         return explainAsync(query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Callback, Aggregate)} method
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void explainAsync(final LambdaCallback<Document> results,
             final Aggregate aggregation) throws MongoDbException {
         explainAsync(new LambdaCallbackAdapter<Document>(results), aggregation);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Callback, Aggregate.Builder)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void explainAsync(final LambdaCallback<Document> results,
             final Aggregate.Builder aggregation) throws MongoDbException {
         explainAsync(new LambdaCallbackAdapter<Document>(results), aggregation);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Callback, Find)} method with
      * an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void explainAsync(final LambdaCallback<Document> results,
             final Find query) throws MongoDbException {
         explainAsync(new LambdaCallbackAdapter<Document>(results), query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Callback, Find.Builder)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void explainAsync(final LambdaCallback<Document> results,
             final Find.Builder query) throws MongoDbException {
         explainAsync(new LambdaCallbackAdapter<Document>(results), query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #findAndModifyAsync(Callback,FindAndModify)}.
      * </p>
      */
     @Override
     public void findAndModifyAsync(final Callback<Document> results,
             final FindAndModify.Builder command) throws MongoDbException {
         findAndModifyAsync(results, command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #findAndModifyAsync(Callback, FindAndModify)}.
      * </p>
      * 
      * @see #findAndModifyAsync(Callback, FindAndModify)
      */
     @Override
     public ListenableFuture<Document> findAndModifyAsync(
             final FindAndModify command) throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         findAndModifyAsync(future, command);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAndModifyAsync(FindAndModify)}.
      * </p>
      */
     @Override
     public ListenableFuture<Document> findAndModifyAsync(
             final FindAndModify.Builder command) throws MongoDbException {
         return findAndModifyAsync(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #findAndModifyAsync(Callback, FindAndModify)} method with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void findAndModifyAsync(final LambdaCallback<Document> results,
             final FindAndModify command) throws MongoDbException {
         findAndModifyAsync(new LambdaCallbackAdapter<Document>(results),
                 command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #findAndModifyAsync(Callback, FindAndModify.Builder)} method with
      * an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void findAndModifyAsync(final LambdaCallback<Document> results,
             final FindAndModify.Builder command) throws MongoDbException {
         findAndModifyAsync(new LambdaCallbackAdapter<Document>(results),
                 command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Callback, Find)}.
      * </p>
      * 
      * @see #findAsync(Callback, DocumentAssignable)
      */
     @Override
     public void findAsync(final Callback<MongoIterator<Document>> results,
             final DocumentAssignable query) throws MongoDbException {
         findAsync(results, new Find.Builder(query).build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Callback,Find)} method.
      * </p>
      */
     @Override
     public void findAsync(final Callback<MongoIterator<Document>> results,
             final Find.Builder query) throws MongoDbException {
         findAsync(results, query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Callback, DocumentAssignable)}.
      * </p>
      * 
      * @see #findAsync(Callback, DocumentAssignable)
      */
     @Override
     public ListenableFuture<MongoIterator<Document>> findAsync(
             final DocumentAssignable query) throws MongoDbException {
         final FutureCallback<MongoIterator<Document>> future = new FutureCallback<MongoIterator<Document>>(
                 getLockType());
 
         findAsync(future, query);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Callback, Find)}.
      * </p>
      * 
      * @see #findAsync(Callback, Find)
      */
     @Override
     public ListenableFuture<MongoIterator<Document>> findAsync(final Find query)
             throws MongoDbException {
         final FutureCallback<MongoIterator<Document>> future = new FutureCallback<MongoIterator<Document>>(
                 getLockType());
 
         findAsync(future, query);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Find)} method.
      * </p>
      */
     @Override
     public ListenableFuture<MongoIterator<Document>> findAsync(
             final Find.Builder query) throws MongoDbException {
         return findAsync(query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Callback, DocumentAssignable)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void findAsync(
             final LambdaCallback<MongoIterator<Document>> results,
             final DocumentAssignable query) throws MongoDbException {
         findAsync(new LambdaCallbackAdapter<MongoIterator<Document>>(results),
                 query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Callback, Find)} method with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void findAsync(
             final LambdaCallback<MongoIterator<Document>> results,
             final Find query) throws MongoDbException {
         findAsync(new LambdaCallbackAdapter<MongoIterator<Document>>(results),
                 query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Callback, Find.Builder)} method
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void findAsync(
             final LambdaCallback<MongoIterator<Document>> results,
             final Find.Builder query) throws MongoDbException {
         findAsync(new LambdaCallbackAdapter<MongoIterator<Document>>(results),
                 query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findOneAsync(Callback, Find)}.
      * </p>
      * 
      * @see #findOneAsync(Callback, Find)
      */
     @Override
     public void findOneAsync(final Callback<Document> results,
             final DocumentAssignable query) throws MongoDbException {
         findOneAsync(results, new Find.Builder(query).build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findOneAsync(Callback, Find)} method.
      * </p>
      */
     @Override
     public void findOneAsync(final Callback<Document> results,
             final Find.Builder query) throws MongoDbException {
         findOneAsync(results, query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #findOneAsync(Callback, DocumentAssignable)}.
      * </p>
      * 
      * @see #findOneAsync(Callback, DocumentAssignable)
      */
     @Override
     public ListenableFuture<Document> findOneAsync(
             final DocumentAssignable query) throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         findOneAsync(future, query);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findOneAsync(Callback, Find)}.
      * </p>
      * 
      * @see #findOneAsync(Callback, Find)
      */
     @Override
     public ListenableFuture<Document> findOneAsync(final Find query)
             throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         findOneAsync(future, query);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findOneAsync(Find)} method.
      * </p>
      */
     @Override
     public ListenableFuture<Document> findOneAsync(final Find.Builder query)
             throws MongoDbException {
         return findOneAsync(query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Callback, DocumentAssignable)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void findOneAsync(final LambdaCallback<Document> results,
             final DocumentAssignable query) throws MongoDbException {
         findOneAsync(new LambdaCallbackAdapter<Document>(results), query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Callback, Find)} method with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void findOneAsync(final LambdaCallback<Document> results,
             final Find query) throws MongoDbException {
         findOneAsync(new LambdaCallbackAdapter<Document>(results), query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Callback, Find.Builder)} method
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void findOneAsync(final LambdaCallback<Document> results,
             final Find.Builder query) throws MongoDbException {
         findOneAsync(new LambdaCallbackAdapter<Document>(results), query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #groupByAsync(Callback,GroupBy)}.
      * </p>
      */
     @Override
     public void groupByAsync(final Callback<MongoIterator<Element>> results,
             final GroupBy.Builder command) throws MongoDbException {
         groupByAsync(results, command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #groupByAsync(Callback, GroupBy)}.
      * </p>
      */
     @Override
     public ListenableFuture<MongoIterator<Element>> groupByAsync(
             final GroupBy command) throws MongoDbException {
         final FutureCallback<MongoIterator<Element>> future = new FutureCallback<MongoIterator<Element>>(
                 getLockType());
 
         groupByAsync(future, command);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #groupByAsync(GroupBy)}.
      * </p>
      */
     @Override
     public ListenableFuture<MongoIterator<Element>> groupByAsync(
             final GroupBy.Builder command) throws MongoDbException {
         return groupByAsync(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #groupByAsync(Callback, GroupBy)} method
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void groupByAsync(
             final LambdaCallback<MongoIterator<Element>> results,
             final GroupBy command) throws MongoDbException {
         groupByAsync(
                 new LambdaCallbackAdapter<MongoIterator<Element>>(results),
                 command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #groupByAsync(Callback, GroupBy.Builder)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void groupByAsync(
             final LambdaCallback<MongoIterator<Element>> results,
             final GroupBy.Builder command) throws MongoDbException {
         groupByAsync(
                 new LambdaCallbackAdapter<MongoIterator<Element>>(results),
                 command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, boolean, Durability, DocumentAssignable...)}
      * method with the {@link #getDurability() default durability}.
      * </p>
      * 
      * @see MongoCollection#insertAsync(Callback, boolean, Durability,
      *      DocumentAssignable[])
      */
     @Override
     public ListenableFuture<Integer> insertAsync(final boolean continueOnError,
             final DocumentAssignable... documents) throws MongoDbException {
         final FutureCallback<Integer> future = new FutureCallback<Integer>(
                 getLockType());
 
         insertAsync(future, continueOnError, getDurability(), documents);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, boolean, Durability, DocumentAssignable...)}
      * method with <tt>continueOnError</tt> set to false and the
      * {@link #getDurability() default durability}.
      * </p>
      * 
      * @see MongoCollection#insertAsync(Callback, boolean, Durability,
      *      DocumentAssignable[])
      */
     @Override
     public ListenableFuture<Integer> insertAsync(final boolean continueOnError,
             final Durability durability, final DocumentAssignable... documents)
             throws MongoDbException {
         final FutureCallback<Integer> future = new FutureCallback<Integer>(
                 getLockType());
 
         insertAsync(future, continueOnError, durability, documents);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, boolean, Durability, DocumentAssignable...)}
      * method the {@link #getDurability() default durability}.
      * </p>
      * 
      * @see MongoCollection#insertAsync(Callback, boolean, Durability,
      *      DocumentAssignable[])
      */
     @Override
     public void insertAsync(final Callback<Integer> results,
             final boolean continueOnError,
             final DocumentAssignable... documents) throws MongoDbException {
         insertAsync(results, continueOnError, getDurability(), documents);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, boolean, Durability, DocumentAssignable...)}
      * method with <tt>continueOnError</tt> set to false and the
      * {@link #getDurability() default durability}.
      * </p>
      * 
      * @see MongoCollection#insertAsync(Callback, boolean, Durability,
      *      DocumentAssignable[])
      */
     @Override
     public void insertAsync(final Callback<Integer> results,
             final DocumentAssignable... documents) throws MongoDbException {
         insertAsync(results, INSERT_CONTINUE_ON_ERROR_DEFAULT, getDurability(),
                 documents);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, boolean, Durability, DocumentAssignable...)}
      * method with <tt>continueOnError</tt> set to false.
      * </p>
      * 
      * @see MongoCollection#insertAsync(Callback, boolean, Durability,
      *      DocumentAssignable[])
      */
     @Override
     public void insertAsync(final Callback<Integer> results,
             final Durability durability, final DocumentAssignable... documents)
             throws MongoDbException {
         insertAsync(results, INSERT_CONTINUE_ON_ERROR_DEFAULT, durability,
                 documents);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, boolean, Durability, DocumentAssignable...)}
      * method with <tt>continueOnError</tt> set to false and the
      * {@link #getDurability() default durability}.
      * </p>
      * 
      * @see MongoCollection#insertAsync(Callback, boolean, Durability,
      *      DocumentAssignable[])
      */
     @Override
     public ListenableFuture<Integer> insertAsync(
             final DocumentAssignable... documents) throws MongoDbException {
         final FutureCallback<Integer> future = new FutureCallback<Integer>(
                 getLockType());
 
         insertAsync(future, INSERT_CONTINUE_ON_ERROR_DEFAULT, getDurability(),
                 documents);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, boolean, Durability, DocumentAssignable...)}
      * method with <tt>continueOnError</tt> set to false.
      * </p>
      * 
      * @see MongoCollection#insertAsync(Callback, boolean, Durability,
      *      DocumentAssignable[])
      */
     @Override
     public ListenableFuture<Integer> insertAsync(final Durability durability,
             final DocumentAssignable... documents) throws MongoDbException {
         final FutureCallback<Integer> future = new FutureCallback<Integer>(
                 getLockType());
 
         insertAsync(future, INSERT_CONTINUE_ON_ERROR_DEFAULT, durability,
                 documents);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, boolean, DocumentAssignable[])} method with
      * an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void insertAsync(final LambdaCallback<Integer> results,
             final boolean continueOnError,
             final DocumentAssignable... documents) throws MongoDbException {
         insertAsync(new LambdaCallbackAdapter<Integer>(results),
                 continueOnError, documents);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, boolean, Durability, DocumentAssignable[])}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void insertAsync(final LambdaCallback<Integer> results,
             final boolean continueOnError, final Durability durability,
             final DocumentAssignable... documents) throws MongoDbException {
         insertAsync(new LambdaCallbackAdapter<Integer>(results),
                 continueOnError, durability, documents);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, DocumentAssignable[])} method with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void insertAsync(final LambdaCallback<Integer> results,
             final DocumentAssignable... documents) throws MongoDbException {
         insertAsync(new LambdaCallbackAdapter<Integer>(results), documents);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(Callback, Durability, DocumentAssignable[])} method
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void insertAsync(final LambdaCallback<Integer> results,
             final Durability durability, final DocumentAssignable... documents)
             throws MongoDbException {
         insertAsync(new LambdaCallbackAdapter<Integer>(results), durability,
                 documents);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #mapReduceAsync(Callback,MapReduce)}.
      * </p>
      */
     @Override
     public void mapReduceAsync(final Callback<MongoIterator<Document>> results,
             final MapReduce.Builder command) throws MongoDbException {
         mapReduceAsync(results, command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #mapReduceAsync(Callback, MapReduce)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void mapReduceAsync(
             final LambdaCallback<MongoIterator<Document>> results,
             final MapReduce command) throws MongoDbException {
         mapReduceAsync(new LambdaCallbackAdapter<MongoIterator<Document>>(
                 results), command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #mapReduceAsync(Callback, MapReduce.Builder)} method with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void mapReduceAsync(
             final LambdaCallback<MongoIterator<Document>> results,
             final MapReduce.Builder command) throws MongoDbException {
         mapReduceAsync(new LambdaCallbackAdapter<MongoIterator<Document>>(
                 results), command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #mapReduceAsync(Callback, MapReduce)}.
      * </p>
      * 
      * @see #mapReduceAsync(Callback, MapReduce)
      */
     @Override
     public ListenableFuture<MongoIterator<Document>> mapReduceAsync(
             final MapReduce command) throws MongoDbException {
         final FutureCallback<MongoIterator<Document>> future = new FutureCallback<MongoIterator<Document>>(
                 getLockType());
 
         mapReduceAsync(future, command);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #mapReduceAsync(MapReduce)}.
      * </p>
      */
     @Override
     public ListenableFuture<MongoIterator<Document>> mapReduceAsync(
             final MapReduce.Builder command) throws MongoDbException {
         return mapReduceAsync(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #parallelScanAsync(Callback, ParallelScan)}
      * .
      * </p>
      */
     @Override
     public void parallelScanAsync(
             final Callback<Collection<MongoIterator<Document>>> results,
             final ParallelScan.Builder parallelScan) throws MongoDbException {
         parallelScanAsync(results, parallelScan.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #parallelScanAsync(Callback, ParallelScan)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void parallelScanAsync(
             final LambdaCallback<Collection<MongoIterator<Document>>> results,
             final ParallelScan parallelScan) throws MongoDbException {
         parallelScanAsync(
                 new LambdaCallbackAdapter<Collection<MongoIterator<Document>>>(
                         results), parallelScan);
 
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #parallelScanAsync(LambdaCallback, ParallelScan)} method.
      * </p>
      */
     @Override
     public void parallelScanAsync(
             final LambdaCallback<Collection<MongoIterator<Document>>> results,
             final ParallelScan.Builder parallelScan) throws MongoDbException {
         parallelScanAsync(results, parallelScan.build());
 
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #parallelScanAsync(Callback, ParallelScan)}
      * .
      * </p>
      */
     @Override
     public ListenableFuture<Collection<MongoIterator<Document>>> parallelScanAsync(
             final ParallelScan parallelScan) throws MongoDbException {
         final FutureCallback<Collection<MongoIterator<Document>>> future;
         future = new FutureCallback<Collection<MongoIterator<Document>>>(
                 getLockType());
 
         parallelScanAsync(future, parallelScan);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #parallelScanAsync(Callback, ParallelScan)}
      * .
      * </p>
      */
     @Override
     public ListenableFuture<Collection<MongoIterator<Document>>> parallelScanAsync(
             final ParallelScan.Builder parallelScan) throws MongoDbException {
         return parallelScanAsync(parallelScan.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #saveAsync(Callback, DocumentAssignable, Durability)} using the
      * {@link #getDurability() default durability}.
      * </p>
      */
     @Override
     public void saveAsync(final Callback<Integer> results,
             final DocumentAssignable document) throws MongoDbException {
         saveAsync(results, document, getDurability());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #saveAsync(Callback, DocumentAssignable, Durability)} using the
      * {@link #getDurability() default durability}.
      * </p>
      */
     @Override
     public ListenableFuture<Integer> saveAsync(final DocumentAssignable document)
             throws MongoDbException {
         final FutureCallback<Integer> future = new FutureCallback<Integer>(
                 getLockType());
 
         saveAsync(future, document, getDurability());
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #saveAsync(Callback, DocumentAssignable, Durability)}.
      * </p>
      */
     @Override
     public ListenableFuture<Integer> saveAsync(
             final DocumentAssignable document, final Durability durability)
             throws MongoDbException {
         final FutureCallback<Integer> future = new FutureCallback<Integer>(
                 getLockType());
 
         saveAsync(future, document, durability);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #saveAsync(Callback, DocumentAssignable)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void saveAsync(final LambdaCallback<Integer> results,
             final DocumentAssignable document) throws MongoDbException {
         saveAsync(new LambdaCallbackAdapter<Integer>(results), document);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #saveAsync(Callback, DocumentAssignable, Durability)} method with
      * an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void saveAsync(final LambdaCallback<Integer> results,
             final DocumentAssignable document, final Durability durability)
             throws MongoDbException {
         saveAsync(new LambdaCallbackAdapter<Integer>(results), document,
                 durability);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #stream(StreamCallback, Aggregate)} method
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public MongoCursorControl stream(final LambdaCallback<Document> results,
             final Aggregate aggregation) throws MongoDbException {
         return stream(new LambdaCallbackAdapter<Document>(results), aggregation);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #stream(StreamCallback, Aggregate.Builder)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public MongoCursorControl stream(final LambdaCallback<Document> results,
             final Aggregate.Builder aggregation) throws MongoDbException {
         return stream(new LambdaCallbackAdapter<Document>(results), aggregation);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #stream(StreamCallback, Find)} method with
      * an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public MongoCursorControl stream(final LambdaCallback<Document> results,
             final Find query) throws MongoDbException {
         return stream(new LambdaCallbackAdapter<Document>(results), query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #stream(StreamCallback, Find.Builder)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public MongoCursorControl stream(final LambdaCallback<Document> results,
             final Find.Builder aggregation) throws MongoDbException {
         return stream(new LambdaCallbackAdapter<Document>(results), aggregation);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #stream(StreamCallback, Aggregate)}.
      * </p>
      * 
      * @see #stream(StreamCallback, Aggregate)
      */
     @Override
     public MongoCursorControl stream(final StreamCallback<Document> results,
             final Aggregate.Builder aggregation) throws MongoDbException {
         return stream(results, aggregation.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #stream(StreamCallback, Find)} method.
      * </p>
      */
     @Override
     public MongoCursorControl stream(final StreamCallback<Document> results,
             final Find.Builder query) throws MongoDbException {
         return streamingFind(results, query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #streamingFind(Callback, Find)}.
      * </p>
      * 
      * @see #streamingFind(Callback, Find)
      */
     @Deprecated
     @Override
     public MongoCursorControl streamingFind(final Callback<Document> results,
             final DocumentAssignable query) throws MongoDbException {
         return streamingFind(results, new Find.Builder(query).build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #stream(StreamCallback, Find)}.
      * </p>
      * 
      * @see #stream(StreamCallback, Find)
      */
     @Deprecated
     @Override
     public MongoCursorControl streamingFind(final Callback<Document> results,
             final Find query) throws MongoDbException {
         return stream(
                 new com.allanbank.mongodb.client.callback.LegacyStreamCallbackAdapter(
                         results), query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #streamingFind(StreamCallback, DocumentAssignable)} method with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public MongoCursorControl streamingFind(
             final LambdaCallback<Document> results,
             final DocumentAssignable query) throws MongoDbException {
         return streamingFind(new LambdaCallbackAdapter<Document>(results),
                 query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #stream(StreamCallback, Find)}.
      * </p>
      * 
      * @see #stream(StreamCallback, Find)
      */
     @Override
     public MongoCursorControl streamingFind(
             final StreamCallback<Document> results,
             final DocumentAssignable query) throws MongoDbException {
         return stream(results, new Find.Builder(query).build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #streamingFind(StreamCallback, Find)}.
      * </p>
      * 
      * @see #stream(StreamCallback, Find)
      */
     @Deprecated
     @Override
     public MongoCursorControl streamingFind(
             final StreamCallback<Document> results, final Find query)
             throws MongoDbException {
         return stream(results, query);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #streamingFind(StreamCallback, Find)}
      * method.
      * </p>
      */
     @Deprecated
     @Override
     public MongoCursorControl streamingFind(
             final StreamCallback<Document> results, final Find.Builder query)
             throws MongoDbException {
         return streamingFind(results, query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #textSearchAsync(Callback, com.allanbank.mongodb.builder.Text)}.
      * </p>
      * 
      * @deprecated Support for the {@code text} command was deprecated in the
      *             2.6 version of MongoDB. Use the
      *             {@link ConditionBuilder#text(String) $text} query operator
      *             instead. This method will not be removed until two releases
      *             after the MongoDB 2.6 release (e.g. 2.10 if the releases are
      *             2.8 and 2.10).
      */
     @Deprecated
     @Override
     public void textSearchAsync(
             final Callback<MongoIterator<com.allanbank.mongodb.builder.TextResult>> results,
             final com.allanbank.mongodb.builder.Text.Builder command)
             throws MongoDbException {
         textSearchAsync(results, command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #textSearchAsync(Callback, com.allanbank.mongodb.builder.Text)}.
      * </p>
      * 
      * @see #textSearchAsync(Callback, com.allanbank.mongodb.builder.Text)
      * @deprecated Support for the {@code text} command was deprecated in the
      *             2.6 version of MongoDB. Use the
      *             {@link ConditionBuilder#text(String) $text} query operator
      *             instead. This method will not be removed until two releases
      *             after the MongoDB 2.6 release (e.g. 2.10 if the releases are
      *             2.8 and 2.10).
      */
     @Deprecated
     @Override
     public ListenableFuture<MongoIterator<com.allanbank.mongodb.builder.TextResult>> textSearchAsync(
             final com.allanbank.mongodb.builder.Text command)
             throws MongoDbException {
         final FutureCallback<MongoIterator<com.allanbank.mongodb.builder.TextResult>> future;
         future = new FutureCallback<MongoIterator<com.allanbank.mongodb.builder.TextResult>>(
                 getLockType());
 
         textSearchAsync(future, command);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #textSearchAsync(com.allanbank.mongodb.builder.Text)}.
      * </p>
      * 
      * @deprecated Support for the {@code text} command was deprecated in the
      *             2.6 version of MongoDB. Use the
      *             {@link ConditionBuilder#text(String) $text} query operator
      *             instead. This method will not be removed until two releases
      *             after the MongoDB 2.6 release (e.g. 2.10 if the releases are
      *             2.8 and 2.10).
      */
     @Deprecated
     @Override
     public ListenableFuture<MongoIterator<com.allanbank.mongodb.builder.TextResult>> textSearchAsync(
             final com.allanbank.mongodb.builder.Text.Builder command)
             throws MongoDbException {
         return textSearchAsync(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * with multiUpdate set to true, upsert set to false, and using the
      * {@link #getDurability() default durability}.
      * </p>
      * 
      * @see #updateAsync(Callback, DocumentAssignable, DocumentAssignable,
      *      boolean, boolean, Durability)
      */
     @Override
     public void updateAsync(final Callback<Long> results,
             final DocumentAssignable query, final DocumentAssignable update)
             throws MongoDbException {
         updateAsync(results, query, update, UPDATE_MULTIUPDATE_DEFAULT,
                 UPDATE_UPSERT_DEFAULT, getDurability());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * using the {@link #getDurability() default durability}.
      * </p>
      * 
      * @see #updateAsync(Callback, DocumentAssignable, DocumentAssignable,
      *      boolean, boolean, Durability)
      */
     @Override
     public void updateAsync(final Callback<Long> results,
             final DocumentAssignable query, final DocumentAssignable update,
             final boolean multiUpdate, final boolean upsert)
             throws MongoDbException {
         updateAsync(results, query, update, multiUpdate, upsert,
                 getDurability());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * with multiUpdate set to true, and upsert set to false.
      * </p>
      * 
      * @see #updateAsync(Callback, DocumentAssignable, DocumentAssignable,
      *      boolean, boolean, Durability)
      */
     @Override
     public void updateAsync(final Callback<Long> results,
             final DocumentAssignable query, final DocumentAssignable update,
             final Durability durability) throws MongoDbException {
         updateAsync(results, query, update, UPDATE_MULTIUPDATE_DEFAULT,
                 UPDATE_UPSERT_DEFAULT, durability);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * with multiUpdate set to true, upsert set to false, and using the
      * {@link #getDurability() default durability}.
      * </p>
      * 
      * @see #updateAsync(Callback, DocumentAssignable, DocumentAssignable,
      *      boolean, boolean, Durability)
      */
     @Override
     public ListenableFuture<Long> updateAsync(final DocumentAssignable query,
             final DocumentAssignable update) throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         updateAsync(future, query, update, UPDATE_MULTIUPDATE_DEFAULT,
                 UPDATE_UPSERT_DEFAULT, getDurability());
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * using the {@link #getDurability() default durability}.
      * </p>
      * 
      * @see #updateAsync(Callback, DocumentAssignable, DocumentAssignable,
      *      boolean, boolean, Durability)
      */
     @Override
     public ListenableFuture<Long> updateAsync(final DocumentAssignable query,
             final DocumentAssignable update, final boolean multiUpdate,
             final boolean upsert) throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         updateAsync(future, query, update, multiUpdate, upsert, getDurability());
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * method.
      * </p>
      * 
      * @see #updateAsync(Callback, DocumentAssignable, DocumentAssignable,
      *      boolean, boolean, Durability)
      */
     @Override
     public ListenableFuture<Long> updateAsync(final DocumentAssignable query,
             final DocumentAssignable update, final boolean multiUpdate,
             final boolean upsert, final Durability durability)
             throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         updateAsync(future, query, update, multiUpdate, upsert, durability);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * with multiUpdate set to true, and upsert set to false.
      * </p>
      * 
      * @see #updateAsync(Callback, DocumentAssignable, DocumentAssignable,
      *      boolean, boolean, Durability)
      */
     @Override
     public ListenableFuture<Long> updateAsync(final DocumentAssignable query,
             final DocumentAssignable update, final Durability durability)
             throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         updateAsync(future, query, update, UPDATE_MULTIUPDATE_DEFAULT,
                 UPDATE_UPSERT_DEFAULT, durability);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void updateAsync(final LambdaCallback<Long> results,
             final DocumentAssignable query, final DocumentAssignable update)
             throws MongoDbException {
         updateAsync(new LambdaCallbackAdapter<Long>(results), query, update);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable, boolean, boolean)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void updateAsync(final LambdaCallback<Long> results,
             final DocumentAssignable query, final DocumentAssignable update,
             final boolean multiUpdate, final boolean upsert)
             throws MongoDbException {
         updateAsync(new LambdaCallbackAdapter<Long>(results), query, update,
                 multiUpdate, upsert);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void updateAsync(final LambdaCallback<Long> results,
             final DocumentAssignable query, final DocumentAssignable update,
             final boolean multiUpdate, final boolean upsert,
             final Durability durability) throws MongoDbException {
         updateAsync(new LambdaCallbackAdapter<Long>(results), query, update,
                 multiUpdate, upsert, durability);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(Callback, DocumentAssignable, DocumentAssignable, Durability)}
      * method with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void updateAsync(final LambdaCallback<Long> results,
             final DocumentAssignable query, final DocumentAssignable update,
             final Durability durability) throws MongoDbException {
         updateAsync(new LambdaCallbackAdapter<Long>(results), query, update,
                 durability);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #writeAsync(Callback, BatchedWrite)}
      * method.
      * </p>
      * 
      * @see #writeAsync(Callback, BatchedWrite)
      */
     @Override
     public ListenableFuture<Long> writeAsync(final BatchedWrite write)
             throws MongoDbException {
         final FutureCallback<Long> future = new FutureCallback<Long>(
                 getLockType());
 
         writeAsync(future, write);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #writeAsync(BatchedWrite)} method.
      * </p>
      * 
      * @see #writeAsync(BatchedWrite)
      */
     @Override
     public ListenableFuture<Long> writeAsync(final BatchedWrite.Builder write)
             throws MongoDbException {
         return writeAsync(write.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #writeAsync(Callback, BatchedWrite)}
      * method.
      * </p>
      * 
      * @see #writeAsync(Callback, BatchedWrite)
      */
     @Override
     public void writeAsync(final Callback<Long> results,
             final BatchedWrite.Builder write) throws MongoDbException {
         writeAsync(results, write.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #writeAsync(Callback, BatchedWrite)}
      * method.
      * </p>
      * 
      * @see #writeAsync(Callback, BatchedWrite)
      */
     @Override
     public void writeAsync(final LambdaCallback<Long> results,
             final BatchedWrite write) throws MongoDbException {
         writeAsync(new LambdaCallbackAdapter<Long>(results), write);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #writeAsync(LambdaCallback, BatchedWrite)}
      * method.
      * </p>
      * 
      * @see #writeAsync(LambdaCallback, BatchedWrite)
      */
     @Override
     public void writeAsync(final LambdaCallback<Long> results,
             final BatchedWrite.Builder write) throws MongoDbException {
         writeAsync(results, write.build());
     }
 
     /**
      * Returns the type of lock to use.
      * 
      * @return The type of lock to use.
      */
     protected LockType getLockType() {
         return myClient.getConfig().getLockType();
     }
 
 }