Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014 Daniel Bechler
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package de.danielbechler.diff.inclusion;
 
 
 import java.util.List;
 import java.util.Map;
 
 import static de.danielbechler.diff.inclusion.Inclusion.EXCLUDED;
 import static de.danielbechler.diff.inclusion.Inclusion.INCLUDED;

 
 {
 	private final InclusionNode nodeInclusions = new InclusionNode();
 	private final Map<Class<?>, InclusiontypeInclusions = new HashMap<Class<?>, Inclusion>();
 	private final Map<StringInclusioncategoryInclusions = new HashMap<StringInclusion>();
 	private final Map<StringInclusionpropertyNameInclusions = new HashMap<StringInclusion>();
 	private final ToInclude includeAndReturn = new ToIncludeAndReturnImpl();
 	private final ToExclude excludeAndReturn = new ToExcludeAndReturnImpl();
 
 	public InclusionService(final CategoryResolver categoryResolverfinal ObjectDifferBuilder rootConfiguration)
 	{
 		Assert.notNull(categoryResolver"categoryResolver");
 		Assert.notNull(rootConfiguration"rootConfiguration");
 		this. = categoryResolver;
 		this. = rootConfiguration;
 	}
 
 	public boolean isIgnored(final DiffNode node)
 	{
 		return node.isExcluded() || !isIncluded(node) || isExcluded(node);
 	}
 
 	private boolean isIncluded(final DiffNode node)
 	{
 		{
 			if (node.isRootNode())
 			{
 				return true;
 			}
 			else if (isIncludedByPath(node))
 			{
 				return true;
 			}
 			else if (isIncludedByCategory(node))
 			{
 				return true;
 			}
 			else if (isIncludedByType(node))
 			{
 				return true;
 			}
 			else if (isIncludedByPropertyName(node))
 			{
 				return true;
 			}
 			return false;
 		}
 		return true;
 	}
 
 	private boolean isExcluded(final DiffNode node)
 	{
 		{
 			if (node.isExcluded())
 			{
 				return true;
 			}
			else if (isExcludedByPath(node))
			{
				return true;
			}
			else if (isExcludedByCategory(node))
			{
				return true;
			}
			else if (isExcludedByType(node))
			{
				return true;
			}
			else if (isExcludedByPropertyName(node))
			{
				return true;
			}
		}
		return false;
	}
	private boolean hasInclusions(final Inclusion inclusion)
	{
		{
			return true;
		}
		{
			return true;
		}
		{
			return true;
		}
		{
			return true;
		}
		return false;
	}
	private boolean isIncludedByPath(final DiffNode node)
	{
	}
	private boolean isIncludedByCategory(final DiffNode node)
	{
	}
	private boolean isIncludedByType(final DiffNode node)
	{
		final AtomicBoolean result = new AtomicBoolean(false);
		{
			public void node(final DiffNode nodefinal Visit visit)
			{
				if (node.getValueType() != null)
				{
					{
						result.set(true);
						visit.stop();
					}
				}
			}
		});
		if (node.getValueType() != null)
		{
			{
				result.set(true);
			}
		}
		return result.get();
	}
	private boolean isIncludedByPropertyName(final DiffNode node)
	{
		{
			return true;
		}
		{
			return true;
		}
		return false;
	}
	private boolean isExcludedByPath(final DiffNode node)
	{
		final InclusionNode valueNode = .getNodeForPath(node.getPath());
		if (valueNode.isExcluded() && !valueNode.containsValue())
		{
			return true;
		}
		return false;
	}
	private boolean isExcludedByCategory(final DiffNode node)
	{
	}
	private boolean isExcludedByType(final DiffNode node)
	{
		if (node.getValueType() != null)
		{
		}
		return false;
	}
	private boolean isExcludedByPropertyName(final DiffNode node)
	{
		final String propertyName = node.getPropertyName();
		if (propertyName != null)
		{
			return .get(propertyName) == ;
		}
		return false;
	}
	private boolean hasCategoryWithInclusion(final DiffNode nodefinal Inclusion inclusion)
	{
		for (final String category : .resolveCategories(node))
		{
			if (.get(category) == inclusion)
			{
				return true;
			}
		}
		return false;
	}
	private boolean isIncludedByOwnPropertyName(final DiffNode node)
	{
		final String propertyName = node.getPropertyName();
		if (propertyName != null)
		{
			return .get(propertyName) == ;
		}
		return false;
	}
	private boolean isIncludedByParentPropertyName(final DiffNode node)
	{
		final List<ElementSelectorpathElementSelectors = node.getPath().getElementSelectors();
		for (final ElementSelector elementSelector : pathElementSelectors)
		{
			if (elementSelector instanceof BeanPropertyElementSelector)
			{
				final BeanPropertyElementSelector beanPropertyElement = (BeanPropertyElementSelectorelementSelector;
				final String propertyName = beanPropertyElement.getPropertyName();
				if (propertyName != null && .get(propertyName) == )
				{
					return true;
				}
			}
		}
		return false;
	}
	public ToInclude include()
	{
	}
	public ToExclude exclude()
	{
	}
	private class ToExcludeAndReturnImpl implements ToExcludeAndReturn
	{
		{
		}
		public ToExcludeAndReturn category(final String category)
		{
			return this;
		}
		public ToExcludeAndReturn type(final Class<?> type)
		{
			return this;
		}
		public ToExcludeAndReturn node(final NodePath nodePath)
		{
			return this;
		}
		public ToExcludeAndReturn propertyName(final String propertyName)
		{
			return this;
		}
		public ToInclude include()
		{
			return InclusionService.this.include();
		}
	}
	private class ToIncludeAndReturnImpl implements ToIncludeAndReturn
	{
		{
		}
		public ToIncludeAndReturn category(final String category)
		{
			return this;
		}
		public ToIncludeAndReturn type(final Class<?> type)
		{
			return this;
		}
		public ToIncludeAndReturn node(final NodePath nodePath)
		{
			return this;
		}
		public ToIncludeAndReturn propertyName(final String propertyName)
		{
			return this;
		}
		public ToExclude exclude()
		{
			return InclusionService.this.exclude();
		}
	}
New to GrepCode? Check out our FAQ X