Merged ObjectDiffEqualsOnlyValueProvidedType annotation with ObjectDiffEqualsOnlyType and did some clean-up

Author: SQiShER

src/main/java/de/danielbechler/diff/Configuration.java

@@ -78,7 +78,7 @@ public enum PrimitiveDefaultValueMode
 	private final Collection<PropertyPath> excludedProperties = new HashSet<PropertyPath>(10);
 	private final Collection<PropertyPath> equalsOnlyProperties = new LinkedHashSet<PropertyPath>(10);
 	private final Collection<PropertyPathAndMethod> equalsOnlyValueProviderMethods = new LinkedHashSet<PropertyPathAndMethod>(10);
-    private final Collection<Class<?>> compareToOnlyTypes = new LinkedHashSet<Class<?>>(10);
+	private final Collection<Class<?>> compareToOnlyTypes = new LinkedHashSet<Class<?>>(10);
 	private final Collection<Class<?>> equalsOnlyTypes = new LinkedHashSet<Class<?>>(10);
 	private final Collection<ClassAndMethod> equalsOnlyValueProviderTypes = new LinkedHashSet<ClassAndMethod>(10);
 	private boolean returnUnchangedNodes = false;
@@ -126,12 +126,12 @@ public Configuration withoutProperty(final PropertyPath propertyPath)
 		this.excludedProperties.add(propertyPath);
 		return this;
 	}
-	
-    public Configuration withCompareToOnlyType(final Class<?> type)
-    {
-        this.compareToOnlyTypes.add(type);
-        return this;
-    }
+
+	public Configuration withCompareToOnlyType(final Class<?> type)
+	{
+		this.compareToOnlyTypes.add(type);
+		return this;
+	}
 
 	public Configuration withEqualsOnlyType(final Class<?> type)
 	{
@@ -145,22 +145,25 @@ public Configuration withEqualsOnlyProperty(final PropertyPath propertyPath)
 		return this;
 	}
 
-	public Configuration withEqualsOnlyValueProviderMethod(final PropertyPath propertyPath, final String methodName) {
+	public Configuration withEqualsOnlyValueProviderMethod(final PropertyPath propertyPath,
+														   final String methodName)
+	{
 		this.equalsOnlyValueProviderMethods.add(new PropertyPathAndMethod(propertyPath, methodName));
 		return this;
 	}
-	
-	public Configuration withEqualsOnlyValueProviderMethod(PropertyPathAndMethod propertyPathEqualsMethod) {
+
+	public Configuration withEqualsOnlyValueProviderMethod(final PropertyPathAndMethod propertyPathEqualsMethod)
+	{
 		this.equalsOnlyValueProviderMethods.add(propertyPathEqualsMethod);
 		return this;
 	}
-	
+
 	public Configuration withIgnoredNodes()
 	{
 		this.returnIgnoredNodes = true;
 		return this;
 	}
-	
+
 	public Configuration withoutIgnoredNodes()
 	{
 		this.returnIgnoredNodes = false;
@@ -331,22 +334,24 @@ public boolean isEqualsOnly(final Node node)
 		}
 		return false;
 	}
-	
-	public boolean hasEqualsOnlyValueProviderMethod(Node node){
-		return getEqualsOnlyValueProviderMethod(node) != null;
+
+	public boolean hasEqualsOnlyValueProviderMethod(final Node node)
+	{
+		return Strings.hasText(getEqualsOnlyValueProviderMethod(node));
 	}
-	
-	public String getEqualsOnlyValueProviderMethod(Node node){
+
+	public String getEqualsOnlyValueProviderMethod(final Node node)
+	{
 		final Class<?> propertyType = node.getType();
 		if (propertyType != null)
 		{
-			ObjectDiffEqualsOnlyValueProvidedType annotation = propertyType.getAnnotation(ObjectDiffEqualsOnlyValueProvidedType.class);
+			final ObjectDiffEqualsOnlyType annotation = propertyType.getAnnotation(ObjectDiffEqualsOnlyType.class);
 			if (annotation != null)
 			{
-				return annotation.method();
+				return annotation.valueProviderMethod();
 			}
-			
-			ClassAndMethod applicable = findEqualsOnlyValueProviderMethodForClass(propertyType);
+
+			final ClassAndMethod applicable = findEqualsOnlyValueProviderMethodForClass(propertyType);
 			if (applicable != null)
 			{
 				return applicable.getMethod();
@@ -356,27 +361,33 @@ public String getEqualsOnlyValueProviderMethod(Node node){
 		{
 			return node.getEqualsOnlyValueProviderMethod();
 		}
-		PropertyPathAndMethod applicable = findEqualsOnlyValueProviderMethodForPath(node.getPropertyPath());
+		final PropertyPathAndMethod applicable = findEqualsOnlyValueProviderMethodForPath(node.getPropertyPath());
 		if (applicable != null)
 		{
 			return applicable.getMethod();
 		}
 		return null;
 	}
-	
-	private ClassAndMethod findEqualsOnlyValueProviderMethodForClass(Class<?> clazz){
-		for(ClassAndMethod propertyPathEqualsOnValueProviderType: equalsOnlyValueProviderTypes){
-			if(clazz.equals(propertyPathEqualsOnValueProviderType.getClazz())){
+
+	private ClassAndMethod findEqualsOnlyValueProviderMethodForClass(final Class<?> clazz)
+	{
+		for (final ClassAndMethod propertyPathEqualsOnValueProviderType : equalsOnlyValueProviderTypes)
+		{
+			if (clazz.equals(propertyPathEqualsOnValueProviderType.getClazz()))
+			{
 				return propertyPathEqualsOnValueProviderType;
 			}
 		}
 		return null;
-			
+
 	}
-	
-	private PropertyPathAndMethod findEqualsOnlyValueProviderMethodForPath(PropertyPath propertyPath){
-		for(PropertyPathAndMethod propertyPathEqualsOnValueProviderMethod: equalsOnlyValueProviderMethods){
-			if(propertyPath.equals(propertyPathEqualsOnValueProviderMethod.getPropertyPath())){
+
+	private PropertyPathAndMethod findEqualsOnlyValueProviderMethodForPath(final PropertyPath propertyPath)
+	{
+		for (final PropertyPathAndMethod propertyPathEqualsOnValueProviderMethod : equalsOnlyValueProviderMethods)
+		{
+			if (propertyPath.equals(propertyPathEqualsOnValueProviderMethod.getPropertyPath()))
+			{
 				return propertyPathEqualsOnValueProviderMethod;
 			}
 		}

src/main/java/de/danielbechler/diff/Instances.java

@@ -24,8 +24,8 @@
 
 import java.util.*;
 
-import static de.danielbechler.util.Objects.*;
 import static de.danielbechler.util.Comparables.*;
+import static de.danielbechler.util.Objects.*;
 
 /** @author Daniel Bechler */
 @SuppressWarnings({"UnusedDeclaration"})
@@ -172,32 +172,39 @@ public boolean areEqual()
 	{
 		return isEqual(base, working);
 	}
-	
-	public boolean areMethodResultsEqual(String method) {
-		try {
-			if(base == null && working == null){
+
+	public boolean areMethodResultsEqual(final String method)
+	{
+		try
+		{
+			if (base == null && working == null)
+			{
 				return true;
 			}
-			if(base == null && working != null || base != null && working == null){
+			if (base == null || working == null)
+			{
 				return false;
 			}
-			Object baseMethodResult = base.getClass().getMethod(method).invoke(base);
-			Object workingMethodResult = working.getClass().getMethod(method).invoke(working);
-			if(baseMethodResult == null){
+			final Object baseMethodResult = base.getClass().getMethod(method).invoke(base);
+			final Object workingMethodResult = working.getClass().getMethod(method).invoke(working);
+			if (baseMethodResult == null)
+			{
 				return workingMethodResult == null;
 			}
 			return baseMethodResult.equals(workingMethodResult);
-		} catch (Exception e) {
+		}
+		catch (Exception e)
+		{
 			throw new RuntimeException(e);
 		}
 	}
 
-    public boolean areEqualByComparison()
+	public boolean areEqualByComparison()
 	{
 		return isEqualByComparison((Comparable) base, (Comparable) working);
 	}
 
-    public boolean areSame()
+	public boolean areSame()
 	{
 		return working == base;
 	}

src/main/java/de/danielbechler/diff/NodeInspector.java

@@ -19,6 +19,7 @@
 import de.danielbechler.diff.node.*;
 
 /** @author Daniel Bechler */
+@SuppressWarnings("SpellCheckingInspection")
 interface NodeInspector
 {
 	boolean isIgnored(Node node);
@@ -27,13 +28,9 @@ interface NodeInspector
 
 	boolean isExcluded(Node node);
 
-    boolean isCompareToOnly(Node node);
+	boolean isCompareToOnly(Node node);
 
 	boolean isEqualsOnly(Node node);
-	
-	boolean hasEqualsOnlyValueProviderMethod(Node node);
-	
-	String getEqualsOnlyValueProviderMethod(Node node);
 
 	boolean isReturnable(Node node);
 
@@ -43,4 +40,14 @@ interface NodeInspector
 	 *         #isEqualsOnly(de.danielbechler.diff.node.Node)} returns <code>true</code>.
 	 */
 	boolean isIntrospectible(Node node);
+
+	/*
+	 * TODO
+	 * Find a way to move the folloing methods out of here. I'd prefer if the equalsOnlyProvider would
+	 * be hidden a little bit deeper (e.g. the PropertyAccessor), so Differs don't need to worry about this.
+	 */
+
+	boolean hasEqualsOnlyValueProviderMethod(Node node);
+
+	String getEqualsOnlyValueProviderMethod(Node node);
 }

src/main/java/de/danielbechler/diff/accessor/AbstractAccessor.java

@@ -55,17 +55,19 @@ public void setIgnored(final boolean ignored)
 	{
 		this.ignored = ignored;
 	}
-	
-	public boolean hasEqualsOnlyValueProviderMethod(){
-		return this.equalsOnlyValueProviderMethod != null && !this.equalsOnlyValueProviderMethod.equals("");
+
+	public boolean hasEqualsOnlyValueProviderMethod()
+	{
+		return equalsOnlyValueProviderMethod != null && !equalsOnlyValueProviderMethod.equals("");
 	}
 
-	public void setEqualsOnlyValueProviderMethod(String equalsOnlyValueProviderMethod) {
+	public void setEqualsOnlyValueProviderMethod(final String equalsOnlyValueProviderMethod)
+	{
 		this.equalsOnlyValueProviderMethod = equalsOnlyValueProviderMethod;
 	}
-	
-	public String getEqualsOnlyValueProviderMethod(){
+
+	public String getEqualsOnlyValueProviderMethod()
+	{
 		return equalsOnlyValueProviderMethod;
 	}
-
 }

src/main/java/de/danielbechler/diff/annotation/ObjectDiffEqualsOnlyType.java

@@ -25,4 +25,12 @@
 @ObjectDiffAnnotation
 public @interface ObjectDiffEqualsOnlyType
 {
+	/**
+	 * The name of a method of the annotated type. The value returned by this method will be used for the equals
+	 * check instead of the annotated object itself. This allows to provide alternative equality checks (e.g.
+	 * comparing a List type by size, by calling <code>size()</code>.) The method should have no parameters.
+	 *
+	 * @return The name of a method providing a different object for the equals check.
+	 */
+	String valueProviderMethod() default "";
 }

src/main/java/de/danielbechler/diff/annotation/ObjectDiffEqualsOnlyValueProvidedType.java

@@ -109,6 +109,7 @@ private static void handleEqualsOnlyTypeAnnotation(final Method readMethod, fina
 		if (annotation != null)
 		{
 			propertyAccessor.setEqualsOnly(true);
+			propertyAccessor.setEqualsOnlyValueProviderMethod(annotation.valueProviderMethod());
 		}
 	}
 }