All Downloads are FREE. Search and download functionalities are using the official Maven repository.

panda.lang.builder.CompareToBuilder Maven / Gradle / Ivy

Go to download 

package panda.lang.builder;

import java.util.Comparator;

import panda.lang.Objects;


/** 
 * Assists in implementing {@link java.lang.Comparable#compareTo(Object)} methods.
 *
 * It is consistent with equals(Object) and
 * hashcode() built with {@link EqualsBuilder} and
 * {@link Objects#hashCode}.

 *
 * 
Two Objects that compare equal using equals(Object) should normally
 * also compare equal using compareTo(Object).

 *
 * 
All relevant fields should be included in the calculation of the
 * comparison. Derived fields may be ignored. The same fields, in the same
 * order, should be used in both compareTo(Object) and
 * equals(Object).

 *
 * 
To use this class write code as follows:

 *
 * 
 * public class MyClass {
 *   String field1;
 *   int field2;
 *   boolean field3;
 *
 *   ...
 *
 *   public int compareTo(Object o) {
 *     MyClass myClass = (MyClass) o;
 *     return new CompareToBuilder()
 *       .appendSuper(super.compareTo(o)
 *       .append(this.field1, myClass.field1)
 *       .append(this.field2, myClass.field2)
 *       .append(this.field3, myClass.field3)
 *       .toComparison();
 *   }
 * }
 * 

 *
 *
 * @see java.lang.Comparable
 * @see java.lang.Object#equals(Object)
 * @see java.lang.Object#hashCode()
 * @see EqualsBuilder
 * 
 */
public class CompareToBuilder implements Builder {

	/**
	 * Current state of the comparison as appended fields are checked.
	 */
	private int comparison;

	/**
	 * 

	 * Constructor for CompareToBuilder.
	 * 

	 * 

	 * Starts off assuming that the objects are equal. Multiple calls are then made to the various
	 * append methods, followed by a call to {@link #toComparison} to get the result.
	 * 

	 */
	public CompareToBuilder() {
		super();
		comparison = 0;
	}

	// -----------------------------------------------------------------------
	/**
	 * 

	 * Appends to the builder the compareTo(Object) result of the
	 * superclass.
	 * 

	 * 
	 * @param superCompareTo result of calling super.compareTo(Object)
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder appendSuper(final int superCompareTo) {
		if (comparison != 0) {
			return this;
		}
		comparison = superCompareTo;
		return this;
	}

	// -----------------------------------------------------------------------
	/**
	 * 

	 * Appends to the builder the comparison of two Objects.
	 * 

	 * 
    
	 * 
  1. Check if lhs == rhs
    2. 
	 * 
  2. Check if either lhs or rhs is null, a
	 * null object is less than a non-null object
    3. 
	 * 
  3. Check the object contents
    4. 
	 * 

	 * 

	 * lhs must either be an array or implement {@link Comparable}.
	 * 

	 * 
	 * @param lhs left-hand object
	 * @param rhs right-hand object
	 * @return this - used to chain append calls
	 * @throws ClassCastException if rhs is not assignment-compatible with
	 *             lhs
	 */
	public CompareToBuilder append(final Object lhs, final Object rhs) {
		return append(lhs, rhs, null);
	}

	/**
	 * 

	 * Appends to the builder the comparison of two Objects.
	 * 

	 * 
    
	 * 
  1. Check if lhs == rhs
    2. 
	 * 
  2. Check if either lhs or rhs is null, a
	 * null object is less than a non-null object
    3. 
	 * 
  3. Check the object contents
    4. 
	 * 

	 * 

	 * If lhs is an array, array comparison methods will be used. Otherwise
	 * comparator will be used to compare the objects. If comparator is
	 * null, lhs must implement {@link Comparable} instead.
	 * 

	 * 
	 * @param lhs left-hand object
	 * @param rhs right-hand object
	 * @param comparator Comparator used to compare the objects, null
	 *            means treat lhs as Comparable
	 * @return this - used to chain append calls
	 * @throws ClassCastException if rhs is not assignment-compatible with
	 *             lhs
	 */
	public CompareToBuilder append(final Object lhs, final Object rhs,
			final Comparator comparator) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == null) {
			comparison = -1;
			return this;
		}
		if (rhs == null) {
			comparison = +1;
			return this;
		}
		if (lhs.getClass().isArray()) {
			// switch on type of array, to dispatch to the correct handler
			// handles multi dimensional arrays
			// throws a ClassCastException if rhs is not the correct array type
			if (lhs instanceof long[]) {
				append((long[])lhs, (long[])rhs);
			}
			else if (lhs instanceof int[]) {
				append((int[])lhs, (int[])rhs);
			}
			else if (lhs instanceof short[]) {
				append((short[])lhs, (short[])rhs);
			}
			else if (lhs instanceof char[]) {
				append((char[])lhs, (char[])rhs);
			}
			else if (lhs instanceof byte[]) {
				append((byte[])lhs, (byte[])rhs);
			}
			else if (lhs instanceof double[]) {
				append((double[])lhs, (double[])rhs);
			}
			else if (lhs instanceof float[]) {
				append((float[])lhs, (float[])rhs);
			}
			else if (lhs instanceof boolean[]) {
				append((boolean[])lhs, (boolean[])rhs);
			}
			else {
				// not an array of primitives
				// throws a ClassCastException if rhs is not an array
				append((Object[])lhs, (Object[])rhs, comparator);
			}
		}
		else {
			// the simple case, not an array, just test the element
			if (comparator == null) {
				@SuppressWarnings("unchecked")
				// assume this can be done; if not throw CCE as per Javadoc
				final Comparable comparable = (Comparable)lhs;
				comparison = comparable.compareTo(rhs);
			}
			else {
				@SuppressWarnings("unchecked")
				// assume this can be done; if not throw CCE as per Javadoc
				final Comparator comparator2 = (Comparator)comparator;
				comparison = comparator2.compare(lhs, rhs);
			}
		}
		return this;
	}

	// -------------------------------------------------------------------------
	/**
	 * Appends to the builder the comparison of two longs.
	 * 
	 * @param lhs left-hand value
	 * @param rhs right-hand value
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final long lhs, final long rhs) {
		if (comparison != 0) {
			return this;
		}
		comparison = ((lhs < rhs) ? -1 : ((lhs > rhs) ? 1 : 0));
		return this;
	}

	/**
	 * Appends to the builder the comparison of two ints.
	 * 
	 * @param lhs left-hand value
	 * @param rhs right-hand value
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final int lhs, final int rhs) {
		if (comparison != 0) {
			return this;
		}
		comparison = ((lhs < rhs) ? -1 : ((lhs > rhs) ? 1 : 0));
		return this;
	}

	/**
	 * Appends to the builder the comparison of two shorts.
	 * 
	 * @param lhs left-hand value
	 * @param rhs right-hand value
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final short lhs, final short rhs) {
		if (comparison != 0) {
			return this;
		}
		comparison = ((lhs < rhs) ? -1 : ((lhs > rhs) ? 1 : 0));
		return this;
	}

	/**
	 * Appends to the builder the comparison of two chars.
	 * 
	 * @param lhs left-hand value
	 * @param rhs right-hand value
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final char lhs, final char rhs) {
		if (comparison != 0) {
			return this;
		}
		comparison = ((lhs < rhs) ? -1 : ((lhs > rhs) ? 1 : 0));
		return this;
	}

	/**
	 * Appends to the builder the comparison of two bytes.
	 * 
	 * @param lhs left-hand value
	 * @param rhs right-hand value
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final byte lhs, final byte rhs) {
		if (comparison != 0) {
			return this;
		}
		comparison = ((lhs < rhs) ? -1 : ((lhs > rhs) ? 1 : 0));
		return this;
	}

	/**
	 * 

	 * Appends to the builder the comparison of two doubles.
	 * 

	 * 

	 * This handles NaNs, Infinities, and -0.0.
	 * 

	 * 

	 * It is compatible with the hash code generated by HashCodeBuilder.
	 * 

	 * 
	 * @param lhs left-hand value
	 * @param rhs right-hand value
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final double lhs, final double rhs) {
		if (comparison != 0) {
			return this;
		}
		comparison = Double.compare(lhs, rhs);
		return this;
	}

	/**
	 * 

	 * Appends to the builder the comparison of two floats.
	 * 

	 * 

	 * This handles NaNs, Infinities, and -0.0.
	 * 

	 * 

	 * It is compatible with the hash code generated by HashCodeBuilder.
	 * 

	 * 
	 * @param lhs left-hand value
	 * @param rhs right-hand value
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final float lhs, final float rhs) {
		if (comparison != 0) {
			return this;
		}
		comparison = Float.compare(lhs, rhs);
		return this;
	}

	/**
	 * Appends to the builder the comparison of two booleanss.
	 * 
	 * @param lhs left-hand value
	 * @param rhs right-hand value
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final boolean lhs, final boolean rhs) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == false) {
			comparison = -1;
		}
		else {
			comparison = +1;
		}
		return this;
	}

	// -----------------------------------------------------------------------
	/**
	 * 

	 * Appends to the builder the deep comparison of two Object arrays.
	 * 

	 * 
    
	 * 
  1. Check if arrays are the same using ==
    2. 
	 * 
  2. Check if for null, null is less than non-null
    3. 
	 * 
  3. Check array length, a short length array is less than a long length array
    4. 
	 * 
  4. Check array contents element by element using {@link #append(Object, Object, Comparator)}
	 * 
    5. 
	 * 

	 * 

	 * This method will also will be called for the top level of multi-dimensional, ragged, and
	 * multi-typed arrays.
	 * 

	 * 
	 * @param lhs left-hand array
	 * @param rhs right-hand array
	 * @return this - used to chain append calls
	 * @throws ClassCastException if rhs is not assignment-compatible with
	 *             lhs
	 */
	public CompareToBuilder append(final Object[] lhs, final Object[] rhs) {
		return append(lhs, rhs, null);
	}

	/**
	 * 

	 * Appends to the builder the deep comparison of two Object arrays.
	 * 

	 * 
    
	 * 
  1. Check if arrays are the same using ==
    2. 
	 * 
  2. Check if for null, null is less than non-null
    3. 
	 * 
  3. Check array length, a short length array is less than a long length array
    4. 
	 * 
  4. Check array contents element by element using {@link #append(Object, Object, Comparator)}
	 * 
    5. 
	 * 

	 * 

	 * This method will also will be called for the top level of multi-dimensional, ragged, and
	 * multi-typed arrays.
	 * 

	 * 
	 * @param lhs left-hand array
	 * @param rhs right-hand array
	 * @param comparator Comparator to use to compare the array elements,
	 *            null means to treat lhs elements as
	 *            Comparable.
	 * @return this - used to chain append calls
	 * @throws ClassCastException if rhs is not assignment-compatible with
	 *             lhs
	 */
	public CompareToBuilder append(final Object[] lhs, final Object[] rhs,
			final Comparator comparator) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == null) {
			comparison = -1;
			return this;
		}
		if (rhs == null) {
			comparison = +1;
			return this;
		}
		if (lhs.length != rhs.length) {
			comparison = (lhs.length < rhs.length) ? -1 : +1;
			return this;
		}
		for (int i = 0; i < lhs.length && comparison == 0; i++) {
			append(lhs[i], rhs[i], comparator);
		}
		return this;
	}

	/**
	 * 

	 * Appends to the builder the deep comparison of two long arrays.
	 * 

	 * 
    
	 * 
  1. Check if arrays are the same using ==
    2. 
	 * 
  2. Check if for null, null is less than non-null
    3. 
	 * 
  3. Check array length, a shorter length array is less than a longer length array
    4. 
	 * 
  4. Check array contents element by element using {@link #append(long, long)}
    5. 
	 * 

	 * 
	 * @param lhs left-hand array
	 * @param rhs right-hand array
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final long[] lhs, final long[] rhs) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == null) {
			comparison = -1;
			return this;
		}
		if (rhs == null) {
			comparison = +1;
			return this;
		}
		if (lhs.length != rhs.length) {
			comparison = (lhs.length < rhs.length) ? -1 : +1;
			return this;
		}
		for (int i = 0; i < lhs.length && comparison == 0; i++) {
			append(lhs[i], rhs[i]);
		}
		return this;
	}

	/**
	 * 

	 * Appends to the builder the deep comparison of two int arrays.
	 * 

	 * 
    
	 * 
  1. Check if arrays are the same using ==
    2. 
	 * 
  2. Check if for null, null is less than non-null
    3. 
	 * 
  3. Check array length, a shorter length array is less than a longer length array
    4. 
	 * 
  4. Check array contents element by element using {@link #append(int, int)}
    5. 
	 * 

	 * 
	 * @param lhs left-hand array
	 * @param rhs right-hand array
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final int[] lhs, final int[] rhs) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == null) {
			comparison = -1;
			return this;
		}
		if (rhs == null) {
			comparison = +1;
			return this;
		}
		if (lhs.length != rhs.length) {
			comparison = (lhs.length < rhs.length) ? -1 : +1;
			return this;
		}
		for (int i = 0; i < lhs.length && comparison == 0; i++) {
			append(lhs[i], rhs[i]);
		}
		return this;
	}

	/**
	 * 

	 * Appends to the builder the deep comparison of two short arrays.
	 * 

	 * 
    
	 * 
  1. Check if arrays are the same using ==
    2. 
	 * 
  2. Check if for null, null is less than non-null
    3. 
	 * 
  3. Check array length, a shorter length array is less than a longer length array
    4. 
	 * 
  4. Check array contents element by element using {@link #append(short, short)}
    5. 
	 * 

	 * 
	 * @param lhs left-hand array
	 * @param rhs right-hand array
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final short[] lhs, final short[] rhs) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == null) {
			comparison = -1;
			return this;
		}
		if (rhs == null) {
			comparison = +1;
			return this;
		}
		if (lhs.length != rhs.length) {
			comparison = (lhs.length < rhs.length) ? -1 : +1;
			return this;
		}
		for (int i = 0; i < lhs.length && comparison == 0; i++) {
			append(lhs[i], rhs[i]);
		}
		return this;
	}

	/**
	 * 

	 * Appends to the builder the deep comparison of two char arrays.
	 * 

	 * 
    
	 * 
  1. Check if arrays are the same using ==
    2. 
	 * 
  2. Check if for null, null is less than non-null
    3. 
	 * 
  3. Check array length, a shorter length array is less than a longer length array
    4. 
	 * 
  4. Check array contents element by element using {@link #append(char, char)}
    5. 
	 * 

	 * 
	 * @param lhs left-hand array
	 * @param rhs right-hand array
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final char[] lhs, final char[] rhs) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == null) {
			comparison = -1;
			return this;
		}
		if (rhs == null) {
			comparison = +1;
			return this;
		}
		if (lhs.length != rhs.length) {
			comparison = (lhs.length < rhs.length) ? -1 : +1;
			return this;
		}
		for (int i = 0; i < lhs.length && comparison == 0; i++) {
			append(lhs[i], rhs[i]);
		}
		return this;
	}

	/**
	 * 

	 * Appends to the builder the deep comparison of two byte arrays.
	 * 

	 * 
    
	 * 
  1. Check if arrays are the same using ==
    2. 
	 * 
  2. Check if for null, null is less than non-null
    3. 
	 * 
  3. Check array length, a shorter length array is less than a longer length array
    4. 
	 * 
  4. Check array contents element by element using {@link #append(byte, byte)}
    5. 
	 * 

	 * 
	 * @param lhs left-hand array
	 * @param rhs right-hand array
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final byte[] lhs, final byte[] rhs) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == null) {
			comparison = -1;
			return this;
		}
		if (rhs == null) {
			comparison = +1;
			return this;
		}
		if (lhs.length != rhs.length) {
			comparison = (lhs.length < rhs.length) ? -1 : +1;
			return this;
		}
		for (int i = 0; i < lhs.length && comparison == 0; i++) {
			append(lhs[i], rhs[i]);
		}
		return this;
	}

	/**
	 * 

	 * Appends to the builder the deep comparison of two double arrays.
	 * 

	 * 
    
	 * 
  1. Check if arrays are the same using ==
    2. 
	 * 
  2. Check if for null, null is less than non-null
    3. 
	 * 
  3. Check array length, a shorter length array is less than a longer length array
    4. 
	 * 
  4. Check array contents element by element using {@link #append(double, double)}
    5. 
	 * 

	 * 
	 * @param lhs left-hand array
	 * @param rhs right-hand array
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final double[] lhs, final double[] rhs) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == null) {
			comparison = -1;
			return this;
		}
		if (rhs == null) {
			comparison = +1;
			return this;
		}
		if (lhs.length != rhs.length) {
			comparison = (lhs.length < rhs.length) ? -1 : +1;
			return this;
		}
		for (int i = 0; i < lhs.length && comparison == 0; i++) {
			append(lhs[i], rhs[i]);
		}
		return this;
	}

	/**
	 * 

	 * Appends to the builder the deep comparison of two float arrays.
	 * 

	 * 
    
	 * 
  1. Check if arrays are the same using ==
    2. 
	 * 
  2. Check if for null, null is less than non-null
    3. 
	 * 
  3. Check array length, a shorter length array is less than a longer length array
    4. 
	 * 
  4. Check array contents element by element using {@link #append(float, float)}
    5. 
	 * 

	 * 
	 * @param lhs left-hand array
	 * @param rhs right-hand array
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final float[] lhs, final float[] rhs) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == null) {
			comparison = -1;
			return this;
		}
		if (rhs == null) {
			comparison = +1;
			return this;
		}
		if (lhs.length != rhs.length) {
			comparison = (lhs.length < rhs.length) ? -1 : +1;
			return this;
		}
		for (int i = 0; i < lhs.length && comparison == 0; i++) {
			append(lhs[i], rhs[i]);
		}
		return this;
	}

	/**
	 * 

	 * Appends to the builder the deep comparison of two boolean arrays.
	 * 

	 * 
    
	 * 
  1. Check if arrays are the same using ==
    2. 
	 * 
  2. Check if for null, null is less than non-null
    3. 
	 * 
  3. Check array length, a shorter length array is less than a longer length array
    4. 
	 * 
  4. Check array contents element by element using {@link #append(boolean, boolean)}
    5. 
	 * 

	 * 
	 * @param lhs left-hand array
	 * @param rhs right-hand array
	 * @return this - used to chain append calls
	 */
	public CompareToBuilder append(final boolean[] lhs, final boolean[] rhs) {
		if (comparison != 0) {
			return this;
		}
		if (lhs == rhs) {
			return this;
		}
		if (lhs == null) {
			comparison = -1;
			return this;
		}
		if (rhs == null) {
			comparison = +1;
			return this;
		}
		if (lhs.length != rhs.length) {
			comparison = (lhs.length < rhs.length) ? -1 : +1;
			return this;
		}
		for (int i = 0; i < lhs.length && comparison == 0; i++) {
			append(lhs[i], rhs[i]);
		}
		return this;
	}

	// -----------------------------------------------------------------------
	/**
	 * Returns a negative integer, a positive integer, or zero as the builder has
	 * judged the "left-hand" side as less than, greater than, or equal to the "right-hand" side.
	 * 
	 * @return final comparison result
	 */
	public int toComparison() {
		return comparison;
	}

	/**
	 * Returns a negative Integer, a positive Integer, or zero as the builder has
	 * judged the "left-hand" side as less than, greater than, or equal to the "right-hand" side.
	 * 
	 * @return final comparison result as an Integer
	 * @see #toComparison()
	 */
	public Integer build() {
		return Integer.valueOf(toComparison());
	}
}
    

    

    

            

    

            



    
    






    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy