org.sfm.csv.CellSetterFactory Maven / Gradle / Ivy

Go to download
package org.sfm.csv;

import java.lang.reflect.Type;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.sfm.csv.cell.BooleanCellValueReader;
import org.sfm.csv.cell.ByteCellValueReader;
import org.sfm.csv.cell.CellSetterImpl;
import org.sfm.csv.cell.CharCellValueReader;
import org.sfm.csv.cell.DateCellValueReader;
import org.sfm.csv.cell.DelayedCellSetterFactoryImpl;
import org.sfm.csv.cell.DoubleCellValueReader;
import org.sfm.csv.cell.EnumCellValueReader;
import org.sfm.csv.cell.FloatCellValueReader;
import org.sfm.csv.cell.IntegerCellValueReader;
import org.sfm.csv.cell.LongCellValueReader;
import org.sfm.csv.cell.ParsingException;
import org.sfm.csv.cell.ShortCellValueReader;
import org.sfm.csv.cell.StringCellValueReader;
import org.sfm.csv.primitive.BooleanCellSetter;
import org.sfm.csv.primitive.BooleanDelayedCellSetterFactory;
import org.sfm.csv.primitive.ByteCellSetter;
import org.sfm.csv.primitive.ByteDelayedCellSetterFactory;
import org.sfm.csv.primitive.CharCellSetter;
import org.sfm.csv.primitive.CharDelayedCellSetterFactory;
import org.sfm.csv.primitive.DoubleCellSetter;
import org.sfm.csv.primitive.DoubleDelayedCellSetterFactory;
import org.sfm.csv.primitive.FloatCellSetter;
import org.sfm.csv.primitive.FloatDelayedCellSetterFactory;
import org.sfm.csv.primitive.IntCellSetter;
import org.sfm.csv.primitive.IntDelayedCellSetterFactory;
import org.sfm.csv.primitive.LongCellSetter;
import org.sfm.csv.primitive.LongDelayedCellSetterFactory;
import org.sfm.csv.primitive.ShortCellSetter;
import org.sfm.csv.primitive.ShortDelayedCellSetterFactory;
import org.sfm.reflect.Setter;
import org.sfm.reflect.SetterFactory;
import org.sfm.reflect.TypeHelper;

public class CellSetterFactory {

	@SuppressWarnings("serial")
	private static final Map, CellValueReader> transformers = new HashMap, CellValueReader>(){{
		put(boolean.class,   new BooleanCellValueReader());
		put(byte.class,      new ByteCellValueReader());
		put(char.class, new CharCellValueReader());
		put(short.class,     new ShortCellValueReader());
		put(int.class,   new IntegerCellValueReader());
		put(long.class,      new LongCellValueReader());
		put(float.class,     new FloatCellValueReader());
		put(double.class,    new DoubleCellValueReader());
		put(Boolean.class,   new BooleanCellValueReader());
		put(Byte.class,      new ByteCellValueReader());
		put(Character.class, new CharCellValueReader());
		put(Short.class,     new ShortCellValueReader());
		put(Integer.class,   new IntegerCellValueReader());
		put(Long.class,      new LongCellValueReader());
		put(Float.class,     new FloatCellValueReader());
		put(Double.class,    new DoubleCellValueReader());
		put(String.class,    new StringCellValueReader());
	}};
	
	private Map> customReaders;
	
	public CellSetterFactory(Map> customReaders) {
		this.customReaders = customReaders;
	}

	public  CellSetter getCellSetter(Setter setter, int index, String columnName) {
		Class propertyClass = TypeHelper.toClass(setter.getPropertyType());
		
		if (propertyClass.isPrimitive() && !customReaders.containsKey(columnName)) {
			return getPrimitiveCellSetter(propertyClass, setter);
		}
		
		return new CellSetterImpl(getReaderForSetter(setter, index, columnName), setter) ;
	}
	
	public  CellSetter getPrimitiveCellSetter(Class clazz, Setter setter) {
		if (boolean.class.equals(clazz)) {
			return new BooleanCellSetter(SetterFactory.toBooleanSetter(setter));
		} else if (byte.class.equals(clazz)) {
			return new ByteCellSetter(SetterFactory.toByteSetter(setter));
		} else if (char.class.equals(clazz)) {
			return new CharCellSetter(SetterFactory.toCharacterSetter(setter));
		} else if (short.class.equals(clazz)) {
			return new ShortCellSetter(SetterFactory.toShortSetter(setter));
		} else if (int.class.equals(clazz)) {
			return new IntCellSetter(SetterFactory.toIntSetter(setter));
		} else if (long.class.equals(clazz)) {
			return new LongCellSetter(SetterFactory.toLongSetter(setter));
		} else if (float.class.equals(clazz)) {
			return new FloatCellSetter(SetterFactory.toFloatSetter(setter));
		} else if (double.class.equals(clazz)) {
			return new DoubleCellSetter(SetterFactory.toDoubleSetter(setter));
		} 
		throw new IllegalArgumentException("Invalid primitive type " + clazz);
	}
	
	@SuppressWarnings("unchecked")
	public  DelayedCellSetterFactory getPrimitiveDelayedCellSetter(Class clazz, Setter setter) {
		if (boolean.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new BooleanDelayedCellSetterFactory(SetterFactory.toBooleanSetter(setter));
		} else if (byte.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new ByteDelayedCellSetterFactory(SetterFactory.toByteSetter(setter));
		} else if (char.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new CharDelayedCellSetterFactory(SetterFactory.toCharacterSetter(setter));
		} else if (short.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new ShortDelayedCellSetterFactory(SetterFactory.toShortSetter(setter));
		} else if (int.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new IntDelayedCellSetterFactory(SetterFactory.toIntSetter(setter));
		} else if (long.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new LongDelayedCellSetterFactory(SetterFactory.toLongSetter(setter));
		} else if (float.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new FloatDelayedCellSetterFactory(SetterFactory.toFloatSetter(setter));
		} else if (double.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new DoubleDelayedCellSetterFactory(SetterFactory.toDoubleSetter(setter));
		} 
		throw new IllegalArgumentException("Invalid primitive type " + clazz);
	}

	private  CellValueReader getReaderForSetter(Setter setter, int index, String colunn) {
		Class
 propertyType = TypeHelper.toClass(setter.getPropertyType());
		CellValueReader
 reader = getReader(propertyType, index, colunn);
		return reader;
	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	private 
 CellValueReader
 getReader(Class
 propertyType, int index, String column) {
		CellValueReader
 reader = null;
		
		reader = (CellValueReader
) customReaders.get(column);
		if (reader == null) {
			if (Date.class.isAssignableFrom(propertyType)) {
				reader = (CellValueReader
) new DateCellValueReader(index);
			} else if (Enum.class.isAssignableFrom(propertyType)) {
				reader = new EnumCellValueReader(propertyType);
			} else {
				reader = getCellValueTransformer(propertyType);
			}
		}
		
		if (reader == null) {
			throw new ParsingException("No cell reader for " + propertyType);
		}
		return reader;
	}

	@SuppressWarnings("unchecked")
	private 
 CellValueReader
 getCellValueTransformer(Class
 propertyType) {
		return (CellValueReader
) transformers.get(propertyType);
	}

	public  DelayedCellSetterFactory getDelayedCellSetter(Setter setter, int index, String columnName) {
		Class propertyClass = TypeHelper.toClass(setter.getPropertyType());
		
		if (propertyClass.isPrimitive() && !customReaders.containsKey(columnName)) {
			return getPrimitiveDelayedCellSetter(propertyClass, setter);
		}
		
		return new DelayedCellSetterFactoryImpl(getReaderForSetter(setter, index, columnName), setter);
	}
	@SuppressWarnings("unchecked")
	public  DelayedCellSetterFactory getDelayedCellSetter(Type type, int index, String columnName) {
		Class propertyClass = TypeHelper.toClass(type);
		
		if (propertyClass.isPrimitive() && !customReaders.containsKey(columnName)) {
			return getPrimitiveDelayedCellSetter(propertyClass, null);
		}
		
		return new DelayedCellSetterFactoryImpl(getReader((Class)TypeHelper.toClass(type), index, columnName), null);
	}
}