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.access;
 
 
 import java.util.Map;
 import java.util.Set;
 
 import static de.danielbechler.util.Objects.isEqual;
 
 public class Instances
 {
 	private final Accessor sourceAccessor;
 	private final Object working;
 	private final Object base;
 	private final Object fresh;
 
 	Instances(final Accessor sourceAccessor,
 			  final Object working,
 			  final Object base,
 			  final Object fresh)
 	{
 		Assert.notNull(sourceAccessor"sourceAccessor");
 		this. = sourceAccessor;
 		this. = working;
 		this. = base;
 		this. = fresh;
 	}
 
 	public static <T> Instances of(final Accessor sourceAccessor,
 								   final T working,
 								   final T base,
 								   final T fresh)
 	{
 		return new Instances(sourceAccessorworkingbasefresh);
 	}
 
 	public static <T> Instances of(final Accessor sourceAccessorfinal T workingfinal T base)
 	{
 		final Object fresh = (working != null) ? Classes.freshInstanceOf(working.getClass()) : null;
 		return new Instances(sourceAccessorworkingbasefresh);
 	}
 
 	public static <T> Instances of(final T workingfinal T base)
 	{
 		final Object fresh = (working != null) ? Classes.freshInstanceOf(working.getClass()) : null;
 		return new Instances(RootAccessor.getInstance(), workingbasefresh);
 	}

Returns:
The Accessor that has been used to get to these instances.
 
 	{
 		return ;
 	}
 
 	public Instances access(final Accessor accessor)
 	{
 		Assert.notNull(accessor"accessor");
 		return new Instances(accessoraccessor.get(), accessor.get(), accessor.get());
 	}
 
 	public Object getWorking()
 	{
 		return ;
 	}
 
 	public <T> T getWorking(final Class<T> type)
 	{
 		return  != null ? type.cast() : null;
 	}
 
 	public Object getBase()
 	{
 		return ;
 	}
 
 	public <T> T getBase(final Class<T> type)
 	{
 		return  != null ? type.cast() : null;
	}
	public Object getFresh()
	{
		if ( == null)
		{
			{
				return 0;
			}
			{
				return false;
			}
		}
		return ;
	}
	@SuppressWarnings("UnusedDeclaration")
	public <T> T getFresh(final Class<T> type)
	{
		final Object o = getFresh();
		return o != null ? type.cast(o) : null;
	}
	public boolean hasBeenAdded()
	{
		if ( != null &&  == null)
		{
			return true;
		}
		{
			return true;
		}
		return false;
	}
	public boolean hasBeenRemoved()
	{
		if ( != null &&  == null)
		{
			return true;
		}
		{
			return true;
		}
		return false;
	}
	public boolean isPrimitiveType()
	{
		return Classes.isPrimitiveType(getType());
	}
	@SuppressWarnings("UnusedDeclaration")
	public boolean isPrimitiveWrapperType()
	{
		return Classes.isPrimitiveWrapperType(getType());
	}
	public Class<?> getType()
	{
		final Set<Class<?>> types = Classes.typesOf();
		final Class<?> sourceAccessorType = tryToGetTypeFromSourceAccessor();
		if (Classes.isPrimitiveType(sourceAccessorType))
		{
			return sourceAccessorType;
		}
		if (types.isEmpty())
		{
			return null;
		}
		if (types.size() == 1)
		{
			return Collections.firstElementOf(types);
		}
		if (types.size() > 1)
		{
// 			The following lines could be added if more precise type resolution is required:
//
//			if (Classes.allAssignableFrom(SortedSet.class, types))
//			{
//				return SortedSet.class;
//			}
//			if (Classes.allAssignableFrom(Set.class, types))
//			{
//				return Set.class;
//			}
//			if (Classes.allAssignableFrom(Queue.class, types))
//			{
//				return Queue.class;
//			}
//			if (Classes.allAssignableFrom(Deque.class, types))
//			{
//				return Deque.class;
//			}
//			if (Classes.allAssignableFrom(List.class, types))
//			{
//				return List.class;
//			}
//			else if (Classes.allAssignableFrom(SortedMap.class, types))
//			{
//				return SortedMap.class;
//			}
			if (Classes.allAssignableFrom(Collection.classtypes))
			{
				return Collection.class;
			}
			else if (Classes.allAssignableFrom(Map.classtypes))
			{
				return Map.class;
			}
			else
			{
				final Class<?> sharedType = Classes.mostSpecificSharedType(types);
				if (sharedType != null)
				{
					return sharedType;
				}
				else if (sourceAccessorType != null)
				{
					return sourceAccessorType;
				}
				// special handling for beans and arrays should go here
			}
		}
		throw new IllegalArgumentException("Detected instances of different types " + types + ". " +
				"Instances must either be null or have the exact same type.");
	}
	{
		{
		}
		return null;
	}
	public boolean isPrimitiveNumericType()
	{
		return Classes.isPrimitiveNumericType(getType());
	}
	private boolean isPrimitiveBooleanType()
	{
		return getType() == boolean.class;
	}
	public boolean areEqual()
	{
		return isEqual();
	}
	public boolean areSame()
	{
		return  == ;
	}
	public boolean areNull()
	{
		return  == null &&  == null;
	}
New to GrepCode? Check out our FAQ X