/*

  * #%L

  * AbstractElement.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.bson.element;

 import static com.allanbank.mongodb.util.Assertions.assertNotNull;

 import java.io.StringWriter;

 import java.util.Collections;

 import java.util.List;

 import com.allanbank.mongodb.bson.Element;

 /**

  * A base class for the basic BSON types.

  * 

  * @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 2011-2014, Allanbank Consulting, Inc., All Rights Reserved

  */

 public abstract class AbstractElement implements Element {

     /** The base type (interface) for all elements. */

     protected static final Class<Element> ELEMENT_TYPE = Element.class;

     /** Serialization version for the class. */

     private static final long serialVersionUID = 7537761445549731633L;

     /**

      * Compares two {@code int} values numerically. The value returned is

      * identical to what would be returned by:

      * 

      * <pre>

      * Integer.valueOf(x).compareTo(Integer.valueOf(y))

      * </pre>

      * 

      * @param x

      *            the first {@code int} to compare

      * @param y

      *            the second {@code int} to compare

      * @return the value {@code 0} if {@code x == y}; a value less than

      *         {@code 0} if {@code x < y}; and a value greater than {@code 0} if

      *         {@code x > y}

      * @since 1.7

      */

     /* package */static int compare(final int x, final int y) {

         return (x < y) ? -1 : ((x == y) ? 0 : 1);

     }

     /**

      * Compares two {@code long} values numerically. The value returned is

      * identical to what would be returned by:

      * 

      * <pre>

      * Long.valueOf(x).compareTo(Long.valueOf(y))

      * </pre>

      * 

      * @param x

      *            the first {@code long} to compare

      * @param y

      *            the second {@code long} to compare

      * @return the value {@code 0} if {@code x == y}; a value less than

      *         {@code 0} if {@code x < y}; and a value greater than {@code 0} if

      *         {@code x > y}

      * @since 1.7

      */

     /* package */static int compare(final long x, final long y) {

         return (x < y) ? -1 : ((x == y) ? 0 : 1);

     }

     /** The name for the BSON type. */

     private final String myName;

     /** The size of the element when encoded in bytes. */

     private final long mySize;

     /**

      * Constructs a new {@link AbstractElement}.

      * 

      * @param name

      *            The name for the BSON type.

      * @param size

      *            The size of the element when encoded in bytes.

      * @throws IllegalArgumentException

      *             If the {@code name} is <code>null</code>.

      */

     public AbstractElement(final String name, final long size)

             throws IllegalArgumentException {

         assertNotNull(name, "Cannot have an null name on an element.");

         myName = name;

         mySize = size;

     }

     /**

      * {@inheritDoc}

      * <p>

      * Returns this element.

      * </p>

      */

     @Override

     public Element asElement() {

         return this;

     }

     /**

      * {@inheritDoc}

      * <p>

      * Overridden to compare the elements based on the tuple (name, type).

      * Derived classes are responsible for the value portion of the full

      * comparison.

      * </p>

      */

     @Override

     public int compareTo(final Element otherElement) {

         int result = myName.compareTo(otherElement.getName());

         if (result == 0) {

             // Use the specialized comparison to match MongoDB's ordering of

             // types.

             result = getType().compare(otherElement.getType());

         }

         return result;

     }

     /**

      * Determines if the passed object is of this same type as this object and

      * if so that its fields are equal.

      * 

      * @param object

      *            The object to compare to.

      * 

      * @see java.lang.Object#equals(java.lang.Object)

      */

     @Override

     public boolean equals(final Object object) {

         boolean result = false;

         if (this == object) {

             result = true;

         }

         else if ((object != null) && (getClass() == object.getClass())) {

             final AbstractElement other = (AbstractElement) object;

             result = nullSafeEquals(myName, other.myName);

         }

         return result;

     }

     /**

      * {@inheritDoc}

      * <p>

      * Returns a singleton list if the nameRegexs is empty and this element's

      * type is assignable to E. An empty list otherwise.

      * </p>

      * 

      * @see Element#find

      */

     @Override

     public <E extends Element> List<E> find(final Class<E> clazz,

             final String... nameRegexs) {

         if ((nameRegexs.length == 0) && clazz.isAssignableFrom(this.getClass())) {

             // End of the path. Match this element.

             return Collections.singletonList(clazz.cast(this));

         }

         return Collections.emptyList();

     }

     /**

      * {@inheritDoc}

      * <p>

      * Returns a singleton list if the nameRegexs is empty. An empty list

      * otherwise.

      * </p>

      * 

      * @see Element#find

      */

     @Override

     public List<Element> find(final String... nameRegexs) {

         return find(ELEMENT_TYPE, nameRegexs);

     }

     /**

      * {@inheritDoc}

      * <p>

      * Returns a {@code this} if the nameRegexs is empty and this element's type

      * is assignable to E. An empty list otherwise.

      * </p>

      * 

      * @see Element#findFirst

      */

     @Override

     public <E extends Element> E findFirst(final Class<E> clazz,

             final String... nameRegexs) {

         if ((nameRegexs.length == 0) && clazz.isAssignableFrom(this.getClass())) {

             // End of the path. Match this element.

             return clazz.cast(this);

         }

         return null;

     }

     /**

      * {@inheritDoc}

      * <p>

      * Searches this sub-elements for matching elements on the path and are of

      * the right type.

      * </p>

      * 

      * @see Element#findFirst

      */

     @Override

     public Element findFirst(final String... nameRegexs) {

         return findFirst(ELEMENT_TYPE, nameRegexs);

     }

     /**

      * Returns the name for the BSON type.

      * 

      * @return The name for the BSON type.

      */

     @Override

     public String getName() {

         return myName;

     }

     /**

      * {@inheritDoc}

      * <p>

      * Uses the {@link JsonSerializationVisitor} to encode the value. In some

      * cases it will be more efficient to override this method with a more

      * straight forward conversion.

      * </p>

      */

     @Override

     public String getValueAsString() {

         final StringWriter writer = new StringWriter();

         final JsonSerializationVisitor visitor = new JsonSerializationVisitor(

                 writer, false);

         // Just the value.

         visitor.setSuppressNames(true);

         accept(visitor);

         return writer.toString();

     }

     /**

      * Computes a reasonable hash code.

      * 

      * @return The hash code value.

      */

     @Override

     public int hashCode() {

         int result = 1;

         result = (31 * result) + ((myName == null) ? 0 : myName.hashCode());

         return result;

     }

     /**

      * Returns the number of bytes that are used to encode the element.

      * 

      * @return The bytes that are used to encode the element.

      */

     @Override

     public long size() {

         return mySize;

     }

     /**

      * String form of the object.

      * 

      * @return A human readable form of the object.

      * 

      * @see java.lang.Object#toString()

      */

     @Override

     public String toString() {

         final StringWriter writer = new StringWriter();

         final JsonSerializationVisitor visitor = new JsonSerializationVisitor(

                 writer, false);

         accept(visitor);

         return writer.toString();

     }

     /**

      * Does a null safe equals comparison.

      * 

      * @param rhs

      *            The right-hand-side of the comparison.

      * @param lhs

      *            The left-hand-side of the comparison.

      * @return True if the rhs equals the lhs. Note: nullSafeEquals(null, null)

      *         returns true.

      */

     protected boolean nullSafeEquals(final Object rhs, final Object lhs) {

         return (rhs == lhs) || ((rhs != null) && rhs.equals(lhs));

     }

 }