org.simpleflatmapper.map.mapper.DiscriminatorMapper Maven / Gradle / Ivy

Go to download
package org.simpleflatmapper.map.mapper;

import org.simpleflatmapper.converter.UncheckedConverter;
import org.simpleflatmapper.map.Mapper;
import org.simpleflatmapper.map.MappingException;
import org.simpleflatmapper.map.ConsumerErrorHandler;
import org.simpleflatmapper.map.context.MappingContextFactoryFromRows;
import org.simpleflatmapper.util.Enumarable;
import org.simpleflatmapper.util.Predicate;
import org.simpleflatmapper.util.UnaryFactory;

import java.util.List;

public class DiscriminatorMapper extends AbstractEnumarableDelegateMapper {

    private final List> mappers;
    private final UncheckedConverter errorConverter;
    private final UnaryFactory> rowEnumarableFactory;

    public DiscriminatorMapper(List> mappers,
                               UnaryFactory> rowEnumarableFactory,
                               UncheckedConverter errorConverter,
                               ConsumerErrorHandler consumerErrorHandler) {
        super(consumerErrorHandler);
        this.mappers = mappers;
        this.errorConverter = errorConverter;
        this.rowEnumarableFactory = rowEnumarableFactory;
    }

    @Override
    protected Mapper getMapper(final ROW row) throws MappingException {

        for (PredicatedMapper tm : mappers) {
            if (tm.getPredicate().test(row)) {
                return tm.getMapper();
            }
        }
        throw new MappingException("No mapper found for " + errorConverter.convert(row));
    }


    @SuppressWarnings("unchecked")
    protected DiscriminatorEnumerable newEnumarableOfT(ROWS rows) throws EX {
        DiscriminatorEnumerable.PredicatedMapperWithContext[] mapperDiscriminators =
                new DiscriminatorEnumerable.PredicatedMapperWithContext[this.mappers.size()];

        for(int i = 0; i < mapperDiscriminators.length; i++) {

            PredicatedMapper predicatedMapper = mappers.get(i);
            mapperDiscriminators[i] =
                    new DiscriminatorEnumerable.PredicatedMapperWithContext(
                            predicatedMapper.getPredicate(),
                            predicatedMapper.getMapper(),
                            predicatedMapper.getMappingContextFactory().newMappingContext(rows));
        }

        return new DiscriminatorEnumerable(
                mapperDiscriminators,
                rowEnumarableFactory.newInstance(rows),
                errorConverter);
    }

    public static class PredicatedMapper {

        private final Predicate predicate;
        private final Mapper mapper;
        private final MappingContextFactoryFromRows mappingContextFactory;

        public PredicatedMapper(Predicate predicate,
                                Mapper mapper,
                                MappingContextFactoryFromRows mappingContextFactory) {
            this.predicate = predicate;
            this.mapper = mapper;
            this.mappingContextFactory = mappingContextFactory;
        }

        public Predicate getPredicate() {
            return predicate;
        }

        public Mapper getMapper() {
            return mapper;
        }

        public MappingContextFactoryFromRows getMappingContextFactory() {
            return mappingContextFactory;
        }
    }


}