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

Go to download
package org.sfm.csv;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.HashMap;
import java.util.Map;

import org.sfm.csv.parser.CsvParser;
import org.sfm.map.FieldMapperErrorHandler;
import org.sfm.map.MappingException;
import org.sfm.map.RowHandlerErrorHandler;
import org.sfm.reflect.Instantiator;
import org.sfm.utils.RowHandler;

public final class CsvMapperImpl implements CsvMapper {
	private final DelayedCellSetterFactory[] delayedCellSetters;
	private final CellSetter[] setters;
	@SuppressWarnings("rawtypes")
	private final Instantiator instantiator;
	private final FieldMapperErrorHandler fieldErrorHandler;
	private final RowHandlerErrorHandler rowHandlerErrorHandlers;
	private final ParsingContextFactory parsingContextFactory;
	
	public CsvMapperImpl(@SuppressWarnings("rawtypes") Instantiator instantiator,
			DelayedCellSetterFactory[] delayedCellSetters,
			CellSetter[] setters,
			ParsingContextFactory parsingContextFactory,
			FieldMapperErrorHandler fieldErrorHandler,
			RowHandlerErrorHandler rowHandlerErrorHandlers) {
		super();
		this.instantiator = instantiator;
		this.delayedCellSetters = delayedCellSetters;
		this.setters = setters;
		this.fieldErrorHandler = fieldErrorHandler;
		this.rowHandlerErrorHandlers = rowHandlerErrorHandlers;
		this.parsingContextFactory = parsingContextFactory;
	}

	@Override
	public > H forEach(final Reader reader, final H handler) throws IOException, MappingException {
		return forEach(reader, handler, 0);
	}
	
	@Override
	public > H forEach(final Reader reader, final H handler, final int rowStart) throws IOException, MappingException {
		return forEach(reader, handler, rowStart, -1);
	}
	
	@Override
	public > H forEach(final Reader reader, final H handler, final int rowStart, final int limit) throws IOException, MappingException {
		new CsvParser().parse(reader, newCellHandler(handler, rowStart, limit));
		return handler;
	}

	@Override
	public > H forEach(final InputStream is, final H handler) throws IOException, MappingException {
		return forEach(new InputStreamReader(is), handler);
	}
	protected CsvMapperCellHandler newCellHandler(final RowHandler handler) {
		return newCellHandler(handler, -1, -1);
	}
	@SuppressWarnings({ "unchecked", "rawtypes" })
	protected CsvMapperCellHandler newCellHandler(final RowHandler handler, int rowStart, int limit) {
		
		CellSetter[] outSetters = new CellSetter[setters.length];
		DelayedCellSetter[] outDelayedCellSetters = new DelayedCellSetter[delayedCellSetters.length];
		
		
		Map, CsvMapperCellHandler> cellHandlers = new HashMap, CsvMapperCellHandler>();

		
		for(int i = 0; i < delayedCellSetters.length; i++) {
			DelayedCellSetterFactory delayedCellSetterFactory = delayedCellSetters[i];
			if (delayedCellSetterFactory != null) {
				if (delayedCellSetterFactory instanceof DelegateMarkerDelayedCellSetter) {
					DelegateMarkerDelayedCellSetter marker = (DelegateMarkerDelayedCellSetter) delayedCellSetterFactory;
					
					CsvMapperCellHandler bhandler = cellHandlers.get(marker.getMapper());
					
					DelegateDelayedCellSetterFactory delegateCellSetter;
					
					if(bhandler == null) {
						delegateCellSetter = new DelegateDelayedCellSetterFactory(marker, i);
						cellHandlers.put(marker.getMapper(), delegateCellSetter.getBytesCellHandler());
					} else {
						delegateCellSetter = new DelegateDelayedCellSetterFactory(marker, bhandler, i);
					}
					outDelayedCellSetters[i] =  delegateCellSetter.newCellSetter(); 
				} else {
					outDelayedCellSetters[i] = delayedCellSetterFactory.newCellSetter();
				}
			}
		}

		
		for(int i = 0; i < setters.length; i++) {
			if (setters[i] instanceof DelegateMarkerSetter) {
				DelegateMarkerSetter marker = (DelegateMarkerSetter) setters[i];
				
				CsvMapperCellHandler bhandler = cellHandlers.get(marker.getMapper());
				
				DelegateCellSetter delegateCellSetter;
				
				if(bhandler == null) {
					delegateCellSetter = new DelegateCellSetter(marker, i + delayedCellSetters.length);
					cellHandlers.put(marker.getMapper(), delegateCellSetter.getBytesCellHandler());
				} else {
					delegateCellSetter = new DelegateCellSetter(marker, bhandler, i + delayedCellSetters.length);
				}
				outSetters[i] = delegateCellSetter; 
			} else {
				outSetters[i] = setters[i];
			}
		}
		
		
		
		
		return new CsvMapperCellHandler(instantiator, 
				outDelayedCellSetters, 
				outSetters, 				
				fieldErrorHandler, 
				rowHandlerErrorHandlers, handler, parsingContextFactory.newContext(), rowStart, limit);
	}


}