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

Go to download
package org.sfm.csv.impl;

import java.io.IOException;
import java.io.Reader;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/*IFJAVA8_START
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
IFJAVA8_END*/

import org.sfm.csv.CsvColumnKey;
import org.sfm.csv.CsvMapper;
import org.sfm.csv.CsvParser;
import org.sfm.csv.parser.CellConsumer;
import org.sfm.csv.parser.CsvReader;
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;
	private final CsvColumnKey[] keys;
	
	private final Instantiator[], T> instantiator;
	private final FieldMapperErrorHandler fieldErrorHandler;
	private final RowHandlerErrorHandler rowHandlerErrorHandlers;
	private final ParsingContextFactory parsingContextFactory;
	
	public CsvMapperImpl(Instantiator[], T> instantiator,
			DelayedCellSetterFactory[] delayedCellSetters,
			CellSetter[] setters,
			CsvColumnKey[] keys,
			ParsingContextFactory parsingContextFactory,
			FieldMapperErrorHandler fieldErrorHandler,
			RowHandlerErrorHandler rowHandlerErrorHandlers) {
		super();
		this.instantiator = instantiator;
		this.delayedCellSetters = delayedCellSetters;
		this.setters = setters;
		this.keys = keys;
		this.fieldErrorHandler = fieldErrorHandler;
		this.rowHandlerErrorHandlers = rowHandlerErrorHandlers;
		this.parsingContextFactory = parsingContextFactory;
	}

	@Override
	public final > H forEach(final Reader reader, final H handler) throws IOException, MappingException {
		new CsvParser().parse(reader, newCellConsumer(handler));
		return handler;
	}

	@Override
	public final > H forEach(final Reader reader, final H handler, final int skip) throws IOException, MappingException {
		new CsvParser().parse(reader, newCellConsumer(handler), skip);
		return handler;
	}

	@Override
	public final > H forEach(final Reader reader, final H handler, final int skip, final int limit) throws IOException, MappingException {
		new CsvParser().parse(reader, newCellConsumer(handler), skip, limit);
		return handler;
	}

	@Override
	public Iterator iterate(Reader reader) {
		return new CsvIterator(CsvParser.newCsvReader(reader), this);
	}

	@Override
	public Iterator iterate(Reader reader, int skip) throws IOException {
		CsvReader csvReader = CsvParser.newCsvReader(reader);
		csvReader.skipLines(skip);
		return new CsvIterator(csvReader, this);
	}

	/*IFJAVA8_START
	@Override
	public Stream stream(Reader reader) {
		return StreamSupport.stream(new CsvSpliterator(CsvParser.newCsvReader(reader)), false);
	}

	@Override
	public Stream stream(Reader reader, int skip) throws IOException {
		CsvReader csvReader = CsvParser.newCsvReader(reader);
		csvReader.skipLines(skip);
		return StreamSupport.stream(new CsvSpliterator(csvReader), false);
	}

	public class CsvSpliterator implements Spliterator {
		private final CsvReader csvReader;
		private final CellConsumer cellConsumer;
		private T current;

		public CsvSpliterator(CsvReader csvReader) {
			this.csvReader = csvReader;
			this.cellConsumer = newCellConsumer(new RowHandler() {
				@Override
				public void handle(T t) throws Exception {
					current = t;
				}
			});
		}

		@Override
		public boolean tryAdvance(Consumer action) {
			current = null;
			try {
				csvReader.parseLine(cellConsumer);
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
			if (current != null) {
				action.accept(current);
				return true;
			} else {
				return false;
			}
		}

		@Override
		public void forEachRemaining(Consumer action) {
			try {
				csvReader.parseAll(newCellConsumer(new RowHandler() {
                    @Override
                    public void handle(T t) throws Exception {
						action.accept(t);
                    }
                }));
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}

		@Override
		public Spliterator trySplit() {
			return null;
		}

		@Override
		public long estimateSize() {
			return Long.MAX_VALUE;
		}

		@Override
		public int characteristics() {
			return Spliterator.ORDERED | Spliterator.NONNULL;
		}
	}

	IFJAVA8_END*/

	@SuppressWarnings({ "unchecked", "rawtypes" })
	protected CsvMapperCellConsumer newCellConsumer(final RowHandler handler) {

		DelayedCellSetter[] outDelayedCellSetters = new DelayedCellSetter[delayedCellSetters.length];
		Map, CsvMapperCellConsumer> cellHandlers = new HashMap, CsvMapperCellConsumer>();


		for(int i = 0; i < delayedCellSetters.length; i++) {
			DelayedCellSetterFactory delayedCellSetterFactory = delayedCellSetters[i];
			if (delayedCellSetterFactory != null) {
				if (delayedCellSetterFactory instanceof DelegateMarkerDelayedCellSetter) {
					DelegateMarkerDelayedCellSetter marker = (DelegateMarkerDelayedCellSetter) delayedCellSetterFactory;

					CsvMapperCellConsumer bhandler = cellHandlers.get(marker.getMapper());

					DelegateDelayedCellSetterFactory delegateCellSetter;

					if(bhandler == null) {
						delegateCellSetter = new DelegateDelayedCellSetterFactory(marker, i);
						cellHandlers.put(marker.getMapper(), delegateCellSetter.getCellHandler());
					} else {
						delegateCellSetter = new DelegateDelayedCellSetterFactory(marker, bhandler, i);
					}
					outDelayedCellSetters[i] =  delegateCellSetter.newCellSetter();
				} else {
					outDelayedCellSetters[i] = delayedCellSetterFactory.newCellSetter();
				}
			}
		}


		CellSetter[] outSetters = new CellSetter[setters.length];
		for(int i = 0; i < setters.length; i++) {
			if (setters[i] instanceof DelegateMarkerSetter) {
				DelegateMarkerSetter marker = (DelegateMarkerSetter) setters[i];

				CsvMapperCellConsumer 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 CsvMapperCellConsumer(instantiator,
				outDelayedCellSetters,
				outSetters, keys,
				fieldErrorHandler,
				rowHandlerErrorHandlers,
				handler,
				parsingContextFactory.newContext());
	}



}