ReflectionConverter.java

Violations

Source code

package biz.hammurapi.convert;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.logging.Level;
import java.util.logging.Logger;

import biz.hammurapi.config.Context;

/**
 * Converts one type to another using accessor/constructor combination.
 * @author Pavel
 *
 */
public class ReflectionConverter implements AtomicConverter {
	private static final Logger logger = Logger.getLogger(ReflectionConverter.class.getName());
	
	Method accessor;
	Constructor constructor;
	private Class targetType;
	private Class sourceType;
	private boolean singleArg;
	
	/**
	 * @param accessor Source object method to invoke to get target type or
	 * constructor parameter for the target type. If it is null, then source itself
	 * is passed to constructor. One of parameters may be null, but not both.
	 * @param constructor Target class constructor which takes one parameter, either
	 * source type or return type of source type accessor.
	 */
	public ReflectionConverter(Method accessor, Constructor constructor) {
		super();
		this.accessor = accessor;
		this.constructor = constructor;
		singleArg = constructor!=null && constructor.getParameterTypes().length==1;
		if (accessor==null) {
			sourceType = constructor.getParameterTypes()[0];
		} else {
			sourceType = accessor.getDeclaringClass();
		}
		
		if (constructor==null) {
			targetType = accessor.getReturnType();
		} else {
			targetType = constructor.getDeclaringClass();
		}		
	}
	
	public Object convert(Object source, Converter master, Context context) {
		try {
			Object param = accessor==null ? source : accessor.invoke(source, null);
			if (constructor==null) {
				return param;
			}
			
			if (singleArg) {
				return constructor.newInstance(new Object[] {param});
			}
			
			return constructor.newInstance(new Object[] {param, context});
		} catch (Exception e) {
			logger.log(Level.FINE, "Cannot convert "+source.getClass().getName()+" to " + constructor.getDeclaringClass()+": "+e, e);
			return null;
		}
	}

	public Class getSourceType() {
		return sourceType;
	}

	public Class getTargetType() {
		return targetType;
	}
	
	/**
	 * Discovers constructor conversions.
	 * @param target Target type
	 * @return Collection of discovered converters.
	 */
	public static Collection discoverConstructorConverters(Class target) {
		Collection ret=new ArrayList();
		if (!target.isInterface()) {
			for (int i=0, cc=target.getConstructors().length; i<cc; i++) {
				Constructor constructor = target.getConstructors()[i];
				Class[] parameterTypes = constructor.getParameterTypes();
				if (parameterTypes.length==1
						&& !target.isAssignableFrom(parameterTypes[0])) {
					
					ret.add(new ReflectionConverter(null, constructor));
				} else if (parameterTypes.length==2
						&& !target.isAssignableFrom(parameterTypes[0])
						&& Context.class.equals(parameterTypes[1])) {
						
					ret.add(new ReflectionConverter(null, constructor));
				}
			}
		}
		return ret;
	}	
	
	public String toString() {
		return this.getClass().getName() + " ("+sourceType+" -> "+targetType+", accessor: "+accessor+", constructor: "+constructor+")";
	}
	
}