ConvertingService.java

Violations

Source code

package biz.hammurapi.convert;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import biz.hammurapi.config.Context;
import biz.hammurapi.config.DomConfigFactory;

public class ConvertingService {
	
	private interface ConvertersBucket {
		
		Object convert(Object source, Context context);
	}
	
	/**
	 * Converter which delegates to convert() method.
	 */
	public static final Converter CONVERTER = new Converter() {

		public Object convert(Object source, Class targetType, Context context) throws ConversionException {
			return ConvertingService.convert(source, targetType, context);
		}
		
	};			
	
	/**
	 * Converts source to target type using converters loaded from
	 * META-INF/config/biz.hammurapi.convert.Converter resources.
	 * If no converter is found, this method performs converter discovery through
	 * constructors if target type is a class and through duck conversion if target
	 * type is an interface.
	 * Invocation of this method is equivalent to invocation of
	 * <code>convert(source, targetType, false)</code>
	 * @param source Source object.
	 * @param targetType Target type.
	 * @return Source object converted to target type or null if no converter
	 * is available for source/targetType combination
	 * @throws ConversionException
	 */
	public static Object convert(Object source, Class targetType) throws ConversionException {
		return convert(source, targetType, null, false, null);
	}
	
	/**
	 * Converts source to target type using converters loaded from
	 * META-INF/config/biz.hammurapi.convert.Converter resources.
	 * If no converter is found, this method performs converter discovery through
	 * constructors if target type is a class and through duck conversion if target
	 * type is an interface.
	 * Invocation of this method is equivalent to invocation of
	 * <code>convert(source, targetType, false)</code>
	 * @param source Source object.
	 * @param targetType Target type.
	 * @param context Conversion context.
	 * @return Source object converted to target type or null if no converter
	 * is available for source/targetType combination
	 * @throws ConversionException
	 */
	public static Object convert(Object source, Class targetType, Context context) throws ConversionException {
		return convert(source, targetType, context, false, null);
	}
	
	/**
	 * Converts source to target type using converters loaded from
	 * META-INF/config/biz.hammurapi.convert.Converter resources.
	 * If no converter is found, this method performs converter discovery through
	 * constructors if target type is a class and through duck conversion if target
	 * type is an interface.
	 * Invocation of this method is equivalent to invocation of
	 * <code>convert(source, targetType, false)</code>
	 * @param source Source object.
	 * @param targetType Target type.
	 * @param classLoader Class loader, source of converters.
	 * @return Source object converted to target type or null if no converter
	 * is available for source/targetType combination
	 * @throws ConversionException
	 */
	public static Object convert(Object source, Class targetType, ClassLoader classLoader) throws ConversionException {
		return convert(source, targetType, null, false, classLoader);
	}
	
	private static class ConverterKey {
		Class sourceType;
		Class targetType;
		
		public ConverterKey(Class sourceType, Class targetType) {
			super();
			this.sourceType = sourceType;
			this.targetType = targetType;
		}

		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result	+ ((sourceType == null) ? 0 : sourceType.hashCode());
			result = prime * result	+ ((targetType == null) ? 0 : targetType.hashCode());
			return result;
		}

		public boolean equals(Object obj) {
			return 
				sourceType == ((ConverterKey) obj).sourceType 
				&& targetType == ((ConverterKey) obj).targetType; 
		}		
		
	}
	
	private static class ClassLoaderConvertersEntry {
		private static final String CONVERT = "convert";
		
		private Converter master = new Converter() {

			public Object convert(Object source, Class targetType, Context context) throws ConversionException {
				if (source==null) {
					return null;
				}
				
				if (targetType.isInstance(source)) {
					return source;
				}
				
				final ConvertersBucket bucket = findConverter(source.getClass(), targetType);
				return bucket==null ? null : bucket.convert(source, context);
			}
			
		};

		private Converter chainingMaster = new Converter() {

			public Object convert(Object source, Class targetType, Context context) throws ConversionException {
				if (source==null) {
					return null;
				}
				
				if (targetType.isInstance(source)) {
					return source;
				}
				
				ConvertersBucket bucket = findChainingConverter(source.getClass(), targetType);
				return bucket==null ? null : bucket.convert(source, context);
			}
			
		};

		Collection atomicConverters = new ArrayList();
		
		/**
		 * Map of resolved converters: Collection[source, target] -&gt; ConverterClosure.
		 */
		Map converters = new HashMap(); 
		
		Set introspectedTargetTypes = new HashSet();

		/**
		 * Map of resolved chaining converters: Collection[source, target] -&gt; ConverterClosure.
		 */
		Map chainingConverters = new HashMap();
		
		synchronized ConvertersBucket findConverter(Class sourceType, Class targetType) {
			ConverterKey key = new ConverterKey(sourceType, targetType);
			Object ret = converters.get(key);
			if (Boolean.FALSE.equals(ret)) { // Indicates that previous converter resolution didn't yield results.

				return null;
			}
			
			if (ret == null) {
				if (!targetType.isInterface() && introspectedTargetTypes.add(targetType)) {
					atomicConverters.addAll(ReflectionConverter.discoverConstructorConverters(targetType));
				}
				final List theConverters  = new ArrayList();
				
				class ConverterEntry implements Comparable {
					public ConverterEntry(AtomicConverter converter, int affinity, int position) {
						super();
						this.converter = converter;
						this.affinity = affinity;
						this.position = position;
					}
					AtomicConverter converter;
					int affinity;
					int position;
					public int compareTo(Object obj) {
						int cret = affinity - ((ConverterEntry) obj).affinity;
						if (cret==0) {
							return position - ((ConverterEntry) obj).position;
						}
						return cret;
					}
				}
				
				Iterator it = atomicConverters.iterator();
				while (it.hasNext()) {
					AtomicConverter ac = (AtomicConverter) it.next();
					int position = 0;
					if (ac.getSourceType().isAssignableFrom(sourceType) && targetType.isAssignableFrom(ac.getTargetType()) ) {
						Integer newSourceAffinity = DuckConverterFactory.classAffinity(sourceType, ac.getSourceType());
						Integer newTargetAffinity = DuckConverterFactory.classAffinity(ac.getTargetType(), targetType);
						if (newSourceAffinity==null || newTargetAffinity==null) {
							throw new IllegalArgumentException("kosyak");
						}
						theConverters.add(new ConverterEntry(ac, newSourceAffinity.intValue()+newTargetAffinity.intValue(), ++position));
					}
				}
				if (theConverters.isEmpty()) {
					converters.put(key, Boolean.FALSE);
				} else {
					Collections.sort(theConverters);
					ret = new ConvertersBucket() {

						public Object convert(Object source, Context context) {
							Iterator it = theConverters.iterator();
							while (it.hasNext()) {
								ConverterEntry ce = (ConverterEntry) it.next();
								Object ret = ce.converter.convert(source, master, context);
								if (ret!=null) {
									return ret;
								}
							}
							return null;
						}
						
					};
					converters.put(key, ret);
				}
			}
			
			return (ConvertersBucket) ret;
		}

		synchronized ConvertersBucket findChainingConverter(Class sourceType, Class targetType) {
			ConvertersBucket ret = findConverter(sourceType, targetType);
			if (ret!=null) {
				return ret;
			}
			
			// TODO 777 - Resolve chain.

			return ret;
		}
		
		void addConverters(final Object provider) {
			if (provider instanceof AtomicConverter) {
				atomicConverters.add(provider);
			} else if (provider instanceof AtomicConvertersBundle) {
				atomicConverters.addAll(((AtomicConvertersBundle) provider).getConverters());
			} else if (provider instanceof Collection) {
				Iterator it = ((Collection) provider).iterator();
				while (it.hasNext()) {
					addConverters(it.next());
				}
			} else { // Introspection

				Class pClass = provider.getClass();
				Method[] methods = pClass.getMethods();
				for (int i=0; i<methods.length; ++i) {
					final Method method = methods[i];
					if (CONVERT.equals(method.getName()) && !void.class.equals(method.getReturnType())) {
						Class[] pTypes = method.getParameterTypes();
						if (pTypes.length == 1) {
							atomicConverters.add(new AtomicConverterBase(pTypes[0], method.getReturnType()) {

								public Object convert(Object source, Converter master, Context context) {
									try {
										return method.invoke(provider, new Object[] {source});
									} catch (IllegalAccessException e) {
										throw new ConversionException(e);
									} catch (InvocationTargetException e) {
										throw new ConversionException(e);
									}
								}
								
							});
						} else if (pTypes.length == 2 && Converter.class.equals(pTypes[1])) {
							atomicConverters.add(new AtomicConverterBase(pTypes[0], method.getReturnType()) {

								public Object convert(Object source, Converter master, Context context) {
									try {
										return method.invoke(provider, new Object[] {source, master});
									} catch (IllegalAccessException e) {
										throw new ConversionException(e);
									} catch (InvocationTargetException e) {
										throw new ConversionException(e);
									}
								}
								
							});
							
						} else if (pTypes.length == 2 && Context.class.equals(pTypes[1])) {
							atomicConverters.add(new AtomicConverterBase(pTypes[0], method.getReturnType()) {

								public Object convert(Object source, Converter master, Context context) {
									try {
										return method.invoke(provider, new Object[] {source, context});
									} catch (IllegalAccessException e) {
										throw new ConversionException(e);
									} catch (InvocationTargetException e) {
										throw new ConversionException(e);
									}
								}
								
							});
							
						} else if (pTypes.length == 3 && Converter.class.equals(pTypes[1]) && Context.class.equals(pTypes[2])) {
							atomicConverters.add(new AtomicConverterBase(pTypes[0], method.getReturnType()) {

								public Object convert(Object source, Converter master, Context context) {
									try {
										return method.invoke(provider, new Object[] {source, master, context});
									} catch (IllegalAccessException e) {
										throw new ConversionException(e);
									} catch (InvocationTargetException e) {
										throw new ConversionException(e);
									}
								}
								
							});
							
						}
						
					}
				}
			}
		}
		
	}
	
	/**
	 * Map of resolved converters: ClassLoader -&gt; ClassLoaderConvertersEntry.
	 */
	private static Map classLoaderEntries = new HashMap(); 		

	/**
	 * Converts source to target type using converters loaded from
	 * <code>META-INF/config/biz.hammurapi.convert.Converter</code> resources.
	 * If no converter is found, this method performs converter discovery through
	 * constructors if target type is a class and through duck conversion if target
	 * type is an interface.
	 * @param source Source object.
	 * @param targetType Target type.
	 * @param context Conversion context.
	 * @param classLoader Class loader.
	 * @return Source object converted to target type or null if no converter
	 * is available for source/targetType combination
	 * @throws ConversionException
	 */
	public static Object convert(Object source, Class targetType, Context context, ClassLoader classLoader) throws ConversionException {
		return convert(source, targetType, context, false, classLoader);
	}
	
	/**
	 * Converts source to target type using converters loaded from
	 * <code>META-INF/config/biz.hammurapi.convert.Converter</code> resources.
	 * If no converter is found, this method performs converter discovery through
	 * constructors if target type is a class and through duck conversion if target
	 * type is an interface.
	 * @param source Source object.
	 * @param targetType Target type.
	 * @param chain If true, the converter will attempt to build a chain of
	 * conversions from source type to target type.
	 * For example, StringBuffer doesn't have a constructor from Integer. If chain
	 * is <code>false</code> then this method will return <code>null</code>. If
	 * <code>chain</code> is true, then the converter will convert Integer to String
	 * and then will create StringBuffer from it. If multiple conversion chains
	 * are available, the shortest is chosen.
	 * @return Source object converted to target type or null if no converter
	 * is available for source/targetType combination
	 * @throws ConversionException
	 */
	private static Object convert(Object source, Class targetType, Context context, boolean chain, ClassLoader classLoader) throws ConversionException {
		if (source==null) {
			return null;
		}
		
		if (targetType.isInstance(source)) {
			return source;
		}
		
		ConverterClosure converter = getConverter(source.getClass(), targetType, context, chain, classLoader);
		return converter==null ? null : converter.convert(source);		
	}
	
	/**
	 * Converts source to target type using converters loaded from
	 * <code>META-INF/config/biz.hammurapi.convert.Converter</code> resources.
	 * If no converter is found, this method performs converter discovery through
	 * constructors if target type is a class and through duck conversion if target
	 * type is an interface.
	 * @param sourceType Source type.
	 * @param targetType Target type.
	 * @return Converter from source type to target type, or null if such converter
	 * is not available.
	 * @throws ConversionException
	 */	
	public static ConverterClosure getConverter(Class sourceType, Class targetType) { 
		return getConverter(sourceType, targetType, null, false, null);
	}
	
	/**
	 * Converts source to target type using converters loaded from
	 * <code>META-INF/config/biz.hammurapi.convert.Converter</code> resources.
	 * If no converter is found, this method performs converter discovery through
	 * constructors if target type is a class and through duck conversion if target
	 * type is an interface.
	 * @param sourceType Source type.
	 * @param targetType Target type.
	 * @param classLoader Class loader to retrieve converters from.
	 * @return Converter from source type to target type, or null if such converter
	 * is not available.
	 * @throws ConversionException
	 */	
	public static ConverterClosure getConverter(Class sourceType, Class targetType, ClassLoader classLoader) { 
		return getConverter(sourceType, targetType, null, false, classLoader);
	}
	
	/**
	 * Converts source to target type using converters loaded from
	 * <code>META-INF/config/biz.hammurapi.convert.Converter</code> resources.
	 * If no converter is found, this method performs converter discovery through
	 * constructors if target type is a class and through duck conversion if target
	 * type is an interface.
	 * @param sourceType Source type.
	 * @param targetType Target type.
	 * @param context Conversion context.
	 * @return Converter from source type to target type, or null if such converter
	 * is not available.
	 * @throws ConversionException
	 */	
	public static ConverterClosure getConverter(Class sourceType, Class targetType, Context context) { 
		return getConverter(sourceType, targetType, context, false, null);
	}
	
	/**
	 * Converts source to target type using converters loaded from
	 * <code>META-INF/config/biz.hammurapi.convert.Converter</code> resources.
	 * If no converter is found, this method performs converter discovery through
	 * constructors if target type is a class and through duck conversion if target
	 * type is an interface.
	 * @param sourceType Source type.
	 * @param targetType Target type.
	 * @param context Conversion context.
	 * @param classLoader Class loader to retrieve converters from.
	 * @return Converter from source type to target type, or null if such converter
	 * is not available.
	 * @throws ConversionException
	 */	
	public static ConverterClosure getConverter(Class sourceType, Class targetType, Context context, ClassLoader classLoader) { 
		return getConverter(sourceType, targetType, context, false, classLoader);
	}
	
	private static ClassLoader promote(ClassLoader present, ClassLoader candidate) {
		ClassLoader ret = DuckConverterFactory.getChildClassLoader(present, candidate);
		return ret==null ? present : ret;
	}
	
	/**
	 *
	 * @param sourceType
	 * @param targetType
	 * @param context
	 * @param chain If true, the converter will attempt to build a chain of
	 * conversions from source type to target type.
	 * For example, StringBuffer doesn't have a constructor from Integer. If chain
	 * is <code>false</code> then this method will return <code>null</code>. If
	 * <code>chain</code> is true, then the converter will convert Integer to String
	 * and then will create StringBuffer from it. If multiple conversion chains
	 * are available, the shortest is chosen.
	 * @param classLoader
	 * @return
	 */
	private static ConverterClosure getConverter(Class sourceType, Class targetType, final Context context, boolean chain, final ClassLoader pClassLoader) {
		ClassLoader classLoader = promote(pClassLoader, promote(targetType.getClassLoader(), sourceType.getClassLoader()));
					
		ClassLoaderConvertersEntry clce;
		synchronized (classLoaderEntries) {
			clce = (ClassLoaderConvertersEntry) classLoaderEntries.get(classLoader);
			if (clce == null) {
				clce = new ClassLoaderConvertersEntry();
				Iterator pit = DomConfigFactory.loadProviders(Converter.class, classLoader);
				while (pit.hasNext()) {
					clce.addConverters(pit.next());
				}
				classLoaderEntries.put(classLoader, clce);
			}			
		}
		final ConvertersBucket bucket = chain ? clce.findChainingConverter(sourceType, targetType) : clce.findConverter(sourceType, targetType);
		return bucket==null ? null : new ConverterClosure() {

			public Object convert(Object source) {
				return bucket.convert(source, context);
			}
			
		};
	}
}