org.simpleflatmapper.poi.impl.StaticSheetMapper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of sfm-poi Show documentation
Excel POI supports.
The newest version!
package org.simpleflatmapper.poi.impl;


import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.simpleflatmapper.map.ContextualSourceFieldMapper;
import org.simpleflatmapper.map.SourceFieldMapper;
import org.simpleflatmapper.map.SourceMapper;
import org.simpleflatmapper.map.MappingContext;
import org.simpleflatmapper.map.MappingException;
import org.simpleflatmapper.map.ConsumerErrorHandler;
import org.simpleflatmapper.map.context.MappingContextFactory;
import org.simpleflatmapper.poi.RowMapper;
import org.simpleflatmapper.util.CheckedConsumer;
import org.simpleflatmapper.util.Enumerable;
import org.simpleflatmapper.util.EnumerableIterator;

import java.util.Iterator;

//IFJAVA8_START
import org.simpleflatmapper.util.EnumerableSpliterator;

import java.util.stream.Stream;
import java.util.stream.StreamSupport;
//IFJAVA8_END

public class StaticSheetMapper implements RowMapper, SourceFieldMapper {

    private final ContextualSourceFieldMapper mapper;
    private final int startRow = 0;

    private final ConsumerErrorHandler consumerErrorHandler;
    private final MappingContextFactory mappingContextFactory;

    public StaticSheetMapper(ContextualSourceFieldMapper mapper, ConsumerErrorHandler consumerErrorHandler, MappingContextFactory mappingContextFactory) {
        this.mapper = mapper;
        this.consumerErrorHandler = consumerErrorHandler;
        this.mappingContextFactory = mappingContextFactory;
    }

    @Override
    public Iterator iterator(Sheet sheet) {
        return iterator(startRow, sheet);
    }

    @Override
    public Iterator iterator(int startRow, Sheet sheet) {
        return new EnumerableIterator(new SheetEnumerable(this, startRow, sheet, newMappingContext()));
    }

    @Override
    public Enumerable enumerate(Sheet sheet) {
        return enumerate(startRow, sheet);
    }

    @Override
    public Enumerable enumerate(int startRow, Sheet sheet) {
        return new SheetEnumerable(this, startRow, sheet, newMappingContext());


    }

    @Override
    public > RH forEach(Sheet sheet, RH consumer) {
        return forEach(startRow, sheet, consumer);
    }

    @Override
    public > RH forEach(int startRow, Sheet sheet, RH consumer) {
        MappingContext mappingContext = newMappingContext();
        SourceMapper lMapper = this.mapper;
        for(int rowNum = startRow; rowNum <= sheet.getLastRowNum(); rowNum++) {
            Row row = sheet.getRow(rowNum);
            if (row != null) {
                T object = lMapper.map(row, mappingContext);
                try {
                    consumer.accept(object);
                } catch (Exception e) {
                    consumerErrorHandler.handlerError(e, object);
                }
            }
        }
        return consumer;
    }

    //IFJAVA8_START
    @Override
    public Stream stream(Sheet sheet) {
        return stream(startRow, sheet);
    }

    @Override
    public Stream stream(int startRow, Sheet sheet) {
        return StreamSupport.stream(new EnumerableSpliterator(new SheetEnumerable(this, startRow, sheet, newMappingContext())), false);
    }
    //IFJAVA8_END


    @Override
    public T map(Row source) throws MappingException {
        return mapper.map(source);
    }

    @Override
    public T map(Row source, MappingContext context) throws MappingException {
        return mapper.map(source, context);
    }

    @Override
    public void mapTo(Row source, T target, MappingContext context) throws Exception {
        mapper.mapTo(source, target, context);
    }

    private MappingContext newMappingContext() {
        return mappingContextFactory.newContext();
    }
}