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.introspection;
 
 
 import java.util.Map;
 import java.util.Set;
 
 import static java.util.Arrays.asList;
 
 public class PropertyAccessor implements PropertyAwareAccessor
 {
 	private static final Logger logger = LoggerFactory.getLogger(PropertyAccessor.class);
 
 	private final String propertyName;
 	private final Class<?> type;
 	private final Method readMethod;
 	private final Method writeMethod;
 
 	public PropertyAccessor(final String propertyNamefinal Method readMethodfinal Method writeMethod)
 	{
 		Assert.notNull(propertyName"propertyName");
 		Assert.notNull(readMethod"readMethod");
 		this. = propertyName;
 		this. = makeAccessible(readMethod);
 		this. = makeAccessible(writeMethod);
 		this. = this..getReturnType();
 	}
 
 	private static Method makeAccessible(final Method method)
 	{
 		if (method != null && !method.isAccessible())
 		{
 			.debug("Making method accessible: {}"method.toString());
 			method.setAccessible(true);
 		}
 		return method;
 	}
 
 	{
 		if (annotation != null)
 		{
 			return new TreeSet<String>(asList(annotation.categories()));
 		}
 		return Collections.emptySet();
 	}
 
 	public boolean isExcludedByAnnotation()
 	{
 		return annotation != null && annotation.excluded();
 	}
 
 	{
 		return this.;
 	}

Private function to allow looking for the field recursively up the superclasses.

Parameters:
clazz
Returns:
 
 	private Set<AnnotationgetFieldAnnotations(final Class<?> clazz)
 	{
 		try
 		{
 		}
 		catch (final NoSuchFieldException e)
 		{
			if (clazz.getSuperclass() != null)
			{
			}
			else
			{
				.debug("Cannot find propertyName: {}, declaring class: {}"clazz);
				return new LinkedHashSet<Annotation>(0);
			}
		}
	}

Returns:
The annotations of the field, or an empty set if there is no field with the name derived from the getter.
	{
	}

Returns:
The given annotation of the field, or null if not annotated or if there is no field with the name derived from the getter.
	public <T extends Annotation> T getFieldAnnotation(final Class<T> annotationClass)
	{
		final Set<? extends Annotationannotations = getFieldAnnotations();
		assert (annotations != null) : "Something is wrong here. " +
				"The contract of getReadAnnotations() guarantees a non-null return value.";
		for (final Annotation annotation : annotations)
		{
			if (annotationClass.isAssignableFrom(annotation.annotationType()))
			{
				return annotationClass.cast(annotation);
			}
		}
		return null;
	}

Returns:
The annotations of the getter used to access this property.
	{
	}
	public <T extends Annotation> T getReadMethodAnnotation(final Class<T> annotationClass)
	{
		final Set<? extends Annotationannotations = getReadMethodAnnotations();
		assert (annotations != null) : "Something is wrong here. " +
				"The contract of getReadAnnotations() guarantees a non-null return value.";
		for (final Annotation annotation : annotations)
		{
			if (annotationClass.isAssignableFrom(annotation.annotationType()))
			{
				return annotationClass.cast(annotation);
			}
		}
		return null;
	}
	{
	}
	public Object get(final Object target)
	{
		if (target == null)
		{
			return null;
		}
		try
		{
			return .invoke(target);
		}
		catch (final Exception cause)
		{
			throw new PropertyReadException(target.getClass(), cause);
		}
	}
	public void set(final Object targetfinal Object value)
	{
		if (target == null)
		{
			.info("Couldn't set new value '{}' for property '{}' " +
					"because the target object is null"value);
		}
		else if ( == null)
		{
			.debug("No setter found for property '{}'");
		}
		else
		{
			invokeWriteMethod(targetvalue);
		}
	}
	public void unset(final Object target)
	{
		set(targetnull);
	}
	@SuppressWarnings("unchecked")
	private void tryToReplaceContentOfCollectionTypes(final Object targetfinal Object value)
	{
		{
			{
				return;
			}
		}
		{
			if (tryToReplaceMapContent((Map<ObjectObject>) get(target), (Map<ObjectObject>) value))
			{
				return;
			}
		}
		.info("Couldn't set new value '{}' for property '{}'"value);
	}
	private void invokeWriteMethod(final Object targetfinal Object value)
	{
		try
		{
			.invoke(targetvalue);
		}
		catch (final Exception cause)
		{
			throw new PropertyWriteException(target.getClass(), valuecause);
		}
	}
	private static boolean tryToReplaceCollectionContent(final Collection<Objecttarget,
														 final Collection<Objectvalue)
	{
		if (target == null)
		{
			return false;
		}
		try
		{
			target.clear();
			target.addAll(value);
			return true;
		}
		catch (final Exception unmodifiable)
		{
			.debug("Failed to replace content of existing Collection"unmodifiable);
			return false;
		}
	}
	private static boolean tryToReplaceMapContent(final Map<ObjectObjecttarget,
												  final Map<ObjectObjectvalue)
	{
		if (target == null)
		{
			return false;
		}
		try
		{
			target.clear();
			target.putAll(value);
			return true;
		}
		catch (final Exception unmodifiable)
		{
			.debug("Failed to replace content of existing Map"unmodifiable);
			return false;
		}
	}
	public Class<?> getType()
	{
		return this.;
	}
	public String toString()
	{
		final StringBuilder sb = new StringBuilder("PropertyAccessor{");
		sb.append("propertyName='").append().append('\'');
		sb.append(", hasWriteMethod=").append( != null);
		sb.append('}');
		return sb.toString();
	}
New to GrepCode? Check out our FAQ X