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

Go to download
package org.sfm.csv;

import java.util.HashMap;
import java.util.Map;

import org.sfm.csv.impl.DynamicCsvMapper;
import org.sfm.map.FieldMapperErrorHandler;
import org.sfm.map.MapperBuilderErrorHandler;
import org.sfm.map.MapperBuildingException;
import org.sfm.map.impl.RethrowFieldMapperErrorHandler;
import org.sfm.map.impl.RethrowMapperBuilderErrorHandler;
import org.sfm.osgi.BridgeClassLoader;
import org.sfm.reflect.ReflectionService;
import org.sfm.reflect.asm.AsmFactory;
import org.sfm.reflect.asm.AsmHelper;

public final class CsvMapperFactory {
	
	private static final AsmFactory _asmFactory = AsmHelper.isAsmPresent() ? new AsmFactory() : null;
	
	/**
	 * instantiate a new JdbcMapperFactory
	 * @return a new JdbcMapperFactory
	 */
	public static CsvMapperFactory newInstance() {
		return new CsvMapperFactory();
	}
	
	private FieldMapperErrorHandler fieldMapperErrorHandler = new RethrowFieldMapperErrorHandler();
	private MapperBuilderErrorHandler mapperBuilderErrorHandler = new RethrowMapperBuilderErrorHandler();
	
	private Map aliases = new HashMap();
	private Map> customReaders = new HashMap>();
	
	private boolean useAsm = true;
	private boolean disableAsm = false;
	
	private final boolean useBridgeClassLoader;
	
	private String defaultDateFormat = "yyyy-MM-dd HH:mm:ss";
	
	public CsvMapperFactory(boolean useBridgeClassLoader) {
		this.useBridgeClassLoader = useBridgeClassLoader;
	}
	
	public CsvMapperFactory() {
		this(false);
	}
	
	/**
	 * 
	 * @param fieldMapperErrorHandler 
	 * @return the factory
	 */
	public CsvMapperFactory fieldMapperErrorHandler(final FieldMapperErrorHandler fieldMapperErrorHandler) {
		this.fieldMapperErrorHandler = fieldMapperErrorHandler;
		return this;
	}

	/**
	 * 
	 * @param mapperBuilderErrorHandler
	 * @return the factory
	 */
	public CsvMapperFactory mapperBuilderErrorHandler(final MapperBuilderErrorHandler mapperBuilderErrorHandler) {
		this.mapperBuilderErrorHandler = mapperBuilderErrorHandler;
		return this;
	}

	/**
	 * 
	 * @param useAsm false if you want to disable asm usage.
	 * @return the factory
	 */
	public CsvMapperFactory useAsm(final boolean useAsm) {
		this.useAsm = useAsm;
		return this;
	}
	
	/**
	 * @param disableAsm true if you want to disable asm.
	 */
	public CsvMapperFactory disableAsm(final boolean disableAsm) {
		this.disableAsm = disableAsm;
		return this;
	}
	
	public CsvMapperFactory defaultDateFormat(final String defaultDateFormat) {
		this.defaultDateFormat = defaultDateFormat;
		return this;
	}
	/**
	 * 
	 * @param target the targeted class for the mapper
	 * @return a jdbc mapper that will map to the targeted class.
	 * @throws MapperBuildingException
	 */
	public  CsvMapper newMapper(final Class target) throws MapperBuildingException {
		return new DynamicCsvMapper(target, reflectionService(target), fieldMapperErrorHandler, mapperBuilderErrorHandler, defaultDateFormat, aliases, customReaders);
	}

	
	/**
	 * Will create a instance of ResultSetMapperBuilder 
	 * @param target the target class of the mapper
	 * @return a builder ready to instantiate a mapper or to be customized
	 * @throws MapperBuildingException
	 */
	public  CsvMapperBuilder newBuilder(final Class target) {
		CsvMapperBuilder builder = new CsvMapperBuilder(target, reflectionService(target), aliases, customReaders);
		builder.fieldMapperErrorHandler(fieldMapperErrorHandler);
		builder.mapperBuilderErrorHandler(mapperBuilderErrorHandler);
		builder.setDefaultDateFormat(defaultDateFormat);
		return builder;
	}


	
	private ReflectionService reflectionService(Class target) {
		AsmFactory asmFactory = null;
		if (AsmHelper.isAsmPresent() && !disableAsm) {
			if (useBridgeClassLoader) {
				asmFactory = new AsmFactory(new BridgeClassLoader(getClass().getClassLoader(), target.getClassLoader()));
			} else {
				asmFactory = _asmFactory;
			}
		}
		return new ReflectionService(AsmHelper.isAsmPresent() && !disableAsm, useAsm, asmFactory);
	}
	
	public CsvMapperFactory addAlias(String key, String value) {
		aliases.put(key.toUpperCase(), value.toUpperCase());
		return this;
	}

	public CsvMapperFactory addCustomValueReader(String column,	CellValueReader cellValueReader) {
		customReaders.put(column, cellValueReader);
		return this;
	}
}