Exception handler support added.

Author: Maros-1984

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

@@ -16,6 +16,8 @@
 
 package de.danielbechler.diff;
 
+import de.danielbechler.diff.accessor.exception.DefaultExceptionListener;
+import de.danielbechler.diff.accessor.exception.ExceptionListener;
 import de.danielbechler.diff.annotation.*;
 import de.danielbechler.diff.node.*;
 import de.danielbechler.diff.path.*;
@@ -88,6 +90,21 @@ public enum PrimitiveDefaultValueMode
 	private boolean returnChildrenOfRemovedNodes = false;
 	private CircularReferenceMatchingMode circularReferenceMatchingMode = CircularReferenceMatchingMode.EQUALITY_OPERATOR;
 	private PrimitiveDefaultValueMode treatPrimitivesAs = PrimitiveDefaultValueMode.UNASSIGNED;
+	/** Handler for recoverable exceptional states. */
+	private ExceptionListener exceptionListener = new DefaultExceptionListener(); 
+
+	/**
+	 * Sets handler for recoverable exceptional states.
+	 * 
+	 * @param exceptionListener
+	 *            Handler for recoverable exceptional states.
+	 * @return Modified configuration object.
+	 */
+	public Configuration withExceptionListener(
+			final ExceptionListener exceptionListener) {
+		this.exceptionListener = exceptionListener;
+		return this;
+	}
 
 	public Configuration withCategory(final String category)
 	{
@@ -444,4 +461,10 @@ else if (node.isRemoved())
 		return true;
 	}
 
+	/**
+	 * @return Handler for recoverable exceptional states.
+	 */
+	public ExceptionListener getExceptionListener() {
+		return exceptionListener;
+	}
 }

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

@@ -19,16 +19,13 @@
 import de.danielbechler.diff.node.*;
 import de.danielbechler.diff.path.*;
 import de.danielbechler.util.*;
-import org.slf4j.*;
 
 import static de.danielbechler.diff.CircularReferenceDetector.*;
 
 /** @author Daniel Bechler */
 @SuppressWarnings("MethodMayBeStatic")
 class DifferDelegator
 {
-	private static final Logger logger = LoggerFactory.getLogger(DifferDelegator.class);
-
 	private final DifferFactory differFactory;
 	private final CircularReferenceDetectorFactory circularReferenceDetectorFactory;
 	private CircularReferenceDetector workingCircularReferenceDetector;
@@ -78,7 +75,7 @@ private Node delegateWithCircularReferenceTracking(final Node parentNode, final
 		catch (CircularReferenceException e)
 		{
 			node = newCircularNode(parentNode, instances, e.getPropertyPath());
-			logCircularReference(node.getPropertyPath());
+			differFactory.getConfiguration().getExceptionListener().onCircularReferenceException(node);
 		}
 		if (parentNode == null)
 		{
@@ -116,13 +113,6 @@ private Node newCircularNode(final Node parentNode,
 		return node;
 	}
 
-	private static void logCircularReference(final PropertyPath propertyPath)
-	{
-		logger.warn("Detected circular reference in node at path {}. " +
-				"Going deeper would cause an infinite loop, so I'll stop looking at " +
-				"this instance along the current path.", propertyPath);
-	}
-
 	private Node compare(final Node parentNode, final Instances instances)
 	{
 		final Differ<?> differ = differFactory.createDiffer(instances.getType(), this);

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

@@ -53,4 +53,8 @@ else if (Map.class.isAssignableFrom(type))
 			return new BeanDiffer(delegator, configuration);
 		}
 	}
+
+	public Configuration getConfiguration() {
+		return configuration;
+	}
 }

src/main/java/de/danielbechler/diff/accessor/exception/DefaultExceptionListener.java

@@ -0,0 +1,28 @@
+package de.danielbechler.diff.accessor.exception;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import de.danielbechler.diff.node.Node;
+
+/**
+ * Handler for recoverable exceptional states which logs the warning or info
+ * messages into log. The exception handler is notified when the library catches
+ * recoverable exceptions or is in a recoverable but exceptional state.
+ */
+public class DefaultExceptionListener implements ExceptionListener {
+	/** Logger instance. */
+	private static final Logger logger = LoggerFactory
+			.getLogger(DefaultExceptionListener.class);
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public void onCircularReferenceException(Node node) {
+		logger.warn(
+				"Detected circular reference in node at path {}. "
+						+ "Going deeper would cause an infinite loop, so I'll stop looking at "
+						+ "this instance along the current path.",
+				node.getPropertyPath());
+	}
+}

src/main/java/de/danielbechler/diff/accessor/exception/ExceptionListener.java

@@ -0,0 +1,18 @@
+package de.danielbechler.diff.accessor.exception;
+
+import de.danielbechler.diff.node.Node;
+
+/**
+ * Handler for recoverable exceptional states. The exception handler is notified
+ * when the library catches recoverable exceptions or is in a recoverable but
+ * exceptional state.
+ */
+public interface ExceptionListener {
+	/**
+	 * Called when CircularReferenceException is caught.
+	 * 
+	 * @param node
+	 *            Current node.
+	 */
+	void onCircularReferenceException(Node node);
+}

src/test/java/de/danielbechler/diff/DifferDelegatorShould.java

@@ -49,6 +49,7 @@ public void setUp() throws Exception
 		initMocks(this);
 
 		when(circularReferenceDetectorFactory.create()).thenReturn(circularReferenceDetector);
+		when(differFactory.getConfiguration()).thenReturn(new Configuration());
 
 		differDelegator = new DifferDelegator(differFactory, circularReferenceDetectorFactory);
 	}