/*
    * #%L
    * MongoDatabaseImpl.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.lang.ref.Reference;
  import java.lang.ref.ReferenceQueue;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  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.MongoClient;
  import com.allanbank.mongodb.MongoCollection;
  import com.allanbank.mongodb.MongoDatabase;
  import com.allanbank.mongodb.MongoDbException;
  import com.allanbank.mongodb.MongoIterator;
  import com.allanbank.mongodb.ProfilingStatus;
  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.NumericElement;
  import com.allanbank.mongodb.bson.builder.BuilderFactory;
  import com.allanbank.mongodb.bson.builder.DocumentBuilder;
  import com.allanbank.mongodb.bson.element.StringElement;
  import com.allanbank.mongodb.client.callback.CursorCallback;
  import com.allanbank.mongodb.client.callback.ReplyCommandCallback;
  import com.allanbank.mongodb.client.message.Command;
  import com.allanbank.mongodb.client.message.Query;
  import com.allanbank.mongodb.util.FutureUtils;
  
  /**
   * Implementation of the {@link MongoDatabase} interface.
   * 
   * @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-2014, Allanbank Consulting, Inc., All Rights Reserved
   */
  public class MongoDatabaseImpl implements MongoDatabase {
  
      /** An empty query document. */
      public static final Document EMPTY_QUERY = MongoCollection.ALL;
  
      /** The client for interacting with MongoDB. */
      protected final Client myClient;
  
      /** The 'admin' database. */
      private MongoDatabase myAdminDatabase;
  
      /** The set of databases in use. */
      private final ConcurrentMap<String, Reference<MongoCollection>> myCollections;
  
      /** The {@link Durability} for writes from this database instance. */
      private Durability myDurability;
  
      /** The {@link MongoClient}. */
      private final MongoClient myMongoClient;
  
      /** The name of the database we interact with. */
      private final String myName;
  
      /** The {@link ReadPreference} for reads from this database instance. */
      private ReadPreference myReadPreference;
  
      /** The queue of references to the collections that have been reclaimed. */
      private final ReferenceQueue<MongoCollection> myReferenceQueue = new ReferenceQueue<MongoCollection>();
  
      /**
       * Create a new MongoDatabaseClient.
       * 
       * @param mongoClient
       *            The {@link MongoClient}.
       * @param client
       *            The client for interacting with MongoDB.
       * @param name
      *            The name of the database we interact with.
      */
     public MongoDatabaseImpl(final MongoClient mongoClient,
             final Client client, final String name) {
         myMongoClient = mongoClient;
         myClient = client;
         myName = name;
         myDurability = null;
         myReadPreference = null;
         myCollections = new ConcurrentHashMap<String, Reference<MongoCollection>>();
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Issues a command to create the collection with the specified name and
      * options.
      * </p>
      */
     @Override
     public boolean createCappedCollection(final String name, final long size)
             throws MongoDbException {
         return createCollection(name, BuilderFactory.start()
                 .add("capped", true).add("size", size));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Issues a command to create the collection with the specified name and
      * options.
      * </p>
      */
     @Override
     public boolean createCollection(final String name,
             final DocumentAssignable options) throws MongoDbException {
         final Document result = runCommand("create", name, options);
         final NumericElement okElem = result.get(NumericElement.class, "ok");
 
         return ((okElem != null) && (okElem.getIntValue() > 0));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to issue a "dropDatabase" command.
      * </p>
      * 
      * @see MongoDatabase#drop()
      */
     @Override
     public boolean drop() {
         final Document result = runCommand("dropDatabase");
         final NumericElement okElem = result.get(NumericElement.class, "ok");
 
         return ((okElem != null) && (okElem.getIntValue() > 0));
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean exists() {
         return myMongoClient.listDatabaseNames().contains(getName());
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to create a new {@link SynchronousMongoCollectionImpl}.
      * </p>
      * 
      * @see MongoDatabase#getCollection(String)
      */
     @Override
     public MongoCollection getCollection(final String name) {
         MongoCollection collection = null;
         Reference<MongoCollection> ref = myCollections.get(name);
         if (ref != null) {
             collection = ref.get();
             if (collection == null) {
                 // Reference was take n from the map. Remove it from the map.
                 myCollections.remove(name, ref);
             }
         }
 
         // Create a new one.
         if (collection == null) {
             collection = new SynchronousMongoCollectionImpl(myClient, this,
                     name);
             ref = new NamedReference<MongoCollection>(name, collection,
                     myReferenceQueue);
 
             final Reference<MongoCollection> existing = myCollections
                     .putIfAbsent(name, ref);
             if (existing != null) {
                 final MongoCollection existingCollection = existing.get();
                 if (existingCollection != null) {
                     collection = existingCollection;
                 }
                 // Extremely unlikely but if the reference came and went that
                 // quick it is the next guys problem to add one. We will return
                 // the one we created.
             }
         }
 
         // Clean out any garbage collected references.
         Reference<?> polled;
         while ((polled = myReferenceQueue.poll()) != null) {
             if (polled instanceof NamedReference) {
                 myCollections.remove(((NamedReference<?>) polled).getName(),
                         polled);
             }
         }
 
         return collection;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Durability getDurability() {
         Durability result = myDurability;
         if (result == null) {
             result = myClient.getDefaultDurability();
         }
         return result;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String getName() {
         return myName;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to query the system.namespace collection for the names of all
      * of the collections.
      * </p>
      * 
      * @see MongoDatabase#getProfilingStatus()
      */
     @Override
     public ProfilingStatus getProfilingStatus() throws MongoDbException {
         final Document result = runCommand("profile", -1, null);
 
         final NumericElement level = result.get(NumericElement.class, "was");
         final NumericElement millis = result
                 .get(NumericElement.class, "slowms");
 
         if ((level != null) && (millis != null)) {
             final ProfilingStatus.Level l = ProfilingStatus.Level
                     .fromValue(level.getIntValue());
             if (l != null) {
                 switch (l) {
                 case NONE:
                     return ProfilingStatus.OFF;
                 case ALL:
                     return ProfilingStatus.ON;
                 case SLOW_ONLY:
                     return ProfilingStatus.slow(millis.getIntValue());
                 }
             }
         }
 
         // undefined?
         return null;
 
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public ReadPreference getReadPreference() {
         ReadPreference result = myReadPreference;
         if (result == null) {
             result = myClient.getDefaultReadPreference();
         }
         return result;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to query the system.namespace collection for the names of all
      * of the collections.
      * </p>
      * 
      * @see MongoDatabase#listCollectionNames()
      */
     @Override
     public List<String> listCollectionNames() {
         final Query query = new Query(myName, "system.namespaces", EMPTY_QUERY,
         /* fields= */null,
         /* batchSize= */0, /* limit= */0, /* numberToSkip= */0,
         /* tailable= */false, ReadPreference.PRIMARY,
         /* noCursorTimeout= */false, /* awaitData= */false,
         /* exhaust= */false, /* partial= */false);
 
         final FutureCallback<MongoIterator<Document>> iterFuture = new FutureCallback<MongoIterator<Document>>(
                 getLockType());
         final CursorCallback callback = new CursorCallback(myClient, query,
                 false, iterFuture);
 
         myClient.send(query, callback);
 
         final List<String> names = new ArrayList<String>();
         final Iterator<Document> iter = FutureUtils.unwrap(iterFuture);
         while (iter.hasNext()) {
             final Document collection = iter.next();
             for (final StringElement nameElement : collection.find(
                     StringElement.class, "name")) {
                 final String name = nameElement.getValue();
                 if ((name.indexOf('$') >= 0) && (name.indexOf(".oplog.$") < 0)) {
                     continue;
                 }
 
                 names.add(name.substring(myName.length() + 1));
             }
         }
 
         return names;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to query the system.namespace collection for the names of all
      * of the collections.
      * </p>
      * 
      * @see MongoDatabase#listCollectionNames()
      */
     @Override
     @Deprecated
     public List<String> listCollections() {
         return listCollectionNames();
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call {@link #runCommand(String)} on the 'admin' database.
      * </p>
      * 
      * @see #runCommandAsync(String, DocumentAssignable)
      */
     @Override
     public Document runAdminCommand(final String command)
             throws MongoDbException {
         return getAdminDatabase().runCommand(command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(String, DocumentAssignable)} method.
      * </p>
      * 
      * @see #runCommandAsync(String, DocumentAssignable)
      */
     @Override
     public Document runAdminCommand(final String command,
             final DocumentAssignable options) throws MongoDbException {
         return getAdminDatabase().runCommand(command, options);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(String, String, DocumentAssignable)} method.
      * </p>
      * 
      * @see #runCommandAsync(String, String, DocumentAssignable)
      */
     @Override
     public Document runAdminCommand(final String commandName,
             final String commandValue, final DocumentAssignable options)
             throws MongoDbException {
         return getAdminDatabase()
                 .runCommand(commandName, commandValue, options);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the {@link #runCommandAsync(DocumentAssignable)}
      * method.
      * </p>
      * 
      * @see #runCommandAsync(DocumentAssignable)
      */
     @Override
     public Document runCommand(final DocumentAssignable command)
             throws MongoDbException {
         return FutureUtils.unwrap(runCommandAsync(command));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(String, DocumentAssignable)} method with
      * <code>null</code> options.
      * </p>
      * 
      * @see #runCommandAsync(String, DocumentAssignable)
      */
     @Override
     public Document runCommand(final String command) throws MongoDbException {
         return FutureUtils.unwrap(runCommandAsync(command, null));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(String, DocumentAssignable)} method.
      * </p>
      * 
      * @see #runCommandAsync(String, DocumentAssignable)
      */
     @Override
     public Document runCommand(final String command,
             final DocumentAssignable options) throws MongoDbException {
         return FutureUtils.unwrap(runCommandAsync(command, options));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(String, int, DocumentAssignable)} method.
      * </p>
      * 
      * @see #runCommandAsync(String, int, DocumentAssignable)
      */
     @Override
     public Document runCommand(final String commandName,
             final int commandValue, final DocumentAssignable options)
             throws MongoDbException {
         return FutureUtils.unwrap(runCommandAsync(commandName, commandValue,
                 options));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(String, String, DocumentAssignable)} method.
      * </p>
      * 
      * @see #runCommandAsync(String, String, DocumentAssignable)
      */
     @Override
     public Document runCommand(final String commandName,
             final String commandValue, final DocumentAssignable options)
             throws MongoDbException {
         return FutureUtils.unwrap(runCommandAsync(commandName, commandValue,
                 options));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(Callback, DocumentAssignable, Version)} method
      * with {@code null} as the version.
      * </p>
      * 
      * @see #runCommandAsync(Callback, DocumentAssignable, Version)
      */
     @Override
     public void runCommandAsync(final Callback<Document> reply,
             final DocumentAssignable command) throws MongoDbException {
         runCommandAsync(reply, command, null);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to build a {@link Command} message and send it to the server.
      * </p>
      */
     @Override
     public void runCommandAsync(final Callback<Document> reply,
             final DocumentAssignable command, final Version requireServerVersion)
             throws MongoDbException {
         final Command commandMessage = new Command(myName,
                 Command.COMMAND_COLLECTION, command.asDocument(),
                 ReadPreference.PRIMARY,
                 VersionRange.minimum(requireServerVersion));
 
         myClient.send(commandMessage, new ReplyCommandCallback(reply));
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(Callback, String, DocumentAssignable)} method
      * with <code>null</code> for the options.
      * </p>
      * 
      * @see #runCommandAsync(Callback, String, DocumentAssignable)
      */
     @Override
     public void runCommandAsync(final Callback<Document> reply,
             final String command) throws MongoDbException {
         runCommandAsync(reply, command, null);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to build the command document and call
      * {@link #runCommandAsync(Callback, DocumentAssignable)}.
      * </p>
      */
     @Override
     public void runCommandAsync(final Callback<Document> reply,
             final String command, final DocumentAssignable options)
             throws MongoDbException {
         final DocumentBuilder builder = BuilderFactory.start();
         builder.addInteger(command, 1);
         addOptions(command, options, builder);
 
         runCommandAsync(reply, builder);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to build the command document and call
      * {@link #runCommandAsync(Callback, DocumentAssignable)}.
      * </p>
      */
     @Override
     public void runCommandAsync(final Callback<Document> reply,
             final String commandName, final int commandValue,
             final DocumentAssignable options) throws MongoDbException {
         final DocumentBuilder builder = BuilderFactory.start();
         builder.add(commandName, commandValue);
         addOptions(commandName, options, builder);
 
         runCommandAsync(reply, builder);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to build the command document and call
      * {@link #runCommandAsync(Callback, DocumentAssignable)}.
      * </p>
      */
     @Override
     public void runCommandAsync(final Callback<Document> reply,
             final String commandName, final String commandValue,
             final DocumentAssignable options) throws MongoDbException {
         final DocumentBuilder builder = BuilderFactory.start();
         builder.add(commandName, commandValue);
         addOptions(commandName, options, builder);
 
         runCommandAsync(reply, builder);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(Callback, DocumentAssignable)} method.
      * </p>
      * 
      * @see #runCommandAsync(Callback, DocumentAssignable)
      */
     @Override
     public ListenableFuture<Document> runCommandAsync(
             final DocumentAssignable command) throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         runCommandAsync(future, command);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call {@link #runCommandAsync(Callback, DocumentAssignable)}
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void runCommandAsync(final LambdaCallback<Document> reply,
             final DocumentAssignable command) throws MongoDbException {
         runCommandAsync(new LambdaCallbackAdapter<Document>(reply), command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call
      * {@link #runCommandAsync(Callback, DocumentAssignable, Version)} with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void runCommandAsync(final LambdaCallback<Document> reply,
             final DocumentAssignable command,
             final Version requiredServerVersion) throws MongoDbException {
         runCommandAsync(new LambdaCallbackAdapter<Document>(reply), command,
                 requiredServerVersion);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call {@link #runCommandAsync(Callback, String)} with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void runCommandAsync(final LambdaCallback<Document> reply,
             final String command) throws MongoDbException {
         runCommandAsync(new LambdaCallbackAdapter<Document>(reply), command);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call
      * {@link #runCommandAsync(Callback, String, DocumentAssignable)} with an
      * adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void runCommandAsync(final LambdaCallback<Document> reply,
             final String command, final DocumentAssignable options)
             throws MongoDbException {
         runCommandAsync(new LambdaCallbackAdapter<Document>(reply), command,
                 options);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call
      * {@link #runCommandAsync(Callback, String, int, DocumentAssignable)} with
      * an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void runCommandAsync(final LambdaCallback<Document> reply,
             final String commandName, final int commandValue,
             final DocumentAssignable options) throws MongoDbException {
         runCommandAsync(new LambdaCallbackAdapter<Document>(reply),
                 commandName, commandValue, options);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call
      * {@link #runCommandAsync(Callback, String, String, DocumentAssignable)}
      * with an adapter for the {@link LambdaCallback}.
      * </p>
      */
     @Override
     public void runCommandAsync(final LambdaCallback<Document> reply,
             final String commandName, final String commandValue,
             final DocumentAssignable options) throws MongoDbException {
         runCommandAsync(new LambdaCallbackAdapter<Document>(reply),
                 commandName, commandValue, options);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(Callback, String, DocumentAssignable)} method
      * with <code>null</code> options.
      * </p>
      * 
      * @see #runCommandAsync(Callback, String, DocumentAssignable)
      */
     @Override
     public ListenableFuture<Document> runCommandAsync(final String command)
             throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         runCommandAsync(future, command, null);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(Callback, String, DocumentAssignable)} method.
      * </p>
      * 
      * @see #runCommandAsync(Callback, String, DocumentAssignable)
      */
     @Override
     public ListenableFuture<Document> runCommandAsync(final String command,
             final DocumentAssignable options) throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         runCommandAsync(future, command, options);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(Callback, String, int, DocumentAssignable)}
      * method.
      * </p>
      * 
      * @see #runCommandAsync(Callback, String, int, DocumentAssignable)
      */
     @Override
     public ListenableFuture<Document> runCommandAsync(final String commandName,
             final int commandValue, final DocumentAssignable options)
             throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         runCommandAsync(future, commandName, commandValue, options);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to call the
      * {@link #runCommandAsync(Callback, String, String, DocumentAssignable)}
      * method.
      * </p>
      * 
      * @see #runCommandAsync(Callback, String, String, DocumentAssignable)
      */
     @Override
     public ListenableFuture<Document> runCommandAsync(final String commandName,
             final String commandValue, final DocumentAssignable options)
             throws MongoDbException {
         final FutureCallback<Document> future = new FutureCallback<Document>(
                 getLockType());
 
         runCommandAsync(future, commandName, commandValue, options);
 
         return future;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setDurability(final Durability durability) {
         myDurability = durability;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to update the databases profile level.
      * </p>
      * 
      * @see MongoDatabase#setProfilingStatus
      */
     @Override
     public boolean setProfilingStatus(final ProfilingStatus profileLevel)
             throws MongoDbException {
         final Document result = runCommand(
                 "profile",
                 profileLevel.getLevel().getValue(),
                 BuilderFactory.start().add("slowms",
                         profileLevel.getSlowMillisThreshold()));
 
         final NumericElement level = result.get(NumericElement.class, "was");
         final NumericElement millis = result
                 .get(NumericElement.class, "slowms");
 
         if ((level != null) && (millis != null)) {
             final ProfilingStatus.Level l = ProfilingStatus.Level
                     .fromValue(level.getIntValue());
             if (l != null) {
                 switch (l) {
                 case NONE:
                     return !ProfilingStatus.Level.NONE.equals(profileLevel
                             .getLevel());
                 case ALL:
                     return !ProfilingStatus.Level.ALL.equals(profileLevel
                             .getLevel());
                 case SLOW_ONLY:
                     final ProfilingStatus before = ProfilingStatus.slow(millis
                             .getIntValue());
                     return !before.equals(profileLevel);
                 }
             }
         }
 
         // From undefined to defined is a change?
         return true;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setReadPreference(final ReadPreference readPreference) {
         myReadPreference = readPreference;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to send a {@code dbStats} command to the MongoDB server.
      * </p>
      * 
      * @see MongoDatabase#stats
      */
     @Override
     public Document stats() throws MongoDbException {
         return runCommand("dbStats");
     }
 
     /**
      * 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);
                 }
             }
         }
     }
 
     /**
      * Returns the type of lock to use.
      * 
      * @return The type of lock to use.
      */
     protected LockType getLockType() {
         return myClient.getConfig().getLockType();
     }
 
     /**
      * Returns a {@link MongoDatabase} interface to the 'admin' database.
      * 
      * @return A reference to a {@link MongoDatabase} for interacting with the
      *         'admin' database.
      */
     private MongoDatabase getAdminDatabase() {
         if (myAdminDatabase == null) {
             if (myName.equals("admin")) {
                 myAdminDatabase = this;
             }
             else {
                 myAdminDatabase = myMongoClient.getDatabase("admin");
             }
         }
 
         return myAdminDatabase;
     }
 }