InclusionService: Code format and Changelog entry

Author: SQiShER

CHANGELOG.md

@@ -0,0 +1,4 @@
+# Changelog
+
+## 0.91
+* InclusionService: Performance improvements (via @Deipher)

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

@@ -24,7 +24,6 @@
 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;
@@ -35,9 +34,6 @@
 import static de.danielbechler.diff.inclusion.Inclusion.INCLUDED;
 import static java.util.Arrays.asList;
 
-/**
- *
- */
 public class InclusionService implements InclusionConfigurer, IsIgnoredResolver
 {
 	private final CategoryResolver categoryResolver;
@@ -86,15 +82,18 @@ private boolean isExcluded(final DiffNode node)
 			}
 		}
 		// Patched : Check if there are exclusions before browsing all excluded elements
-		if (hasExclusions()) {
-			if (isExcludedByPath(node) || isExcludedByCategory(node)) {
+		if (hasExclusions())
+		{
+			if (isExcludedByPath(node) || isExcludedByCategory(node))
+			{
 				return true;
-			} else if (isExcludedByType(node) || isExcludedByPropertyName(node)) {
+			}
+			else if (isExcludedByType(node) || isExcludedByPropertyName(node))
+			{
 				return true;
 			}
 		}
 		return false;
-
 	}
 
 	private boolean isIncluded(final DiffNode node)
@@ -109,108 +108,129 @@ private boolean isIncluded(final DiffNode node)
 			{
 				return true;
 			}
-		}		
+		}
 		// Patched : Check if there are inclusions before browsing all included elements
-		if (hasInclusions()) {
-			if (node.isRootNode()) {
+		if (hasInclusions())
+		{
+			if (node.isRootNode())
+			{
 				return true;
-			} else if (isIncludedByPath(node) || isIncludedByCategory(node)) {
+			}
+			else if (isIncludedByPath(node) || isIncludedByCategory(node))
+			{
 				return true;
-			} else if (isIncludedByType(node) || isIncludedByPropertyName(node)) {
+			}
+			else if (isIncludedByType(node) || isIncludedByPropertyName(node))
+			{
 				return true;
 			}
 			return false;
 		}
 		return true;
 	}
 
-	private boolean hasInclusions() {
-		// Patched : Now return if inclusions have been configured
-		return nodePathInclusion || categoryInclusion || typeInclusion || propertyNameInclusion;
-	}
-	
-	private boolean hasExclusions() {
+	private boolean hasExclusions()
+	{
 		// Patched (New method) : Now return if exclusions have been configured
 		return nodePathExclusion || categoryExclusion || typeExclusion || propertyNameExclusion;
 	}
 
-	private boolean isIncludedByPath(final DiffNode node)
+	private boolean isExcludedByPath(final DiffNode node)
 	{
-		// Patched : First check if nodePath inclusions have been configured
-		if (nodePathInclusion && nodeInclusions.getNodeForPath(node.getPath()).isIncluded()) {
-			return true;
+		// 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 isIncludedByCategory(final DiffNode node)
+	private boolean isExcludedByCategory(final DiffNode node)
 	{
-		// Patched : First check if category inclusions have been configured
-		if (categoryInclusion && hasCategoryWithInclusion(node, INCLUDED)) {
+		// Patched : First check if category exclusions have been configured
+		if (categoryExclusion && hasCategoryWithInclusion(node, EXCLUDED))
+		{
 			return true;
 		}
 		return false;
 	}
 
-	private boolean isIncludedByType(final DiffNode node)
+	private boolean isExcludedByType(final DiffNode node)
 	{
-		// Patched : First check if type inclusions have been configured
-		if (typeInclusion && typeInclusions.get(node.getValueType()) == INCLUDED) {
-			return true;
+		// Patched : First check if type exclusions have been configured
+		if (typeExclusion && node.getValueType() != null)
+		{
+			return typeInclusions.get(node.getValueType()) == EXCLUDED;
 		}
 		return false;
 	}
 
-	private boolean isIncludedByPropertyName(final DiffNode node)
+	private boolean isExcludedByPropertyName(final DiffNode node)
 	{
-		// Patched : First check if property name inclusions have been configured
-		if (propertyNameInclusion) {
-			if (isIncludedByOwnPropertyName(node)) {
-				return true;
-			} else if (isIncludedByParentPropertyName(node)) {
-				return true;
+		// 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;
 	}
 
-	private boolean isExcludedByPath(final DiffNode node)
+	private boolean hasInclusions()
 	{
-		// 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;
-			}
+		// Patched : Now return if inclusions have been configured
+		return nodePathInclusion || categoryInclusion || typeInclusion || propertyNameInclusion;
+	}
+
+	private boolean isIncludedByPath(final DiffNode node)
+	{
+		// Patched : First check if nodePath inclusions have been configured
+		if (nodePathInclusion && nodeInclusions.getNodeForPath(node.getPath()).isIncluded())
+		{
+			return true;
 		}
 		return false;
 	}
 
-	private boolean isExcludedByCategory(final DiffNode node)
+	private boolean isIncludedByCategory(final DiffNode node)
 	{
-		// Patched : First check if category exclusions have been configured
-		if (categoryExclusion && hasCategoryWithInclusion(node, EXCLUDED)) {
+		// Patched : First check if category inclusions have been configured
+		if (categoryInclusion && hasCategoryWithInclusion(node, INCLUDED))
+		{
 			return true;
 		}
 		return false;
 	}
 
-	private boolean isExcludedByType(final DiffNode node)
+	private boolean isIncludedByType(final DiffNode node)
 	{
-		// Patched : First check if type exclusions have been configured
-		if (typeExclusion && node.getValueType() != null) {
-			return typeInclusions.get(node.getValueType()) == EXCLUDED;
+		// Patched : First check if type inclusions have been configured
+		if (typeInclusion && typeInclusions.get(node.getValueType()) == INCLUDED)
+		{
+			return true;
 		}
 		return false;
 	}
 
-	private boolean isExcludedByPropertyName(final DiffNode node)
+	private boolean isIncludedByPropertyName(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;
+		// 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;