Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2012 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;
 
 
 import java.util.*;

This is the entry point for all comparisons. It determines the type of the given objects and passes them to the appropriate Differ.

Author(s):
Daniel Bechler
 
 {
 	private final Differ beanDiffer;
 	private final Differ mapDiffer;
 	private final Differ collectionDiffer;
 	private final Differ primitiveDiffer;
 
 
 	{
 		this. = new BeanDiffer(this);
 		this. = new MapDiffer(this);
 		this. = new CollectionDiffer(this);
 		this. = new PrimitiveDiffer(this);
 	}

Constructor used for lazy initialization of the concrete Differs.
 
 	public DelegatingObjectDifferImpl(final Differ beanDiffer,
 									  final Differ mapDiffer,
 									  final Differ collectionDiffer,
 									  final Differ primitiveDiffer)
 	{
 		this. = beanDiffer != null ? beanDiffer : new BeanDiffer(this);
 		this. = mapDiffer != null ? mapDiffer : new MapDiffer(this);
 		this. = collectionDiffer != null ? collectionDiffer : new CollectionDiffer(this);
 		this. = primitiveDiffer != null ? primitiveDiffer : new PrimitiveDiffer(this);
 	}
 
 	public <T> Node compare(final T workingfinal T base)
 	{
 		return delegate(., Instances.of(workingbase));
 	}

Delegates the comparison to the appropriate Differ.

Returns:
A node representing the difference between the given Instances.
 
 	public Node delegate(final Node parentNodefinal Instances instances)
 	{
 		Assert.notNull(instances"instances");
 		if (instances.areNull())
 		{
 			return newNode(parentNodeinstances);
 		}
 		else if (instances.isPrimitiveType())
 		{
 			return .compare(parentNodeinstances);
 		}
 		else if (Collection.class.isAssignableFrom(instances.getType()))
 		{
 			return .compare(parentNodeinstances);
 		}
 		else if (Map.class.isAssignableFrom(instances.getType()))
 		{
 			return .compare(parentNodeinstances);
 		}
 		else
 		{
 			return .compare(parentNodeinstances);
 		}
 	}
 
 	private static Node newNode(final Node parentNodefinal Instances instances)
 	{
 		return new DefaultNode(parentNodeinstances.getSourceAccessor(), instances.getType());
 	}
 
 	public boolean isIgnored(final Node node)
	{
		return .isIgnored(node);
	}
	public boolean isIncluded(final Node node)
	{
	}
	public boolean isExcluded(final Node node)
	{
	}
	public boolean isEqualsOnly(final Node node)
	{
	}
	public boolean isReturnable(final Node node)
	{
	}
	public boolean isIntrospectible(final Node node)
	{
	}
	{
	}
	public void setConfiguration(final Configuration configuration)
	{
		Assert.notNull(configuration"configuration");
		this. = configuration;
	}
	// Test Helpers
	{
		return ;
	}
	{
		return ;
	}
	{
	}
New to GrepCode? Check out our FAQ X