All Downloads are FREE. Search and download functionalities are using the official Maven repository.

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

package org.sfm.csv.impl;

import org.sfm.csv.CellValueReader;
import org.sfm.csv.CellValueReaderFactory;
import org.sfm.csv.CsvColumnDefinition;
import org.sfm.csv.CsvColumnKey;
import org.sfm.csv.impl.cellreader.*;
import org.sfm.csv.impl.primitive.*;
import org.sfm.csv.ParsingContextFactoryBuilder;
import org.sfm.reflect.*;
import org.sfm.reflect.impl.NullSetter;
import org.sfm.reflect.meta.ClassMeta;
import org.sfm.reflect.meta.PropertyMeta;

import java.lang.reflect.Type;

public final class CellSetterFactory {

	private final CellValueReaderFactory cellValueReaderFactory;

	public CellSetterFactory(CellValueReaderFactory cellValueReaderFactory) {
		this.cellValueReaderFactory = cellValueReaderFactory;
	}
	
	public  CellSetter getPrimitiveCellSetter(Class clazz, CellValueReader reader,  Setter setter) {
		if (boolean.class.equals(clazz)) {
			return new BooleanCellSetter(ObjectSetterFactory.toBooleanSetter(setter), booleanReader(reader));
		} else if (byte.class.equals(clazz)) {
			return new ByteCellSetter(ObjectSetterFactory.toByteSetter(setter), byteReader(reader));
		} else if (char.class.equals(clazz)) {
			return new CharCellSetter(ObjectSetterFactory.toCharacterSetter(setter), charReader(reader));
		} else if (short.class.equals(clazz)) {
			return new ShortCellSetter(ObjectSetterFactory.toShortSetter(setter), shortReader(reader));
		} else if (int.class.equals(clazz)) {
			return new IntCellSetter(ObjectSetterFactory.toIntSetter(setter), intReader(reader));
		} else if (long.class.equals(clazz)) {
			return new LongCellSetter(ObjectSetterFactory.toLongSetter(setter), longReader(reader));
		} else if (float.class.equals(clazz)) {
			return new FloatCellSetter(ObjectSetterFactory.toFloatSetter(setter), floatReader(reader));
		} else if (double.class.equals(clazz)) {
			return new DoubleCellSetter(ObjectSetterFactory.toDoubleSetter(setter), doubleReader(reader));
		} 
		throw new IllegalArgumentException("Invalid primitive type " + clazz);
	}

	@SuppressWarnings("unchecked")
	private DoubleCellValueReader doubleReader(CellValueReader reader) {
		if (reader instanceof DoubleCellValueReader)  {
			return (DoubleCellValueReader) reader;
		} else {
			return new BoxedDoubleCellValueReader((CellValueReader) reader);
		}
	}

	@SuppressWarnings("unchecked")
	private FloatCellValueReader floatReader(CellValueReader reader) {
		if (reader instanceof FloatCellValueReader)  {
			return (FloatCellValueReader) reader;
		} else {
			return new BoxedFloatCellValueReader((CellValueReader) reader);
		}
	}

	@SuppressWarnings("unchecked")
	private LongCellValueReader longReader(CellValueReader reader) {
		if (reader instanceof LongCellValueReader)  {
			return (LongCellValueReader) reader;
		} else {
			return new BoxedLongCellValueReader((CellValueReader) reader);
		}
	}

	@SuppressWarnings("unchecked")
	private IntegerCellValueReader intReader(CellValueReader reader) {
		if (reader instanceof IntegerCellValueReader)  {
			return (IntegerCellValueReader) reader;
		} else {
			return new BoxedIntegerCellValueReader((CellValueReader) reader);
		}
	}

	@SuppressWarnings("unchecked")
	private ShortCellValueReader shortReader(CellValueReader reader) {
		if (reader instanceof ShortCellValueReader)  {
			return (ShortCellValueReader) reader;
		} else {
			return new BoxedShortCellValueReader((CellValueReader) reader);
		}
	}

	@SuppressWarnings("unchecked")
	private CharCellValueReader charReader(CellValueReader reader) {
		if (reader instanceof CharCellValueReader)  {
			return (CharCellValueReader) reader;
		} else {
			return new BoxedCharCellValueReader((CellValueReader) reader);
		}
	}

	@SuppressWarnings("unchecked")
	private ByteCellValueReader byteReader(CellValueReader reader) {
		if (reader instanceof ByteCellValueReader)  {
			return (ByteCellValueReader) reader;
		} else {
			return new BoxedByteCellValueReader((CellValueReader) reader);
		}
	}

	@SuppressWarnings("unchecked")
	private BooleanCellValueReader booleanReader(CellValueReader reader) {
		if (reader instanceof BooleanCellValueReader)  {
			return (BooleanCellValueReader) reader;
		} else {
			return new BoxedBooleanCellValueReader((CellValueReader) reader);
		}
	}

	@SuppressWarnings("unchecked")
	private  DelayedCellSetterFactory getPrimitiveDelayedCellSetter(Class clazz, CellValueReader reader, Setter setter) {
		if (boolean.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new BooleanDelayedCellSetterFactory(ObjectSetterFactory.toBooleanSetter(setter), booleanReader(reader));
		} else if (byte.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new ByteDelayedCellSetterFactory(ObjectSetterFactory.toByteSetter(setter), byteReader(reader));
		} else if (char.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new CharDelayedCellSetterFactory(ObjectSetterFactory.toCharacterSetter(setter), charReader(reader));
		} else if (short.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new ShortDelayedCellSetterFactory(ObjectSetterFactory.toShortSetter(setter), shortReader(reader));
		} else if (int.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new IntDelayedCellSetterFactory(ObjectSetterFactory.toIntSetter(setter), intReader(reader));
		} else if (long.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new LongDelayedCellSetterFactory(ObjectSetterFactory.toLongSetter(setter), longReader(reader));
		} else if (float.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new FloatDelayedCellSetterFactory(ObjectSetterFactory.toFloatSetter(setter), floatReader(reader));
		} else if (double.class.equals(clazz)) {
			return (DelayedCellSetterFactory) new DoubleDelayedCellSetterFactory(ObjectSetterFactory.toDoubleSetter(setter), doubleReader(reader));
		} 
		throw new IllegalArgumentException("Invalid primitive type " + clazz);
	}

	@SuppressWarnings("unchecked")
    public  Getter, P> newDelayedGetter(CsvColumnKey key, Type type) {
		Class clazz = TypeHelper.toClass(type);
		Getter getter;
		int columnIndex = key.getIndex();
		if (clazz.isPrimitive()) {
			if (boolean.class.equals(clazz)) {
				getter = new BooleanDelayedGetter(columnIndex);
			} else if (byte.class.equals(clazz)) {
				getter = new ByteDelayedGetter(columnIndex);
			} else if (char.class.equals(clazz)) {
				getter = new CharDelayedGetter(columnIndex);
			} else if (short.class.equals(clazz)) {
				getter = new ShortDelayedGetter(columnIndex);
			} else if (int.class.equals(clazz)) {
				getter = new IntDelayedGetter(columnIndex);
			} else if (long.class.equals(clazz)) {
				getter = new LongDelayedGetter(columnIndex);
			} else if (float.class.equals(clazz)) {
				getter = new FloatDelayedGetter(columnIndex);
			} else if (double.class.equals(clazz)) {
				getter = new DoubleDelayedGetter(columnIndex);
			} else {
				throw new IllegalArgumentException("Unexpected primitive " + clazz);
			}
		} else {
			getter = new DelayedGetter(columnIndex);
		}
		return getter;
	}

	@SuppressWarnings({"unchecked" })
	private 

CellValueReader

getReader(ClassMeta

propertyType, int index, CsvColumnDefinition columnDefinition, ParsingContextFactoryBuilder parsingContextFactoryBuilder) { CellValueReader

reader = null; if (columnDefinition.hasCustomSource()) { reader = (CellValueReader

) columnDefinition.getCustomReader(); } CellValueReaderFactory factory = cellValueReaderFactory; if (columnDefinition.hasCustomReaderFactory()) { factory = columnDefinition.getCustomCellValueReaderFactory(); } if (reader == null) { reader = factory.getReader(propertyType.getType(), index, columnDefinition, parsingContextFactoryBuilder); } if (reader == null) { for(InstantiatorDefinition id : propertyType.getInstantiatorDefinitions()) { if (id.getParameters().length == 1) { final Type sourceType = id.getParameters()[0].getGenericType(); reader = factory.getReader(sourceType, index, columnDefinition, parsingContextFactoryBuilder); if (reader != null) { Instantiator instantiator = propertyType.getReflectionService().getInstantiatorFactory().getOneArgIdentityInstantiator(id); return new InstantiatorOnReader(instantiator, reader); } } } } // if (reader == null && false) { // // check if has a one arg construct // final Constructor[] constructors = propertyType.getConstructors(); // if (constructors != null && constructors.length == 1 && constructors[0].getParameterTypes().length == 1) { // final Constructor

constructor = (Constructor

) constructors[0]; // CellValueReader innerReader = factory.

getReader(constructor.getParameterTypes()[0], index, columnDefinition, parsingContextFactoryBuilder); // // if (innerReader != null) { // reader = new ConstructorOnReader

(constructor, innerReader); // } // } // } if (reader == null) { throw new ParsingException("No cell reader for " + propertyType); } return reader; } @SuppressWarnings("unchecked") public CellSetter getCellSetter(PropertyMeta prop, int index, CsvColumnDefinition columnDefinition, ParsingContextFactoryBuilder parsingContextFactoryBuilder) { Class propertyClass = (Class) TypeHelper.toClass(prop.getPropertyType()); CellValueReader reader = getReader(prop.getPropertyClassMeta(), index, columnDefinition, parsingContextFactoryBuilder); if (propertyClass.isPrimitive()) { return getPrimitiveCellSetter(propertyClass, reader, getSetter(prop)); } else { return new CellSetterImpl(reader, getSetter(prop)); } } public DelayedCellSetterFactory getDelayedCellSetter(PropertyMeta prop, int index, CsvColumnDefinition columnDefinition, ParsingContextFactoryBuilder parsingContextFactoryBuilder) { Class propertyClass = TypeHelper.toClass(prop.getPropertyType()); CellValueReader reader = getReader(prop.getPropertyClassMeta(), index, columnDefinition, parsingContextFactoryBuilder); if (propertyClass.isPrimitive()) { return getPrimitiveDelayedCellSetter(propertyClass, reader, getSetter(prop)); } else { return new DelayedCellSetterFactoryImpl(reader, getSetter(prop)); } } private Setter getSetter(PropertyMeta prop) { Setter setter = prop.getSetter(); if (NullSetter.isNull(setter)) { return null; } else { return setter; } } }





© 2015 - 2025 Weber Informatics LLC | Privacy Policy