InclusionService: Improved performance

Author: Deipher

src/main/java/de/danielbechler/diff/inclusion/InclusionService.java

@@ -24,6 +24,7 @@
 import de.danielbechler.diff.selector.ElementSelector;
 import de.danielbechler.util.Assert;
 
+import java.util.Collection;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.LinkedList;
@@ -49,6 +50,16 @@ public class InclusionService implements InclusionConfigurer, IsIgnoredResolver
 	private final ToExclude excludeAndReturn = new ToExcludeAndReturnImpl();
 	private final TypePropertyConfigInclusionResolver typePropertyConfigInclusionResolver = new TypePropertyConfigInclusionResolver();
 	private final Collection<InclusionResolver> inclusionResolvers = new LinkedList<InclusionResolver>();
+	// Patched : Inclusion boolean properties
+	private boolean categoryInclusion = false;
+	private boolean propertyNameInclusion = false;
+	private boolean nodePathInclusion = false;
+	private boolean typeInclusion = false;
+	// Patched : Exclusion boolean properties
+	private boolean categoryExclusion = false;
+	private boolean nodePathExclusion = false;
+	private boolean propertyNameExclusion = false;
+	private boolean typeExclusion = false;
 
 	public InclusionService(final CategoryResolver categoryResolver, final ObjectDifferBuilder rootConfiguration)
 	{
@@ -74,23 +85,16 @@ private boolean isExcluded(final DiffNode node)
 				return true;
 			}
 		}
-		if (isExcludedByPath(node))
-		{
-			return true;
-		}
-		else if (isExcludedByCategory(node))
-		{
-			return true;
-		}
-		else if (isExcludedByType(node))
-		{
-			return true;
-		}
-		else if (isExcludedByPropertyName(node))
-		{
-			return true;
+		// Patched : Check if there are exclusions before browsing all excluded elements
+		if (hasExclusions()) {
+			if (isExcludedByPath(node) || isExcludedByCategory(node)) {
+				return true;
+			} else if (isExcludedByType(node) || isExcludedByPropertyName(node)) {
+				return true;
+			}
 		}
 		return false;
+
 	}
 
 	private boolean isIncluded(final DiffNode node)
@@ -105,113 +109,109 @@ private boolean isIncluded(final DiffNode node)
 			{
 				return true;
 			}
-		}
-		if (hasInclusions(INCLUDED, node))
-		{
-			if (isIncludedByPath(node))
-			{
-				return true;
-			}
-			else if (isIncludedByCategory(node))
-			{
+		}		
+		// Patched : Check if there are inclusions before browsing all included elements
+		if (hasInclusions()) {
+			if (node.isRootNode()) {
 				return true;
-			}
-			else if (isIncludedByType(node))
-			{
+			} else if (isIncludedByPath(node) || isIncludedByCategory(node)) {
 				return true;
-			}
-			else if (isIncludedByPropertyName(node))
-			{
+			} else if (isIncludedByType(node) || isIncludedByPropertyName(node)) {
 				return true;
 			}
 			return false;
 		}
 		return true;
 	}
 
-	private boolean isExcludedByPath(final DiffNode node)
-	{
-		final InclusionNode valueNode = nodeInclusions.getNodeForPath(node.getPath());
-		if (valueNode.isExcluded() && !valueNode.containsValue(INCLUDED))
-		{
-			return true;
-		}
-		return false;
+	private boolean hasInclusions() {
+		// Patched : Now return if inclusions have been configured
+		return nodePathInclusion || categoryInclusion || typeInclusion || propertyNameInclusion;
 	}
-
-	private boolean isExcludedByCategory(final DiffNode node)
-	{
-		return hasCategoryWithInclusion(node, EXCLUDED);
+	
+	private boolean hasExclusions() {
+		// Patched (New method) : Now return if exclusions have been configured
+		return nodePathExclusion || categoryExclusion || typeExclusion || propertyNameExclusion;
 	}
 
-	private boolean isExcludedByType(final DiffNode node)
+	private boolean isIncludedByPath(final DiffNode node)
 	{
-		if (node.getValueType() != null)
-		{
-			return typeInclusions.get(node.getValueType()) == EXCLUDED;
+		// Patched : First check if nodePath inclusions have been configured
+		if (nodePathInclusion && nodeInclusions.getNodeForPath(node.getPath()).isIncluded()) {
+			return true;
 		}
 		return false;
 	}
 
-	private boolean isExcludedByPropertyName(final DiffNode node)
+	private boolean isIncludedByCategory(final DiffNode node)
 	{
-		final String propertyName = node.getPropertyName();
-		if (propertyName != null && propertyNameInclusions.get(propertyName) == EXCLUDED)
-		{
+		// Patched : First check if category inclusions have been configured
+		if (categoryInclusion && hasCategoryWithInclusion(node, INCLUDED)) {
 			return true;
 		}
 		return false;
 	}
 
-	private boolean hasInclusions(final Inclusion inclusion, final DiffNode node)
+	private boolean isIncludedByType(final DiffNode node)
 	{
-		if (nodeInclusions.containsValue(inclusion))
-		{
-			return true;
-		}
-		if (typeInclusions.containsValue(inclusion))
-		{
-			return true;
-		}
-		if (categoryInclusions.containsValue(inclusion))
-		{
-			return true;
-		}
-		if (propertyNameInclusions.containsValue(inclusion))
-		{
+		// Patched : First check if type inclusions have been configured
+		if (typeInclusion && typeInclusions.get(node.getValueType()) == INCLUDED) {
 			return true;
 		}
 		return false;
 	}
 
-	private boolean isIncludedByPath(final DiffNode node)
+	private boolean isIncludedByPropertyName(final DiffNode node)
 	{
-		return nodeInclusions.getNodeForPath(node.getPath()).isIncluded();
+		// Patched : First check if property name inclusions have been configured
+		if (propertyNameInclusion) {
+			if (isIncludedByOwnPropertyName(node)) {
+				return true;
+			} else if (isIncludedByParentPropertyName(node)) {
+				return true;
+			}
+		}
+		return false;
 	}
 
-	private boolean isIncludedByCategory(final DiffNode node)
+	private boolean isExcludedByPath(final DiffNode node)
 	{
-		return hasCategoryWithInclusion(node, INCLUDED);
+		// Patched : First check if node path exclusions have been configured
+		if (nodePathExclusion) {
+			final InclusionNode valueNode = nodeInclusions.getNodeForPath(node.getPath());
+			if (valueNode.isExcluded() && !valueNode.containsValue(INCLUDED)) {
+				return true;
+			}
+		}
+		return false;
 	}
 
-	private boolean isIncludedByType(final DiffNode node)
+	private boolean isExcludedByCategory(final DiffNode node)
 	{
-		if (typeInclusions.get(node.getValueType()) == INCLUDED)
-		{
+		// Patched : First check if category exclusions have been configured
+		if (categoryExclusion && hasCategoryWithInclusion(node, EXCLUDED)) {
 			return true;
 		}
 		return false;
 	}
 
-	private boolean isIncludedByPropertyName(final DiffNode node)
+	private boolean isExcludedByType(final DiffNode node)
 	{
-		if (isIncludedByOwnPropertyName(node))
-		{
-			return true;
+		// Patched : First check if type exclusions have been configured
+		if (typeExclusion && node.getValueType() != null) {
+			return typeInclusions.get(node.getValueType()) == EXCLUDED;
 		}
-		else if (isIncludedByParentPropertyName(node))
-		{
-			return true;
+		return false;
+	}
+
+	private boolean isExcludedByPropertyName(final DiffNode node)
+	{
+		// Patched : First check if property name exclusions have been configured
+		if (propertyNameExclusion) {
+			final String propertyName = node.getPropertyName();
+			if (propertyName != null) {
+				return propertyNameInclusions.get(propertyName) == EXCLUDED;
+			}
 		}
 		return false;
 	}
@@ -286,24 +286,32 @@ public ObjectDifferBuilder and()
 
 		public ToExcludeAndReturn category(final String category)
 		{
+			// Patched : Indicates that there are category exclusions
+			categoryExclusion = true;
 			categoryInclusions.put(category, EXCLUDED);
 			return this;
 		}
 
 		public ToExcludeAndReturn type(final Class<?> type)
 		{
+			// Patched : Indicates that there are type exclusions
+			typeExclusion = true;
 			typeInclusions.put(type, EXCLUDED);
 			return this;
 		}
 
 		public ToExcludeAndReturn node(final NodePath nodePath)
 		{
+			// Patched : Indicates that there are nodePath exclusions
+			nodePathExclusion = true;
 			nodeInclusions.getNodeForPath(nodePath).setValue(EXCLUDED);
 			return this;
 		}
 
 		public ToExcludeAndReturn propertyName(final String propertyName)
 		{
+			// Patched : Indicates that there are property name exclusions
+			propertyNameExclusion = true;
 			propertyNameInclusions.put(propertyName, EXCLUDED);
 			return this;
 		}
@@ -335,25 +343,33 @@ public ObjectDifferBuilder and()
 
 		public ToIncludeAndReturn category(final String category)
 		{
+			// Patched : Indicates that there are category inclusions
+			categoryInclusion = true;
 			categoryInclusions.put(category, INCLUDED);
 			return this;
 		}
 
 		public ToIncludeAndReturn type(final Class<?> type)
 		{
+			// Patched : Indicates that there are type inclusions
+			typeInclusion = true;
 			typeInclusions.put(type, INCLUDED);
 			return this;
 		}
 
 		public ToIncludeAndReturn node(final NodePath nodePath)
 		{
+			// Patched : Indicates that there are nodePath inclusions
+			nodePathInclusion = true;
 			nodeInclusions.getNodeForPath(nodePath).setValue(INCLUDED);
 			return this;
 		}
 
 		public ToIncludeAndReturn propertyName(final String propertyName)
 		{
 			Assert.hasText(propertyName, "propertyName");
+			// Patched : Indicates that there are property name inclusions
+			propertyNameInclusion = true;
 			propertyNameInclusions.put(propertyName, INCLUDED);
 			return this;
 		}
@@ -375,4 +391,4 @@ public ToExclude exclude()
 			return InclusionService.this.exclude();
 		}
 	}
-}
+}