/*
    * #%L
    * SynchronousMongoCollectionImpl.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 java.util.List;
  
  import com.allanbank.mongodb.BatchedAsyncMongoCollection;
  import com.allanbank.mongodb.Durability;
  import com.allanbank.mongodb.ListenableFuture;
  import com.allanbank.mongodb.MongoCollection;
  import com.allanbank.mongodb.MongoDatabase;
  import com.allanbank.mongodb.MongoDbException;
  import com.allanbank.mongodb.MongoIterator;
  import com.allanbank.mongodb.ReadPreference;
  import com.allanbank.mongodb.Version;
  import com.allanbank.mongodb.bson.Document;
  import com.allanbank.mongodb.bson.DocumentAssignable;
  import com.allanbank.mongodb.bson.Element;
  import com.allanbank.mongodb.bson.ElementType;
  import com.allanbank.mongodb.bson.NumericElement;
  import com.allanbank.mongodb.bson.builder.BuilderFactory;
  import com.allanbank.mongodb.bson.builder.DocumentBuilder;
  import com.allanbank.mongodb.bson.element.BooleanElement;
  import com.allanbank.mongodb.bson.element.IntegerElement;
  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.Index;
  import com.allanbank.mongodb.builder.MapReduce;
  import com.allanbank.mongodb.builder.ParallelScan;
  import com.allanbank.mongodb.client.callback.FutureReplyCallback;
  import com.allanbank.mongodb.client.callback.ValidatingReplyCallback;
  import com.allanbank.mongodb.client.message.CreateIndexCommand;
  import com.allanbank.mongodb.util.FutureUtils;
  
  /**
   * Implementation of the {@link MongoCollection} interface including the
   * synchronous methods.
   * 
   * @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 class SynchronousMongoCollectionImpl extends
          AbstractAsyncMongoCollection implements MongoCollection {
  
      /**
       * Create a new MongoDatabaseClient.
       * 
       * @param client
       *            The client for interacting with MongoDB.
       * @param database
       *            The database the collection is a part of.
       * @param name
       *            The name of the collection we interact with.
       */
      public SynchronousMongoCollectionImpl(final Client client,
              final MongoDatabase database, final String name) {
          super(client, database, name);
      }
  
      /**
       * {@inheritDoc}
       * <p>
       * Overridden to call the {@link #aggregateAsync(Aggregate)}.
       * </p>
       * 
       * @see #aggregateAsync(Aggregate)
       */
      @Override
      public MongoIterator<Document> aggregate(final Aggregate command)
              throws MongoDbException {
          return FutureUtils.unwrap(aggregateAsync(command));
      }
  
      /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #aggregate(Aggregate)}.
      * </p>
      */
     @Override
     public MongoIterator<Document> aggregate(final Aggregate.Builder command)
             throws MongoDbException {
         return aggregate(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #count(DocumentAssignable,ReadPreference)}
      * method with {@link #getReadPreference()} as the <tt>readPreference</tt>
      * argument and an empty {@code query} document.
      * </p>
      */
     @Override
     public long count() throws MongoDbException {
         return count(BuilderFactory.start(), getReadPreference());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #countAsync(Count)} and unwrap the result.
      * </p>
      */
     @Override
     public long count(final Count count) throws MongoDbException {
         final ListenableFuture<Long> future = countAsync(count);
 
         return FutureUtils.unwrap(future).longValue();
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #count(Count) count(count.build())}.
      * </p>
      */
     @Override
     public long count(final Count.Builder count) throws MongoDbException {
         return count(count.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #count(DocumentAssignable, ReadPreference)}
      * method with {@link #getReadPreference()} as the <tt>readPreference</tt>
      * argument.
      * </p>
      */
     @Override
     public long count(final DocumentAssignable query) throws MongoDbException {
         return count(query, getReadPreference());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #countAsync(DocumentAssignable, ReadPreference)} method.
      * </p>
      */
     @Override
     public long count(final DocumentAssignable query,
             final ReadPreference readPreference) throws MongoDbException {
 
         final ListenableFuture<Long> future = countAsync(query, readPreference);
 
         return FutureUtils.unwrap(future).longValue();
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #count(DocumentAssignable,ReadPreference)}
      * method with an empty {@code query} document.
      * </p>
      */
     @Override
     public long count(final ReadPreference readPreference)
             throws MongoDbException {
         return count(BuilderFactory.start(), readPreference);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #createIndex(String, boolean, Element...)}
      * method with <code>null</code> for the name.
      * </p>
      * 
      * @see #createIndex(String, boolean, Element...)
      */
     @Override
     public void createIndex(final boolean unique, final Element... keys)
             throws MongoDbException {
         createIndex(null, unique, keys);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #createIndex(String,DocumentAssignable,Element...)} method with
      * <code>null</code> for <tt>name</tt>.
      * </p>
      * 
      * @see #createIndex(String,DocumentAssignable,Element...)
      */
     @Override
     public void createIndex(final DocumentAssignable options,
             final Element... keys) throws MongoDbException {
         createIndex(null, options, keys);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #createIndex(DocumentAssignable, Element...)} method with
      * {@link #EMPTY_INDEX_OPTIONS} for <tt>options</tt>.
      * </p>
      * 
      * @see #createIndex(DocumentAssignable, Element...)
      */
     @Override
     public void createIndex(final Element... keys) throws MongoDbException {
         createIndex(EMPTY_INDEX_OPTIONS, keys);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #createIndex(String,DocumentAssignable,Element...)} method with
      * {@link #UNIQUE_INDEX_OPTIONS} if {@code unique} is <code>true</code> or
      * {@link #EMPTY_INDEX_OPTIONS} id {@code unique} is <code>false</code>.
      * </p>
      * 
      * @see #createIndex(String, DocumentAssignable, Element...)
      */
     @Override
     public void createIndex(final String name, final boolean unique,
             final Element... keys) throws MongoDbException {
         createIndex(name, unique ? UNIQUE_INDEX_OPTIONS : EMPTY_INDEX_OPTIONS,
                 keys);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to insert the index document into the 'system.indexes'
      * collection or use the {@code createIndexes} command as appropriate.
      * </p>
      * 
      * @see MongoCollection#createIndex(String,DocumentAssignable,Element...)
      */
     @Override
     public void createIndex(final String name,
             final DocumentAssignable options, final Element... keys)
             throws MongoDbException {
 
         if (isCreateIndexesSupported()) {
             final CreateIndexCommand command = new CreateIndexCommand(
                     getDatabaseName(), getName(), keys, name, options);
 
             final FutureReplyCallback callback = new FutureReplyCallback();
             myClient.send(command, new ValidatingReplyCallback(callback));
 
             FutureUtils.unwrap(callback);
         }
         else {
 
             String indexName = name;
             if ((name == null) || name.isEmpty()) {
                 indexName = CreateIndexCommand.buildIndexName(keys);
             }
 
             final DocumentBuilder indexEntryBuilder = BuilderFactory.start();
             indexEntryBuilder.addString("name", indexName);
             indexEntryBuilder.addString("ns", getDatabaseName() + "."
                     + getName());
 
             final DocumentBuilder keyBuilder = indexEntryBuilder.push("key");
             for (final Element key : keys) {
                 keyBuilder.add(key);
             }
 
             for (final Element option : options.asDocument()) {
                 indexEntryBuilder.add(option);
             }
 
             final SynchronousMongoCollectionImpl indexCollection = new SynchronousMongoCollectionImpl(
                     myClient, myDatabase, "system.indexes");
             final Document indexDocument = indexEntryBuilder.build();
             if (indexCollection.findOne(indexDocument) == null) {
 
                 final Version requiredServerVersion = determineIndexServerVersion(keys);
 
                 final FutureCallback<Integer> callback = new FutureCallback<Integer>();
                 indexCollection.doInsertAsync(callback, false, Durability.ACK,
                         requiredServerVersion, indexDocument);
 
                 FutureUtils.unwrap(callback);
             }
         }
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #delete(DocumentAssignable, boolean, Durability)} method with
      * false as the <tt>singleDelete</tt> argument and the
      * {@link #getDurability() default durability}.
      * </p>
      * 
      * @see #delete(DocumentAssignable, boolean, Durability)
      */
     @Override
     public long delete(final DocumentAssignable query) throws MongoDbException {
         return delete(query, DELETE_SINGLE_DELETE_DEFAULT, getDurability());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #delete(DocumentAssignable, boolean, Durability)} method with the
      * {@link #getDurability() default durability}.
      * </p>
      * 
      * @see #delete(DocumentAssignable, boolean, Durability)
      */
     @Override
     public long delete(final DocumentAssignable query,
             final boolean singleDelete) throws MongoDbException {
         return delete(query, singleDelete, getDurability());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #deleteAsync(DocumentAssignable, boolean, Durability)} method.
      * </p>
      * 
      * @see #deleteAsync(DocumentAssignable, boolean, Durability)
      */
     @Override
     public long delete(final DocumentAssignable query,
             final boolean singleDelete, final Durability durability)
             throws MongoDbException {
 
         final ListenableFuture<Long> future = deleteAsync(query, singleDelete,
                 durability);
 
         return FutureUtils.unwrap(future).longValue();
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #deleteAsync(DocumentAssignable, boolean, Durability)} method with
      * false as the <tt>singleDelete</tt> argument.
      * </p>
      * 
      * @see #delete(DocumentAssignable, boolean, Durability)
      */
     @Override
     public long delete(final DocumentAssignable query,
             final Durability durability) throws MongoDbException {
         return delete(query, DELETE_SINGLE_DELETE_DEFAULT, durability);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #distinctAsync(Distinct)}.
      * </p>
      */
     @Override
     public MongoIterator<Element> distinct(final Distinct command)
             throws MongoDbException {
         return FutureUtils.unwrap(distinctAsync(command));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #distinct(Distinct)}.
      * </p>
      */
     @Override
     public MongoIterator<Element> distinct(final Distinct.Builder command)
             throws MongoDbException {
         return distinct(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to issue a { "drop" : <collection_name> } command.
      * </p>
      * 
      * @see MongoCollection#drop()
      */
     @Override
     public boolean drop() {
         final Document result = myDatabase.runCommand("drop", myName, null);
         final List<NumericElement> okElem = result.find(NumericElement.class,
                 "ok");
 
         return ((okElem.size() > 0) && (okElem.get(0).getIntValue() > 0));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * To generate the name of the index and then drop it.
      * </p>
      */
     @Override
     public boolean dropIndex(final IntegerElement... keys)
             throws MongoDbException {
         return dropIndex(CreateIndexCommand.buildIndexName(keys));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to issue a { "deleteIndexes" : <collection_name>, index :
      * <name> } command.
      * </p>
      */
     @Override
     public boolean dropIndex(final String name) throws MongoDbException {
 
         final DocumentBuilder options = BuilderFactory.start();
         options.addString("index", name);
 
         final Document result = myDatabase.runCommand("deleteIndexes", myName,
                 options.build());
         final List<NumericElement> okElem = result.find(NumericElement.class,
                 "ok");
 
         return ((okElem.size() > 0) && (okElem.get(0).getIntValue() > 0));
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean exists() throws MongoDbException {
         return myDatabase.listCollectionNames().contains(getName());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Aggregate)} method.
      * </p>
      */
     @Override
     public Document explain(final Aggregate aggregation)
             throws MongoDbException {
         return FutureUtils.unwrap(explainAsync(aggregation));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Aggregate)} method.
      * </p>
      */
     @Override
     public Document explain(final Aggregate.Builder aggregation)
             throws MongoDbException {
         return FutureUtils.unwrap(explainAsync(aggregation.build()));
 
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explain(Find)} method.
      * </p>
      * 
      * @see #explain(Find)
      */
     @Override
     public Document explain(final DocumentAssignable query)
             throws MongoDbException {
         return explain(new Find.Builder(query).build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explainAsync(Find)} method.
      * </p>
      * 
      * @see #explainAsync(Find)
      */
     @Override
     public Document explain(final Find query) throws MongoDbException {
         return FutureUtils.unwrap(explainAsync(query));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #explain(Find)} method.
      * </p>
      */
     @Override
     public Document explain(final Find.Builder query) throws MongoDbException {
         return explain(query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(DocumentAssignable)} method.
      * </p>
      * 
      * @see #findAsync(DocumentAssignable)
      */
     @Override
     public MongoIterator<Document> find(final DocumentAssignable query)
             throws MongoDbException {
         return FutureUtils.unwrap(findAsync(query));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAsync(Find)} method.
      * </p>
      * 
      * @see #findAsync(Find)
      */
     @Override
     public MongoIterator<Document> find(final Find query)
             throws MongoDbException {
         return FutureUtils.unwrap(findAsync(query));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #find(Find)} method.
      * </p>
      */
     @Override
     public MongoIterator<Document> find(final Find.Builder query)
             throws MongoDbException {
         return find(query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAndModifyAsync(FindAndModify)}.
      * </p>
      * 
      * @see #findAndModifyAsync(FindAndModify)
      */
     @Override
     public Document findAndModify(final FindAndModify command)
             throws MongoDbException {
         return FutureUtils.unwrap(findAndModifyAsync(command));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findAndModify(FindAndModify)}.
      * </p>
      */
     @Override
     public Document findAndModify(final FindAndModify.Builder command)
             throws MongoDbException {
         return findAndModify(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findOneAsync(DocumentAssignable)}.
      * </p>
      * 
      * @see #findOneAsync(DocumentAssignable)
      */
     @Override
     public Document findOne(final DocumentAssignable query)
             throws MongoDbException {
         return FutureUtils.unwrap(findOneAsync(query));
     }
 
     /**
      * <p>
      * Overridden to call the
      * {@link #findOneAsync(com.allanbank.mongodb.Callback, Find)}.
      * </p>
      * 
      * @see #findOneAsync(com.allanbank.mongodb.Callback, Find)
      */
     @Override
     public Document findOne(final Find query) throws MongoDbException {
         return FutureUtils.unwrap(findOneAsync(query));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #findOne(Find)} method.
      * </p>
      */
     @Override
     public Document findOne(final Find.Builder query) throws MongoDbException {
         return findOne(query.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #groupByAsync(GroupBy)}.
      * </p>
      */
     @Override
     public MongoIterator<Element> groupBy(final GroupBy command)
             throws MongoDbException {
         return FutureUtils.unwrap(groupByAsync(command));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #groupBy(GroupBy)}.
      * </p>
      */
     @Override
     public MongoIterator<Element> groupBy(final GroupBy.Builder command)
             throws MongoDbException {
         return groupBy(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insert(boolean, Durability, DocumentAssignable...)} method with
      * the {@link #getDurability() default durability}.
      * </p>
      * 
      * @see #insert(boolean, Durability, DocumentAssignable[])
      */
     @Override
     public int insert(final boolean continueOnError,
             final DocumentAssignable... documents) throws MongoDbException {
         return insert(continueOnError, getDurability(), documents);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insertAsync(boolean, Durability, DocumentAssignable...)} method.
      * </p>
      * 
      * @see #insertAsync(boolean, Durability, DocumentAssignable[])
      */
     @Override
     public int insert(final boolean continueOnError,
             final Durability durability, final DocumentAssignable... documents)
             throws MongoDbException {
         final ListenableFuture<Integer> future = insertAsync(continueOnError,
                 durability, documents);
 
         return FutureUtils.unwrap(future).intValue();
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insert(boolean, Durability, DocumentAssignable...)} method with
      * <tt>continueOnError</tt> set to false and the {@link #getDurability()
      * default durability}.
      * </p>
      * 
      * @see MongoCollection#insertAsync(boolean, Durability,
      *      DocumentAssignable[])
      */
     @Override
     public int insert(final DocumentAssignable... documents)
             throws MongoDbException {
         return insert(INSERT_CONTINUE_ON_ERROR_DEFAULT, getDurability(),
                 documents);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #insert(boolean, Durability, DocumentAssignable...)} method with
      * <tt>continueOnError</tt> set to false.
      * </p>
      * 
      * @see #insert(boolean, Durability, DocumentAssignable[])
      */
     @Override
     public int insert(final Durability durability,
             final DocumentAssignable... documents) throws MongoDbException {
         return insert(INSERT_CONTINUE_ON_ERROR_DEFAULT, durability, documents);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to send a {@code collStats} command to the MongoDB server and
      * look for the {@code capped} field to determine if the collection is
      * capped or not.
      * </p>
      * 
      * @see MongoCollection#isCapped
      */
     @Override
     public boolean isCapped() throws MongoDbException {
         final Document statistics = stats();
 
         final NumericElement numeric = statistics.get(NumericElement.class,
                 "capped");
         if (numeric != null) {
             return (numeric.getIntValue() != 0);
         }
 
         final BooleanElement bool = statistics.get(BooleanElement.class,
                 "capped");
         if (bool != null) {
             return bool.getValue();
         }
 
         // Not found implies not capped.
         return false;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #mapReduceAsync(MapReduce)}.
      * </p>
      * 
      * @see #mapReduceAsync(MapReduce)
      */
     @Override
     public MongoIterator<Document> mapReduce(final MapReduce command)
             throws MongoDbException {
         return FutureUtils.unwrap(mapReduceAsync(command));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #mapReduce(MapReduce)}.
      * </p>
      */
     @Override
     public MongoIterator<Document> mapReduce(final MapReduce.Builder command)
             throws MongoDbException {
         return mapReduce(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #parallelScanAsync(ParallelScan)}.
      * </p>
      * 
      * @see #parallelScanAsync(ParallelScan)
      */
     @Override
     public Collection<MongoIterator<Document>> parallelScan(
             final ParallelScan parallelScan) throws MongoDbException {
         return FutureUtils.unwrap(parallelScanAsync(parallelScan));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #parallelScan(ParallelScan)}.
      * </p>
      * 
      * @see #parallelScanAsync(ParallelScan)
      */
     @Override
     public Collection<MongoIterator<Document>> parallelScan(
             final ParallelScan.Builder parallelScan) throws MongoDbException {
         return parallelScan(parallelScan.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #save(DocumentAssignable, Durability)}
      * using the {@link #getDurability() default durability}.
      * </p>
      */
     @Override
     public int save(final DocumentAssignable document) throws MongoDbException {
         return save(document, getDurability());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #saveAsync(DocumentAssignable, Durability)}
      * .
      * </p>
      */
     @Override
     public int save(final DocumentAssignable document,
             final Durability durability) throws MongoDbException {
         return FutureUtils.unwrap(saveAsync(document, durability)).intValue();
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to return a {@link BatchedAsyncMongoCollection}.
      * </p>
      */
     @Override
     public BatchedAsyncMongoCollection startBatch() {
         return new BatchedAsyncMongoCollectionImpl(myClient, myDatabase, myName);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to send a {@code collStats} command to the MongoDB server.
      * </p>
      * 
      * @see MongoCollection#stats
      */
     @Override
     public Document stats() throws MongoDbException {
         return myDatabase.runCommand("collStats", getName(), null);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #textSearchAsync(com.allanbank.mongodb.builder.Text)}.
      * </p>
      * 
      * @see #textSearchAsync(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 MongoIterator<com.allanbank.mongodb.builder.TextResult> textSearch(
             final com.allanbank.mongodb.builder.Text command)
             throws MongoDbException {
         return FutureUtils.unwrap(textSearchAsync(command));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #textSearch(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 MongoIterator<com.allanbank.mongodb.builder.TextResult> textSearch(
             final com.allanbank.mongodb.builder.Text.Builder command)
             throws MongoDbException {
         return textSearch(command.build());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #update(DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * method with multiUpdate set to true, upsert set to false, and using the
      * {@link #getDurability() default durability}.
      * </p>
      * 
      * @see #update(DocumentAssignable, DocumentAssignable, boolean, boolean,
      *      Durability)
      */
     @Override
     public long update(final DocumentAssignable query,
             final DocumentAssignable update) throws MongoDbException {
         return update(query, update, UPDATE_MULTIUPDATE_DEFAULT,
                 UPDATE_UPSERT_DEFAULT, getDurability());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #update(DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * method with the {@link #getDurability() default durability}.
      * </p>
      * 
      * @see #update(DocumentAssignable, DocumentAssignable, boolean, boolean,
      *      Durability)
      */
     @Override
     public long update(final DocumentAssignable query,
             final DocumentAssignable update, final boolean multiUpdate,
             final boolean upsert) throws MongoDbException {
         return update(query, update, multiUpdate, upsert, getDurability());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #updateAsync(DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * method.
      * </p>
      * 
      * @see #updateAsync(DocumentAssignable, DocumentAssignable, boolean,
      *      boolean, Durability)
      */
     @Override
     public long update(final DocumentAssignable query,
             final DocumentAssignable update, final boolean multiUpdate,
             final boolean upsert, final Durability durability)
             throws MongoDbException {
 
         final ListenableFuture<Long> future = updateAsync(query, update,
                 multiUpdate, upsert, durability);
 
         return FutureUtils.unwrap(future).longValue();
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #update(DocumentAssignable, DocumentAssignable, boolean, boolean, Durability)}
      * method with multiUpdate set to true, and upsert set to false.
      * </p>
      * 
      * @see #update(DocumentAssignable, DocumentAssignable, boolean, boolean,
      *      Durability)
      */
     @Override
     public long update(final DocumentAssignable query,
             final DocumentAssignable update, final Durability durability)
             throws MongoDbException {
         return update(query, update, UPDATE_MULTIUPDATE_DEFAULT,
                 UPDATE_UPSERT_DEFAULT, durability);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to send a {@code collMod} command to the server.
      * </p>
      */
     @Override
     public Document updateOptions(final DocumentAssignable options)
             throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         final DocumentBuilder commandDoc = BuilderFactory.start();
         commandDoc.add("collMod", getName());
         addOptions("collMod", options, commandDoc);
 
         myDatabase.runCommandAsync(future, commandDoc.build(),
                 Version.VERSION_2_2);
 
         return FutureUtils.unwrap(future);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to send a {@code validate} command to the server.
      * </p>
      */
     @Override
     public Document validate(final ValidateMode mode) throws MongoDbException {
         Document result = null;
 
         switch (mode) {
         case INDEX_ONLY:
             result = myDatabase.runCommand("validate", getName(),
                     BuilderFactory.start().add("scandata", false).build());
             break;
         case NORMAL:
             result = myDatabase.runCommand("validate", getName(), null);
             break;
         case FULL:
             result = myDatabase.runCommand("validate", getName(),
                     BuilderFactory.start().add("full", true).build());
             break;
         }
 
         return result;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #writeAsync(BatchedWrite)}.
      * </p>
      * 
      * @see #writeAsync(BatchedWrite)
      */
     @Override
     public long write(final BatchedWrite write) throws MongoDbException {
         final ListenableFuture<Long> future = writeAsync(write);
 
         return FutureUtils.unwrap(future).longValue();
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #write(BatchedWrite)}.
      * </p>
      * 
      * @see #write(BatchedWrite)
      */
     @Override
     public long write(final BatchedWrite.Builder write) throws MongoDbException {
         return write(write.build());
     }
 
     /**
      * Adds the options to the document builder.
      * 
      * @param command
      *            The command to make sure is removed from the options.
      * @param options
      *            The options to be added. May be <code>null</code>.
      * @param builder
      *            The builder to add the options to.
      */
     protected void addOptions(final String command,
             final DocumentAssignable options, final DocumentBuilder builder) {
         if (options != null) {
             for (final Element element : options.asDocument()) {
                 if (!command.equals(element.getName())) {
                     builder.add(element);
                 }
             }
         }
     }
 
     /**
      * Determines the minimum server version required to support the provided
      * index keys and options.
      * 
      * @param keys
      *            The index keys.
      * @return The version required for the index. May be null.
      */
     protected Version determineIndexServerVersion(final Element[] keys) {
         Version result = null;
 
         for (final Element key : keys) {
             if (key.getType() == ElementType.STRING) {
                 final String type = key.getValueAsString();
                 if (Index.GEO_2DSPHERE_INDEX_NAME.equals(type)) {
                     result = Version.later(result, Version.VERSION_2_4);
                 }
                 else if (Index.HASHED_INDEX_NAME.equals(type)) {
                     result = Version.later(result, Version.VERSION_2_4);
                 }
                 else if (Index.TEXT_INDEX_NAME.equals(type)) {
                     result = Version.later(result, Version.VERSION_2_4);
                 }
             }
         }
 
         return result;
     }
 
     /**
      * Determines if all of the servers in the cluster support the
      * {@code createIndexes} command.
      * 
      * @return True if all servers in the cluster are at least the
      *         {@link BatchedWrite#REQUIRED_VERSION}.
      */
     protected boolean isCreateIndexesSupported() {
         final ClusterStats clusterStats = myClient.getClusterStats();
         final VersionRange serverVersionRange = clusterStats
                 .getServerVersionRange();
         final Version minServerVersion = serverVersionRange.getLowerBounds();
 
         return (CreateIndexCommand.REQUIRED_VERSION.compareTo(minServerVersion) <= 0);
     }
 }