/*

  * #%L

  * ConditionBuilder.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.builder;

 import java.awt.geom.Point2D;

 import java.util.ArrayList;

 import java.util.Date;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.UUID;

 import java.util.regex.Pattern;

 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.builder.ArrayBuilder;

 import com.allanbank.mongodb.bson.builder.BuilderFactory;

 import com.allanbank.mongodb.bson.builder.DocumentBuilder;

 import com.allanbank.mongodb.bson.element.ArrayElement;

 import com.allanbank.mongodb.bson.element.BinaryElement;

 import com.allanbank.mongodb.bson.element.BooleanElement;

 import com.allanbank.mongodb.bson.element.DocumentElement;

 import com.allanbank.mongodb.bson.element.DoubleElement;

 import com.allanbank.mongodb.bson.element.IntegerElement;

 import com.allanbank.mongodb.bson.element.JavaScriptElement;

 import com.allanbank.mongodb.bson.element.JavaScriptWithScopeElement;

 import com.allanbank.mongodb.bson.element.LongElement;

 import com.allanbank.mongodb.bson.element.MaxKeyElement;

 import com.allanbank.mongodb.bson.element.MinKeyElement;

 import com.allanbank.mongodb.bson.element.MongoTimestampElement;

 import com.allanbank.mongodb.bson.element.NullElement;

 import com.allanbank.mongodb.bson.element.ObjectId;

 import com.allanbank.mongodb.bson.element.ObjectIdElement;

 import com.allanbank.mongodb.bson.element.RegularExpressionElement;

 import com.allanbank.mongodb.bson.element.StringElement;

 import com.allanbank.mongodb.bson.element.SymbolElement;

 import com.allanbank.mongodb.bson.element.TimestampElement;

 import com.allanbank.mongodb.bson.element.UuidElement;

 import com.allanbank.mongodb.builder.expression.Constant;

 import com.allanbank.mongodb.builder.expression.Expressions;

 import com.allanbank.mongodb.error.QueryFailedException;

 /**

  * ConditionBuilder provides tracking for the condition of a single field within

  * a query.

  * <p>

  * Use the {@link QueryBuilder#where(String)} method to create a

  * {@link ConditionBuilder}.

  * </p>

  * 

  * @see QueryBuilder#whereField(String)

  * @api.yes This class is part of the driver's API. Public and protected members

  *          will be deprecated for at least 1 non-bugfix release (version

  *          numbers are <major>.<minor>.<bugfix>) before being

  *          removed or modified.

  * @copyright 2012-2013, Allanbank Consulting, Inc., All Rights Reserved

  */

 public class ConditionBuilder implements DocumentAssignable {

     /** The equals element. */

     private Element myEqualsComparison;

     /** The name of the field to compare. */

     private final String myFieldName;

     /** The non-equal comparisons. */

     private final Map<Operator, Element> myOtherComparisons;

     /** The parent builder for the condition. */

     private final QueryBuilder myParent;

     /**

      * Creates a new ConditionBuilder.

      * <p>

      * This constructor is protected since generally users will use the

      * {@link QueryBuilder} class to create a condition builder.

      * </p>

      * 

      * @param fieldName

      *            The name for the field to compare.

      * @param parent

      *            The parent builder for this condition.

      */

     protected ConditionBuilder(final String fieldName, final QueryBuilder parent) {

         myFieldName = fieldName;

         myParent = parent;

         myOtherComparisons = new LinkedHashMap<Operator, Element>();

     }

     /**

      * Checks if the value is greater than the specified <tt>dateTime</tt>.

      * <p>

      * This is equivalent to {@link #greaterThanTimestamp(long)

      * greaterThanTimestamp(dateTime.getTime())}.

      * </p>

      * <p>

      * Only a single {@link #greaterThan(int) greaterThan(...)} comparison can

      * be used. Calling multiple {@link #greaterThan(byte[]) greaterThan(...)}

      * methods overwrites previous values. In addition any

      * {@link #equals(boolean) equals(...)} condition is removed since no

      * equality operator is supported by MongoDB.

      * </p>

      * 

      * @param dateTime

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      * @see #greaterThanTimestamp(long)

      */

     public ConditionBuilder after(final Date dateTime) {

         return greaterThanTimestamp(dateTime.getTime());

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param elements

      *            A builder for the values for the comparison. Any changes to

      *            the {@link ArrayBuilder} after this method is called are not

      *            reflected in the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final ArrayBuilder elements) {

         return all(elements.build());

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final boolean... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final boolean value : values) {

             arrayBuilder.add(value);

         }

         return all(arrayBuilder);

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final byte[]... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final byte[] value : values) {

             arrayBuilder.add(value);

         }

         return all(arrayBuilder);

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method is designed to be used with the {@link Expressions#constant

      * Expressions.constant(...)} helper methods.<blockquote>

      * 

      * <pre>

      * <code>

      * import static {@link Expressions#constant com.allanbank.mongodb.builder.expression.Expressions.constant};

      * 

      * DocumentAssignable query = QueryBuilder.where("f").all(constant(1), constant(2), constant(3));

      * </code>

      * </pre>

      * 

      * </blockquote>

      * </p>

      * <p>

      * Only a single {@link #all(Element[])} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final Constant... values) {

         myEqualsComparison = null;

         final List<Element> elements = new ArrayList<Element>(values.length);

         for (int i = 0; i < values.length; ++i) {

             elements.add(values[i].toElement(ArrayElement.nameFor(i)));

         }

         myOtherComparisons.put(MiscellaneousOperator.ALL, new ArrayElement(

                 MiscellaneousOperator.ALL.getToken(), elements));

         return this;

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final Date... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final Date value : values) {

             arrayBuilder.add(value);

         }

         return all(arrayBuilder);

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final DocumentAssignable... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final DocumentAssignable value : values) {

             arrayBuilder.add(value);

         }

         return all(arrayBuilder);

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final Double... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final Double value : values) {

             arrayBuilder.add(value.doubleValue());

         }

         return all(arrayBuilder);

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * Only a single {@link #all(Element[])} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param elements

      *            The element values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final Element... elements) {

         myEqualsComparison = null;

         myOtherComparisons.put(MiscellaneousOperator.ALL, new ArrayElement(

                 MiscellaneousOperator.ALL.getToken(), elements));

         return this;

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final Integer... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final Integer value : values) {

             arrayBuilder.add(value.intValue());

         }

         return all(arrayBuilder);

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final Long... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final Long value : values) {

             arrayBuilder.add(value.longValue());

         }

         return all(arrayBuilder);

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final ObjectId... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final ObjectId value : values) {

             arrayBuilder.add(value);

         }

         return all(arrayBuilder);

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final Pattern... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final Pattern value : values) {

             arrayBuilder.add(value);

         }

         return all(arrayBuilder);

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final String... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final String value : values) {

             arrayBuilder.add(value);

         }

         return all(arrayBuilder);

     }

     /**

      * Specify the values that must <em>all</em> be in the fields array.

      * <p>

      * This method can only be used with values of the same BSON type. If mixed

      * types need to be used there are several options:

      * <ul>

      * <li>Use the {@link Expressions#constant Expressions#constant(...)}

      * helpers with the {@link #all(Constant...)} method.</li>

      * <li>Use the {@link ArrayBuilder} with the {@link #all(ArrayBuilder)}

      * method.</li>

      * <li>Manually construct the {@link Element elements} and use the

      * {@link #all(Element...)} method.</li>

      * </ul>

      * </p>

      * <p>

      * Only a single {@link #all(ArrayBuilder)} comparison can be used. Calling

      * multiple <tt>all(...)</tt> methods overwrites previous values. In

      * addition any {@link #equals(boolean) equals(...)} condition is removed

      * since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param values

      *            The values for the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder all(final UUID... values) {

         final ArrayBuilder arrayBuilder = BuilderFactory.startArray();

         for (final UUID value : values) {

             arrayBuilder.add(value);

         }

         return all(arrayBuilder);

     }

     /**

      * Starts a logical conjunction with this condition builder. If the

      * <tt>fieldName</tt> is equal to this builder's {@link #getFieldName()

      * field name} then this builder will be returned. Otherwise a different

      * builder will be returned sharing the same parent {@link QueryBuilder}.

      * 

      * @param fieldName

      *            The name of the field to create a conjunction with.

      * @return The {@link ConditionBuilder} to use to construct the conjunction.

      */

     public ConditionBuilder and(final String fieldName) {

         return myParent.whereField(fieldName);

     }

     /**

      * {@inheritDoc}

      * <p>

      * Returns the result of {@link #build()}.

      * </p>

      * 

      * @see #build()

      */

     @Override

     public Document asDocument() {

         return build();

     }

     /**

      * Checks if the value is less than the specified <tt>dateTime</tt>.

      * <p>

      * This is equivalent to {@link #lessThanTimestamp(long)

      * lessThanTimestamp(dateTime.getTime())}.

      * </p>

      * <p>

      * Only a single {@link #lessThan(int) lessThan(...)} comparison can be

      * used. Calling multiple {@link #lessThan(byte[]) lessThan(...)} methods

      * overwrites previous values. In addition any {@link #equals(boolean)

      * equals(...)} condition is removed since no equality operator is supported

      * by MongoDB.

      * </p>

      * 

      * @param dateTime

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      * @see #lessThanTimestamp(long)

      */

     public ConditionBuilder before(final Date dateTime) {

         return lessThanTimestamp(dateTime.getTime());

     }

     /**

      * Returns the results of building the parent {@link QueryBuilder}.

      * 

      * @return The results of building the parent {@link QueryBuilder}.

      * 

      * @see QueryBuilder#build()

      */

     public Document build() {

         return myParent.build();

     }

     /**

      * Adds a {@link MiscellaneousOperator#COMMENT $comment} to the query.

      * Comments are useful for locating queries in the profiler log within

      * MongoDB.

      * <p>

      * Note that the {@link MiscellaneousOperator#COMMENT $comment} operator

      * does not apply to a specific field but applies to the document as a

      * whole. For this reason only a single {@link #comment} condition can be

      * used. Calling multiple <tt>comment(...)</tt> methods overwrites previous

      * values.

      * </p>

      * 

      * @param comment

      *            The comment to add to the query.

      * @return This builder for call chaining.

      * 

      * @see <a

      *      href="http://docs.mongodb.org/manual/reference/operator/meta/comment/">$comment</a>

      */

     public ConditionBuilder comment(final String comment) {

         myParent.comment(comment);

         return this;

     }

     /**

      * Query to match a single element in the array field.

      * <p>

      * Only a single {@link #elementMatches(DocumentAssignable)} comparison can

      * be used. Calling multiple <tt>elementMatches(...)</tt> methods overwrites

      * previous values. In addition any {@link #equals(boolean) equals(...)}

      * condition is removed since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param arrayElementQuery

      *            A builder for the query to match a sub element. Any changes to

      *            the {@link QueryBuilder} after this method is called are not

      *            reflected in the comparison.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder elementMatches(

             final DocumentAssignable arrayElementQuery) {

         myEqualsComparison = null;

         myOtherComparisons.put(

                 MiscellaneousOperator.ELEMENT_MATCH,

                 new DocumentElement(MiscellaneousOperator.ELEMENT_MATCH

                         .getToken(), arrayElementQuery.asDocument()));

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equals(final boolean value) {

         myOtherComparisons.clear();

         myEqualsComparison = new BooleanElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param subType

      *            The binary values subtype.

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equals(final byte subType, final byte[] value) {

         myOtherComparisons.clear();

         myEqualsComparison = new BinaryElement(getFieldName(), subType, value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equals(final byte[] value) {

         myOtherComparisons.clear();

         myEqualsComparison = new BinaryElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>dateTime</tt>.

      * <p>

      * This is equivalent to {@link #equalsTimestamp(long)

      * equalsTimestamp(dateTime.getTime())}.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param dateTime

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      * @see #equalsTimestamp(long)

      */

     public ConditionBuilder equals(final Date dateTime) {

         return equalsTimestamp(dateTime.getTime());

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equals(final DocumentAssignable value) {

         myOtherComparisons.clear();

         myEqualsComparison = new DocumentElement(getFieldName(),

                 value.asDocument());

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * <b>NOTE:</b> Queries for matching a double value that closely

      * approximates an integer value (e.g., 1.00) will compare equal to a stored

      * integer or long value.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equals(final double value) {

         myOtherComparisons.clear();

         myEqualsComparison = new DoubleElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * <b>NOTE:</b> Queries for matching a integer value will compare equals to

      * an equivalent stored long or closely matching double value.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equals(final int value) {

         myOtherComparisons.clear();

         myEqualsComparison = new IntegerElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * <b>NOTE:</b> Queries for matching a long value will compare equals to an

      * equivalent stored integer or closely matching double value.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equals(final long value) {

         myOtherComparisons.clear();

         myEqualsComparison = new LongElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equals(final ObjectId value) {

         myOtherComparisons.clear();

         myEqualsComparison = new ObjectIdElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * <b>NOTE:</b> This checks if the value <b>is</b> a regular expression

      * <b>or</b> if it is a string or symbol that matches the regular

      * expression. It is functionally equivalent to {@link #matches(Pattern)}.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      * 

      * @see #matches(Pattern)

      */

     public ConditionBuilder equals(final Pattern value) {

         myOtherComparisons.clear();

         myEqualsComparison = new RegularExpressionElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * <b>NOTE:</b> This method will match against a string or a symbol type

      * element.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equals(final String value) {

         myOtherComparisons.clear();

         myEqualsComparison = new StringElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>uuid</tt> using the standard

      * byte ordering.

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param uuid

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equals(final UUID uuid) {

         myOtherComparisons.clear();

         myEqualsComparison = new UuidElement(getFieldName(), uuid);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equalsJavaScript(final String value) {

         myOtherComparisons.clear();

         myEqualsComparison = new JavaScriptElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * <b>NOTE:</b> Testing has shown that the <tt>scope</tt> is ignored when

      * performing the comparison.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @param scope

      *            The stored scope value.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equalsJavaScript(final String value,

             final DocumentAssignable scope) {

         myOtherComparisons.clear();

         myEqualsComparison = new JavaScriptWithScopeElement(getFieldName(),

                 value, scope.asDocument());

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt> using the legacy

      * Java byte ordering.

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param uuid

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equalsLegacy(final UUID uuid) {

         myOtherComparisons.clear();

         myEqualsComparison = new UuidElement(getFieldName(),

                 UuidElement.LEGACY_UUID_SUBTTYPE, uuid);

         return this;

     }

     /**

      * Checks if the value is a max key element.

      * <p>

      * <b>WARNING:</b> Testing has shown that this query matches all documents

      * even if they do not contain any value for the field.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equalsMaxKey() {

         myOtherComparisons.clear();

         myEqualsComparison = new MaxKeyElement(getFieldName());

         return this;

     }

     /**

      * Checks if the value is a min key element.

      * <p>

      * <b>WARNING:</b> Testing has shown that this query matches all documents

      * even if they do not contain any value for the field.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equalsMinKey() {

         myOtherComparisons.clear();

         myEqualsComparison = new MinKeyElement(getFieldName());

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * <b>WARNING:</b> Testing has shown that this query will throw a

      * {@link QueryFailedException} if a document contains a field with the same

      * name but of type {@link ElementType#UTC_TIMESTAMP}.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equalsMongoTimestamp(final long value) {

         myOtherComparisons.clear();

         myEqualsComparison = new MongoTimestampElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value is a null value.

      * <p>

      * <b>Note:</b> A field is considered to be <code>null</code> if it is a

      * literal <code>null</code> value in the document <b>OR</b> it does not

      * contain the field.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equalsNull() {

         myOtherComparisons.clear();

         myEqualsComparison = new NullElement(getFieldName());

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equalsSymbol(final String value) {

         myOtherComparisons.clear();

         myEqualsComparison = new SymbolElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the value equals the specified <tt>value</tt>.

      * <p>

      * <b>NOTE:</b> Queries for matching a timestamp value will compare equals

      * to an equivalent stored MongoTimestamp value.

      * </p>

      * <p>

      * Only a single {@link #equals(boolean) equals(...)} comparison can be

      * used. Calling multiple {@link #equals(byte[]) equals(...)} methods

      * overwrites previous values. In addition <tt>equals(...)</tt> removes all

      * other conditions from the builder since there is no equal operator

      * supported by MongoDB.

      * </p>

      * 

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder equalsTimestamp(final long value) {

         myOtherComparisons.clear();

         myEqualsComparison = new TimestampElement(getFieldName(), value);

         return this;

     }

     /**

      * Checks if the field exists (or not) in the document.

      * <p>

      * Only a single {@link #exists(boolean) exists(...)} comparison can be

      * used. Calling multiple {@link #exists() exists(...)} methods overwrites

      * previous values. In addition any {@link #equals(boolean) equals(...)}

      * condition is removed since no equality operator is supported by MongoDB.

      * </p>

      * <p>

      * This method is equivalent to calling {@link #exists(boolean)

      * exists(true)}.

      * </p>

      * 

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder exists() {

         return exists(true);

     }

     /**

      * Checks if the field exists (or not) in the document.

      * <p>

      * Only a single {@link #exists(boolean) exists(...)} comparison can be

      * used. Calling multiple {@link #exists() exists(...)} methods overwrites

      * previous values. In addition any {@link #equals(boolean) equals(...)}

      * condition is removed since no equality operator is supported by MongoDB.

      * </p>

      * 

      * @param value

      *            If true the field must exist. If false the field must not

      *            exist.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder exists(final boolean value) {

         myEqualsComparison = null;

         myOtherComparisons.put(MiscellaneousOperator.EXISTS,

                 new BooleanElement(MiscellaneousOperator.EXISTS.getToken(),

                         value));

         return this;

     }

     /**

      * Geospatial query for documents whose field intersects the specified

      * {@link GeoJson GeoJSON} specified geometry.

      * <p>

      * This method is designed to be use with a GeoJSON document constructed

      * with the {@link GeoJson} class<blockquote>

      * 

      * <pre>

      * <code>

      * {@link QueryBuilder#where where}("geo").intersects({@link GeoJson#lineString GeoJson.lineString}( {@link GeoJson#p GeoJson.p}(1,2),{@link GeoJson#p GeoJson.p}(10,11) ) );

      * </code>

      * </pre>

      * 

      * </blockquote>

      * </p>

      * <p>

      * <b>NOTE: </b> The {@code $geoIntersects} operator requires a

      * {@link Index#geo2dSphere(String) 2dsphere} index.

      * </p>

      * <p>

      * Only a single {@link #geoWithin} comparison can be used. Calling multiple

      * <tt>geoWithin(...)</tt> methods overwrites previous values. In addition

      * any {@link #equals(boolean) equals(...)} condition is removed since no

      * equality operator is supported by MongoDB.

      * </p>

      * 

      * @param geoJsonDoc

      *            The GeoJSON document describing the geometry.

      * @return The condition builder for chaining method calls.

      * 

      * @since MongoDB 2.4

      */

     public ConditionBuilder geoWithin(final DocumentAssignable geoJsonDoc) {

         myEqualsComparison = null;

         myOtherComparisons.put(GeospatialOperator.GEO_WITHIN,

                 new DocumentElement(GeospatialOperator.GEO_WITHIN.getToken(),

                         new DocumentElement(GeospatialOperator.GEOMETRY,

                                 geoJsonDoc.asDocument())));

         return this;

     }

     /**

      * Geospatial query for documents whose field intersects the specified

      * {@link GeoJson GeoJSON} specified geometry.

      * <p>

      * This method is designed to be use with a GeoJSON document constructed

      * with the {@link GeoJson} class<blockquote>

      * 

      * <pre>

      * <code>

      * {@link QueryBuilder#where where}("geo").intersects({@link GeoJson#lineString GeoJson.lineString}( {@link GeoJson#p GeoJson.p}(1,2),{@link GeoJson#p GeoJson.p}(10,11) ) );

      * </code>

      * </pre>

      * 

      * </blockquote>

      * </p>

      * <p>

      * <b>NOTE: </b> The {@code $geoIntersects} operator requires a

      * {@link Index#geo2dSphere(String) 2dsphere} index.

      * </p>

      * <p>

      * Only a single {@link #geoWithin} comparison can be used. Calling multiple

      * <tt>geoWithin(...)</tt> methods overwrites previous values. In addition

      * any {@link #equals(boolean) equals(...)} condition is removed since no

      * equality operator is supported by MongoDB.

      * </p>

      * 

      * @param geoJsonDoc

      *            The GeoJSON document describing the geometry.

      * @param unique

      *            If false then the query will return a document with multiple

      *            matching shaped or points multiple times.

      * @return The condition builder for chaining method calls.

      * 

      * @since MongoDB 2.4

      * @deprecated {@code $uniqueDocs} was removed in MongoDB 2.6. 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

     public ConditionBuilder geoWithin(final DocumentAssignable geoJsonDoc,

             final boolean unique) {

         myEqualsComparison = null;

         myOtherComparisons

                 .put(GeospatialOperator.GEO_WITHIN,

                         new DocumentElement(

                                 GeospatialOperator.GEO_WITHIN.getToken(),

                                 new DocumentElement(

                                         GeospatialOperator.GEOMETRY, geoJsonDoc

                                                 .asDocument()),

                                 new BooleanElement(

                                         GeospatialOperator.UNIQUE_DOCS_MODIFIER,

                                         unique)));

         return this;

     }

     /**

      * Returns the fieldName value.

      * 

      * @return The fieldName value.

      */

     public String getFieldName() {

         return myFieldName;

     }

     /**

      * Checks if the value is greater than the specified <tt>value</tt>.

      * <p>

      * Only a single {@link #greaterThan(int) greaterThan(...)} comparison can

      * be used. Calling multiple {@link #greaterThan(byte[]) greaterThan(...)}

      * methods overwrites previous values. In addition any

      * {@link #equals(boolean) equals(...)} condition is removed since no

      * equality operator is supported by MongoDB.

      * </p>

      * 

      * @param subType

      *            The binary values subtype.

      * @param value

      *            The value to compare the field against.

      * @return The condition builder for chaining method calls.

      */

     public ConditionBuilder greaterThan(final byte subType, final byte[] value) {

         myEqualsComparison = null;

         myOtherComparisons.put(ComparisonOperator.GT, new BinaryElement(

                 ComparisonOperator.GT.getToken(), subType, value));

         return this;

     }