com.impetus.kundera.utils

Class DeepEquals

java.lang.Object

com.impetus.kundera.utils.DeepEquals

public class DeepEquals
extends Object

Deeply compare two (2) objects. This method will call any overridden equals() methods if they exist. If not, it will then proceed to do a field-by-field comparison, and when a non-primitive field is encountered, recursively continue the deep comparison. When an array is found, it will also ensure that the array contents are deeply equal, not requiring the array instance (container) to be identical. This method will successfully compare object graphs that have cycles (A->B->C->A). There is no need to ever use the Arrays.deepEquals() method as this is a true and more effective super set. *

Author:

John DeRegnaucourt

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	DeepEquals.DualKey

Field Summary

Fields

Modifier and Type	Field and Description
private static Map<Class,Boolean>	_customEquals
private static Map<Class,Boolean>	_customHash
private static Map<Class,Collection<Field>>	_reflectedFields

Constructor Summary

Constructors

Constructor and Description
DeepEquals()

Method Summary

Methods

Modifier and Type	Method and Description
private static boolean	compareOrdered(DeepEquals.DualKey dualKey, LinkedList<DeepEquals.DualKey> stack, Collection visited) Compare two Collections that must be same length and in same order.
private static boolean	compareUnordered(Collection col1, Collection col2, Set visited) Deeply compare the two sets referenced by dualKey.
static boolean	deepEquals(Object a, Object b)
private static boolean	deepEquals(Object a, Object b, Set<DeepEquals.DualKey> visited)
static int	deepHashCode(Object obj)
static Collection<Field>	getDeepDeclaredFields(Class c)
static boolean	hasCustomEquals(Class c)
static boolean	hasCustomHashCode(Class c)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

_customEquals

private static final Map<Class,Boolean> _customEquals

_customHash

private static final Map<Class,Boolean> _customHash

_reflectedFields

private static final Map<Class,Collection<Field>> _reflectedFields

Constructor Detail

DeepEquals

public DeepEquals()

Method Detail

deepEquals

public static boolean deepEquals(Object a,
                 Object b)

deepEquals

private static boolean deepEquals(Object a,
                 Object b,
                 Set<DeepEquals.DualKey> visited)

compareOrdered

private static boolean compareOrdered(DeepEquals.DualKey dualKey,
                     LinkedList<DeepEquals.DualKey> stack,
                     Collection visited)

Compare two Collections that must be same length and in same order.

Parameters:

dualKey - DualKey represents the two Collections to compare

visited - Collection of objects already compared (prevents cycles)

stack - add items to compare to the Stack (Stack versus recursion)

Returns:

boolean false if the Collections are not the same length, otherwise place collection items on Stack to be further compared.

compareUnordered

private static boolean compareUnordered(Collection col1,
                       Collection col2,
                       Set visited)

Deeply compare the two sets referenced by dualKey. This method attempts to quickly determine inequality by length, then hash, and finally does a deepEquals on each element if the two Sets passed by the prior tests.

Parameters:

col1 - Collection one

col2 - Collection two

visited - Set containing items that have already been compared, so as to prevent cycles.

Returns:

boolean true if the Sets are deeply equals, false otherwise.

hasCustomEquals

public static boolean hasCustomEquals(Class c)

deepHashCode

public static int deepHashCode(Object obj)

hasCustomHashCode

public static boolean hasCustomHashCode(Class c)

getDeepDeclaredFields

public static Collection<Field> getDeepDeclaredFields(Class c)

Parameters:

c - Class instance

Returns:

Collection of only the fields in the passed in class that would need further processing (reference fields). This makes field traversal on a class faster as it does not need to continually process known fields like primitives.