ability to compare a bean or map or collection by the result of a method call

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

@@ -49,6 +49,17 @@ public final Node compare(final Node parentNode, final Instances instances)
 		{
 			beanNode.setState(Node.State.IGNORED);
 		}
+		else if (nodeInspector.isWithMethodEquals(beanNode)){
+			String method = nodeInspector.getWithMethodEqualsMethod(beanNode);
+			if (instances.areMethodResultEqual(method))
+			{
+				beanNode.setState(Node.State.UNTOUCHED);
+			}
+			else
+			{
+				beanNode.setState(Node.State.CHANGED);
+			}
+		}
 		else if (instances.areNull() || instances.areSame())
 		{
 			beanNode.setState(Node.State.UNTOUCHED);

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

@@ -61,6 +61,17 @@ else if (nodeInspector.isEqualsOnly(collectionNode))
 				collectionNode.setState(Node.State.CHANGED);
 			}
 		}
+		else if (nodeInspector.isWithMethodEquals(collectionNode)){
+			String method = nodeInspector.getWithMethodEqualsMethod(collectionNode);
+			if (collectionInstances.areMethodResultEqual(method))
+			{
+				collectionNode.setState(Node.State.UNTOUCHED);
+			}
+			else
+			{
+				collectionNode.setState(Node.State.CHANGED);
+			}
+		}
 		else if (collectionInstances.hasBeenAdded())
 		{
 			compareItems(collectionNode, collectionInstances, collectionInstances.getWorking(Collection.class));

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

@@ -77,8 +77,10 @@ public enum PrimitiveDefaultValueMode
 	private final Collection<PropertyPath> includedProperties = new HashSet<PropertyPath>(10);
 	private final Collection<PropertyPath> excludedProperties = new HashSet<PropertyPath>(10);
 	private final Collection<PropertyPath> equalsOnlyProperties = new LinkedHashSet<PropertyPath>(10);
+	private final Collection<PropertyPathAndMethod> methodEqualProperties = new LinkedHashSet<PropertyPathAndMethod>(10);
     private final Collection<Class<?>> compareToOnlyTypes = new LinkedHashSet<Class<?>>(10);
 	private final Collection<Class<?>> equalsOnlyTypes = new LinkedHashSet<Class<?>>(10);
+	private final Collection<ClassAndMethod> methodEqualTypes = new LinkedHashSet<ClassAndMethod>(10);
 	private boolean returnUnchangedNodes = false;
 	private boolean returnIgnoredNodes = false;
 	private boolean returnCircularNodes = true;
@@ -124,7 +126,7 @@ public Configuration withoutProperty(final PropertyPath propertyPath)
 		this.excludedProperties.add(propertyPath);
 		return this;
 	}
-
+	
     public Configuration withCompareToOnlyType(final Class<?> type)
     {
         this.compareToOnlyTypes.add(type);
@@ -143,12 +145,22 @@ public Configuration withEqualsOnlyProperty(final PropertyPath propertyPath)
 		return this;
 	}
 
+	public Configuration withMethodEqualsProperty(final PropertyPath propertyPath, final String methodName) {
+		this.methodEqualProperties.add(new PropertyPathAndMethod(propertyPath, methodName));
+		return this;
+	}
+
+	public Configuration withMethodEqualsProperty(PropertyPathAndMethod propertyPathEqualsMethod) {
+		this.methodEqualProperties.add(propertyPathEqualsMethod);
+		return this;
+	}
+
 	public Configuration withIgnoredNodes()
 	{
 		this.returnIgnoredNodes = true;
 		return this;
 	}
-
+	
 	public Configuration withoutIgnoredNodes()
 	{
 		this.returnIgnoredNodes = false;
@@ -309,6 +321,57 @@ public boolean isEqualsOnly(final Node node)
 		}
 		return false;
 	}
+
+	public boolean isWithMethodEquals(Node node){
+		return getWithMethodEqualsMethod(node) != null;
+	}
+
+	public String getWithMethodEqualsMethod(Node node){
+		final Class<?> propertyType = node.getType();
+		if (propertyType != null)
+		{
+			ObjectDiffMethodEqualsType annotation = propertyType.getAnnotation(ObjectDiffMethodEqualsType.class);
+			if (annotation != null)
+			{
+				return annotation.method();
+			}
+
+			ClassAndMethod applicable = findMethodEqualPropertyForClass(propertyType);
+			if (applicable != null)
+			{
+				return applicable.getMethod();
+			}
+		}
+		if (node.isWithMethodEquals())
+		{
+			return node.getWithMethodEqualsMethod();
+		}
+		PropertyPathAndMethod applicable = findMethodEqualPropertyForPath(node.getPropertyPath());
+		if (applicable != null)
+		{
+			return applicable.getMethod();
+		}
+		return null;
+	}
+
+	private ClassAndMethod findMethodEqualPropertyForClass(Class<?> clazz){
+		for(ClassAndMethod propertyPathEqualsMethod: methodEqualTypes){
+			if(clazz.equals(propertyPathEqualsMethod.getClazz())){
+				return propertyPathEqualsMethod;
+			}
+		}
+		return null;
+
+	}
+
+	private PropertyPathAndMethod findMethodEqualPropertyForPath(PropertyPath propertyPath){
+		for(PropertyPathAndMethod propertyPathEqualsMethod: methodEqualProperties){
+			if(propertyPath.equals(propertyPathEqualsMethod.getPropertyPath())){
+				return propertyPathEqualsMethod;
+			}
+		}
+		return null;
+	}
 
 	public boolean isReturnable(final Node node)
 	{
@@ -347,4 +410,5 @@ else if (node.isRemoved())
 		}
 		return true;
 	}
+
 }

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

@@ -172,6 +172,19 @@ public boolean areEqual()
 	{
 		return isEqual(base, working);
 	}
+
+	public boolean areMethodResultEqual(String method) {
+		try {
+			Object baseMethodResult = base.getClass().getMethod(method).invoke(base);
+			Object workingMethodResult = working.getClass().getMethod(method).invoke(working);
+			if(baseMethodResult == null){
+				return workingMethodResult == null;
+			}
+			return baseMethodResult.equals(workingMethodResult);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
 
     public boolean areEqualByComparison()
 	{
@@ -281,4 +294,5 @@ public PropertyPath getPropertyPath(final Node parentNode)
 			return PropertyPath.createBuilder().withRoot().build();
 		}
 	}
+
 }

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

@@ -61,6 +61,17 @@ else if (nodeInspector.isEqualsOnly(mapNode))
 				mapNode.setState(Node.State.CHANGED);
 			}
 		}
+		else if (nodeInspector.isWithMethodEquals(mapNode)){
+			String method = nodeInspector.getWithMethodEqualsMethod(mapNode);
+			if (instances.areMethodResultEqual(method))
+			{
+				mapNode.setState(Node.State.UNTOUCHED);
+			}
+			else
+			{
+				mapNode.setState(Node.State.CHANGED);
+			}
+		}
 		else if (instances.hasBeenAdded())
 		{
 			compareEntries(mapNode, instances, instances.getWorking(Map.class).keySet());

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

@@ -30,6 +30,9 @@ interface NodeInspector
     boolean isCompareToOnly(Node node);
 
 	boolean isEqualsOnly(Node node);
+
+	boolean isWithMethodEquals(Node node);
+	String getWithMethodEqualsMethod(Node node);
 
 	boolean isReturnable(Node node);
 

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

@@ -24,6 +24,7 @@ public abstract class AbstractAccessor implements Accessor
 	private Set<String> categories = new TreeSet<String>();
 	private boolean equalsOnly;
 	private boolean ignored;
+	private String withMethodEqualsMethod;
 
 	public final Set<String> getCategories()
 	{
@@ -54,5 +55,17 @@ public void setIgnored(final boolean ignored)
 	{
 		this.ignored = ignored;
 	}
+
+	public boolean isWithMethodEquals(){
+		return this.withMethodEqualsMethod != null && !this.withMethodEqualsMethod.equals("");
+	}
+
+	public void setWithMethodEqualsMethod(String withMethodEqualsMethod) {
+		this.withMethodEqualsMethod = withMethodEqualsMethod;
+	}
+
+	public String getWithMethodEqualsMethod(){
+		return withMethodEqualsMethod;
+	}
 
 }

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

@@ -24,4 +24,5 @@ public interface Accessor extends PropertyDescriptor
 	void set(Object target, Object value);
 
 	void unset(Object target);
+
 }

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

@@ -30,4 +30,9 @@ public interface PropertyDescriptor
 	boolean isIgnored();
 
 	boolean isEqualsOnly();
+
+
+	boolean isWithMethodEquals();
+
+	String getWithMethodEqualsMethod();
 }

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

@@ -0,0 +1,15 @@
+package de.danielbechler.diff.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Inherited
+@ObjectDiffAnnotation
+public @interface ObjectDiffMethodEqualsType {
+	public String method();
+}

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

@@ -51,4 +51,6 @@
 	 * @return The categories for this property.
 	 */
 	public String[] categories() default {};
+
+	public String methodEqual() default "";
 }

src/main/java/de/danielbechler/diff/example/MethodEqualExample.java

@@ -0,0 +1,77 @@
+package de.danielbechler.diff.example;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.danielbechler.diff.Configuration;
+import de.danielbechler.diff.ObjectDifferFactory;
+import de.danielbechler.diff.annotation.ObjectDiffMethodEqualsType;
+import de.danielbechler.diff.annotation.ObjectDiffProperty;
+import de.danielbechler.diff.node.Node;
+import de.danielbechler.diff.path.PropertyPath;
+import de.danielbechler.diff.visitor.PrintingVisitor;
+
+class MethodEqualExample {
+	private MethodEqualExample()
+	{
+	}
+
+	public static void main(final String[] args)
+	{
+		PropertyClass prop = new PropertyClass("1", "2");
+		final EncompassingClass base = new EncompassingClass(prop);
+		PropertyClass prop2 = new PropertyClass("1", "3");
+		final EncompassingClass working = new EncompassingClass(prop2);
+
+		final Configuration configuration = new Configuration();
+
+		// (Option 1) Causes the ObjectDiffer to compare using the method "getProp1" on the 'prop' property of the root object
+		configuration.withMethodEqualsProperty(PropertyPath.buildWith("prop"), "getProp1");
+
+		final Node node = ObjectDifferFactory.getInstance(configuration).compare(working, base);
+
+		node.visit(new PrintingVisitor(working, base));
+
+		// Output with ignore: 
+		//	Property at path '/' has not changed
+		// Output without ignore: 
+		// Property at path '/prop/prop2' has changed from [ 2 ] to [ 3 ]
+	}
+
+	public static class EncompassingClass
+	{
+		private final PropertyClass prop;
+
+		public EncompassingClass(final PropertyClass prop)
+		{
+			this.prop = prop;
+		}
+
+		/* (Option 2) This annotation causes the ObjectDiffer to use getProp1 method to compare */
+		//@ObjectDiffProperty(methodEqual = "getProp1")
+		public PropertyClass getProp() {
+			return prop;
+		}
+	}
+
+	/* (Option 3) This annotation causes the ObjectDiffer to use getProp1 method to compare */
+	//@ObjectDiffMethodEqualsType(method="getProp1")
+	public static class PropertyClass
+	{
+		private String prop1;
+		private String prop2;
+
+		public PropertyClass(String prop1, String prop2)
+		{
+			this.prop1 = prop1;
+			this.prop2 = prop2;
+		}
+		public String getProp1() {
+			return prop1;
+		}
+		public String getProp2() {
+			return prop2;
+		}
+	}
+
+}

src/main/java/de/danielbechler/diff/introspect/StandardIntrospector.java

@@ -99,6 +99,7 @@ private static void handleObjectDiffPropertyAnnotation(final Method readMethod,
 			propertyAccessor.setEqualsOnly(annotation.equalsOnly());
 			propertyAccessor.setIgnored(annotation.ignore());
 			propertyAccessor.setCategories(Collections.setOf(annotation.categories()));
+			propertyAccessor.setWithMethodEqualsMethod(annotation.methodEqual());
 		}
 	}
 

src/main/java/de/danielbechler/diff/node/DefaultNode.java

@@ -317,6 +317,14 @@ public final boolean isIgnored()
 	{
 		return state == State.IGNORED || accessor.isIgnored();
 	}
+
+	public boolean isWithMethodEquals() {
+		return accessor.isWithMethodEquals();
+	}
+
+	public String getWithMethodEqualsMethod() {
+		return accessor.getWithMethodEqualsMethod();
+	}
 
 	public final Set<String> getCategories()
 	{
@@ -474,4 +482,5 @@ public void setCircleStartNode(final Node circleStartNode)
 	{
 		this.circleStartNode = circleStartNode;
 	}
+
 }

src/main/java/de/danielbechler/diff/node/Node.java

@@ -201,4 +201,8 @@ public enum State
 
 	<T extends Annotation> T getPropertyAnnotation(Class<T> annotationClass);
 
+	boolean isWithMethodEquals();
+
+	String getWithMethodEqualsMethod();
+
 }

src/main/java/de/danielbechler/diff/path/ClassAndMethod.java

@@ -0,0 +1,16 @@
+package de.danielbechler.diff.path;
+
+public class ClassAndMethod {
+	private Class<?> clazz;
+	private String method;
+	public ClassAndMethod(Class<?> clazz, String method){
+		this.clazz = clazz;
+		this.method = method;
+	}
+	public Class<?> getClazz() {
+		return clazz;
+	}
+	public String getMethod() {
+		return method;
+	}
+}