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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of simpleFlatMapper Show documentation
Java library to map flat record - ResultSet, csv - to java object with minimum configuration and low footprint.
There is a newer version: 1.10.3
package org.sfm.csv.impl;

import org.sfm.csv.CsvColumnKey;
import org.sfm.csv.CsvMapper;
import org.sfm.csv.CsvParser;
import org.sfm.csv.CsvReader;
import org.sfm.csv.parser.CellConsumer;
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;

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.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
//IFJAVA8_END



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 {
		return forEach(CsvParser.reader(reader), handler);
	}

	@Override
	public > H forEach(CsvReader reader, H handle) throws IOException, MappingException {
		reader.parseAll(newCellConsumer(handle));
		return handle;
	}

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

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

	@Override
	public > H forEach(CsvReader reader, H handle, int limit) throws IOException, MappingException {
		reader.parseRows(newCellConsumer(handle), limit);
		return handle;
	}

	@Override
	public Iterator iterate(Reader reader) throws IOException {
		return iterate(CsvParser.reader(reader));
	}

	@Override
	public Iterator iterate(CsvReader csvReader) {
		return new CsvMapperIterator(csvReader, this);
	}

	@Override
	public Iterator iterate(Reader reader, int skip) throws IOException {
		return iterate(CsvParser.skip(skip).reader(reader));
	}

	@Override
	public Iterator iterator(Reader reader) throws IOException {
		return iterate(reader);
	}

	@Override
	public Iterator iterator(CsvReader csvReader) {
		return iterate(csvReader);
	}

	@Override
	public Iterator iterator(Reader reader, int skip) throws IOException {
		return iterate(reader, skip);
	}


	//IFJAVA8_START
	@Override
	public Stream stream(Reader reader) throws IOException {
		return stream(CsvParser.reader(reader));
	}

	@Override
	public Stream stream(CsvReader csvReader) {
		return StreamSupport.stream(new CsvSpliterator(csvReader), false);
	}

	@Override
	public Stream stream(Reader reader, int skip) throws IOException {
		return stream(CsvParser.skip(skip).reader(reader));
	}

	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.parseRow(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 cellHandler = cellHandlers.get(marker.getMapper());

					DelegateDelayedCellSetterFactory delegateCellSetter;

					if(cellHandler == null) {
						delegateCellSetter = new DelegateDelayedCellSetterFactory(marker, i);
						cellHandlers.put(marker.getMapper(), delegateCellSetter.getCellHandler());
					} else {
						delegateCellSetter = new DelegateDelayedCellSetterFactory(marker, cellHandler, 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 cellHandler = cellHandlers.get(marker.getMapper());

				DelegateCellSetter delegateCellSetter;

				if(cellHandler == null) {
					delegateCellSetter = new DelegateCellSetter(marker, i + delayedCellSetters.length);
					cellHandlers.put(marker.getMapper(), delegateCellSetter.getBytesCellHandler());
				} else {
					delegateCellSetter = new DelegateCellSetter(marker, cellHandler, i + delayedCellSetters.length);
				}
				outSetters[i] = delegateCellSetter;
			} else {
				outSetters[i] = setters[i];
			}
		}

		return new CsvMapperCellConsumer(instantiator,
				outDelayedCellSetters,
				outSetters, keys,
				fieldErrorHandler,
				rowHandlerErrorHandlers,
				handler,
				parsingContextFactory.newContext());
	}



}