AbstractCsvAnnotationBeanReader

package com.github.mygreen.supercsv.io;

import java.io.IOException;
import java.io.Reader;
import java.io.UncheckedIOException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

import org.supercsv.cellprocessor.ift.CellProcessor;
import org.supercsv.exception.SuperCsvCellProcessorException;
import org.supercsv.exception.SuperCsvException;
import org.supercsv.exception.SuperCsvReflectionException;
import org.supercsv.io.AbstractCsvReader;
import org.supercsv.io.CsvBeanReader;
import org.supercsv.io.ITokenizer;
import org.supercsv.prefs.CsvPreference;
import org.supercsv.util.BeanInterfaceProxy;
import org.supercsv.util.CsvContext;
import org.supercsv.util.MethodCache;

import com.github.mygreen.supercsv.builder.BeanMapping;
import com.github.mygreen.supercsv.builder.CallbackMethod;
import com.github.mygreen.supercsv.exception.SuperCsvBindingException;
import com.github.mygreen.supercsv.exception.SuperCsvNoMatchColumnSizeException;
import com.github.mygreen.supercsv.exception.SuperCsvNoMatchHeaderException;
import com.github.mygreen.supercsv.exception.SuperCsvRowException;
import com.github.mygreen.supercsv.validation.CsvBindingErrors;
import com.github.mygreen.supercsv.validation.CsvError;
import com.github.mygreen.supercsv.validation.CsvExceptionConverter;
import com.github.mygreen.supercsv.validation.CsvValidator;
import com.github.mygreen.supercsv.validation.ValidationContext;

/**
 * アノテーションを元にCSVファイルを読み込むための抽象クラス。
 *
 * @param <T> マッピング対象のBeanのクラスタイプ
 *
 * @see CsvBeanReader
 * @version 2.3
 * @since 2.1
 * @author T.TSUCHIE
 *
 */
public abstract class AbstractCsvAnnotationBeanReader<T> extends AbstractCsvReader {

    /**
     * Beanのマッピング情報のキャッシュ。
     * ・組み立てたCellProcessorをキャッシュしておきます。
     */
    protected BeanMappingCache<T> beanMappingCache;

    /** temporary storage of processed columns to be mapped to the bean */
    protected final List<Object> processedColumns = new ArrayList<>();

    /** cache of methods for mapping from columns to fields */
    protected final MethodCache cache = new MethodCache();

    /** exception converter. */
    protected CsvExceptionConverteronverter.html#CsvExceptionConverter">CsvExceptionConverter exceptionConverter = new CsvExceptionConverter();

    /** processing error messages. */
    protected final List<String> errorMessages = new ArrayList<>();

    /** validator */
    protected final List<CsvValidator<T>> validators = new ArrayList<>();

    public AbstractCsvAnnotationBeanReader(final Reader reader, final CsvPreference preference) {
        super(reader, preference);
    }

    public AbstractCsvAnnotationBeanReader(final ITokenizer tokenizer, final CsvPreference preference) {
        super(tokenizer, preference);
    }

    /**
     * 1レコード分を読み込みます。
     *
     * @return Beanのレコード。読み込むレコードがない場合は、nullを返します。
     *
     * @throws IOException レコードの読み込みに失敗した場合。
     * @throws SuperCsvNoMatchColumnSizeException レコードのカラムサイズに問題がある場合
     * @throws SuperCsvBindingException セルの値に問題がある場合
     * @throws SuperCsvException 設定など、その他に問題がある場合
     *
     */
    public T read() throws IOException {

        if(readRow()) {

            final T bean = instantiateBean(beanMappingCache.getOriginal().getType());
            final CsvBindingErrorsBindingErrors.html#CsvBindingErrors">CsvBindingErrors bindingErrors = new CsvBindingErrors(beanMappingCache.getOriginal().getType());

            final CsvContext context = new CsvContext(getLineNumber(), getRowNumber(), 1);
            context.setRowSource(new ArrayList<Object>(processedColumns));

            Optional<SuperCsvRowException> rowException = Optional.empty();
            try {
                executeCellProcessor(processedColumns, getColumns(), beanMappingCache.getCellProcessorsForReading(), context);

            } catch(SuperCsvRowException e) {
                /*
                 * カラムごとのCellProcessorのエラーの場合、別なValidatorで値を検証するために、
                 * 後から判定を行うようにする。
                 */
                rowException = Optional.of(e);

                final List<CsvError> errors = exceptionConverter.convert(e, beanMappingCache.getOriginal());
                bindingErrors.addAllErrors(errors);

            } catch(SuperCsvException e) {
                errorMessages.addAll(exceptionConverter.convertAndFormat(e, beanMappingCache.getOriginal()));
                throw e;
            }

            // コールバックメソッドの実行（読み込み前）
            for(CallbackMethod callback : beanMappingCache.getOriginal().getPreReadMethods()) {
                callback.invoke(bean, context, bindingErrors, beanMappingCache.getOriginal());
            }

            // beanへのマッピング
            populateBean(bean, beanMappingCache.getNameMapping(), bindingErrors);

            // Bean(レコード)の入力値検証
            for(CsvValidator<T> recordValidator : validators) {
                recordValidator.validate(bean, bindingErrors, new ValidationContext<>(context, beanMappingCache.getOriginal()));
            }

            // コールバックメソッドの実行（読み込み後）
            for(CallbackMethod callback : beanMappingCache.getOriginal().getPostReadMethods()) {
                callback.invoke(bean, context, bindingErrors, beanMappingCache.getOriginal());
            }

            // エラーメッセージの変換
            processErrors(bindingErrors, context, rowException);

            return bean;

        }

        return null; // EOF


    }

    /**
     * 成功時、例外発生時の処理を指定して、1レコード分を読み込みます。
     *
     * @since 2.3
     * @param successHandler 読み込み成功時の処理の実装。
     * @param errorHandler CSVに関する例外発生時の処理の実装。
     * @return CSVの読み込み処理ステータスを返します。
     * @throws IOException 致命的なレコードの読み込みに失敗した場合にスローされます。
     */
    public CsvReadStatus read(final CsvSuccessHandler<T> successHandler, final CsvErrorHandler errorHandler) throws IOException {

        try {
            final T bean = read();
            if(bean != null) {
                successHandler.onSuccess(bean);
                return CsvReadStatus.SUCCESS;
            } else {
                return CsvReadStatus.EOF;
            }

        } catch(SuperCsvException e) {
            errorHandler.onError(e);
            return CsvReadStatus.ERROR;

        }

    }

    /**
     * {@link Stream} を返します。要素はCSVの行をBeanにマッピングしたオブジェクトです。
     * <p>読み込む際には例外 {@link SuperCsvException} / {@link UncheckedIOException} が発生する可能性があります（読み込みを行った {@link Stream} メソッドからスローされます)。</p>
     * <p>読み込み時にスローされた {@link IOException} は、{@link UncheckedIOException} にラップされます。</p>
     *
     * @since 2.3
     * @return 各レコードをBeanに変換した {@link Stream} を返します。
     */
    public Stream<T> lines() {

        Iterator<T> itr = new Iterator<T>() {

            T nextLine = null;

            @Override
            public boolean hasNext() {
                if(nextLine != null) {
                    return true;

                } else {
                    try {
                        nextLine = read();
                        return (nextLine != null);
                    } catch(IOException e) {
                        throw new UncheckedIOException(e);
                    }
                }
            }

            @Override
            public T next() {
                if (nextLine != null || hasNext()) {
                    T line = nextLine;
                    nextLine = null;
                    return line;
                } else {
                    throw new NoSuchElementException();
                }
            }

        };

        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
                itr, Spliterator.ORDERED | Spliterator.NONNULL), false);

    }

    /**
     * CSVのヘッダーの検証を行います。
     *
     * @param sourceHeader オリジナルのヘッダー情報。
     * @param definedHeader アノテーションなどの定義を元にしたヘッダー情報
     * @throws SuperCsvNoMatchColumnSizeException ヘッダーのサイズ（カラム数）がBean定義と一致しない場合。
     * @throws SuperCsvNoMatchHeaderException ヘッダーの値がBean定義と一致しない場合。
     */
    protected void validateHeader(final String[] sourceHeader, final String[] definedHeader) {

        // check column size.
        if(sourceHeader.length != definedHeader.length) {
            final CsvContext context = new CsvContext(1, 1, 1);
            throw new SuperCsvNoMatchColumnSizeException(sourceHeader.length, definedHeader.length, context);

        }

        // check header value
        for(int i=0; i < sourceHeader.length; i++) {
            if(!sourceHeader[i].equals(definedHeader[i])) {
                final CsvContext context = new CsvContext(1, 1, i+1);
                throw new SuperCsvNoMatchHeaderException(sourceHeader, definedHeader, context);
            }
        }

    }

    /**
     * 行の例外情報をメッセージに変換したりします。
     * @param bindingErrors
     * @param context
     * @param rowException
     */
    protected void processErrors(final CsvBindingErrors bindingErrors, final CsvContext context,
            final Optional<SuperCsvRowException> rowException) {
        if(bindingErrors.hasErrors()) {
            final List<String> message = bindingErrors.getAllErrors().stream()
                    .map(error -> error.format(exceptionConverter.getMessageResolver(), exceptionConverter.getMessageInterpolator()))
                    .collect(Collectors.toList());
            errorMessages.addAll(message);

            final SuperCsvBindingExceptionException.html#SuperCsvBindingException">SuperCsvBindingException bindingException = new SuperCsvBindingException("has binding error.", context, bindingErrors);
            rowException.ifPresent(re -> bindingException.addAllProcessingErrors(re.getColumnErrors()));

            throw bindingException;
        }
    }

    /**
     * 指定したBeanのクラスのインスタンスを作成する。
     *
     * @param clazz Beanのクラスタイプ。
     * @return Beanのインスタンス。
     * @throws SuperCsvReflectionException Beanのインスタンスの作成に失敗した場合。
     */
    protected T instantiateBean(final Class<T> clazz) {

        final T bean;
        if( clazz.isInterface() ) {
            bean = BeanInterfaceProxy.createProxy(clazz);
        } else {
            try {
                bean = clazz.newInstance();
            } catch(InstantiationException e) {
                throw new SuperCsvReflectionException(String.format(
                    "error instantiating bean, check that %s has a default no-args constructor", clazz.getName()), e);
            } catch(IllegalAccessException e) {
                throw new SuperCsvReflectionException("error instantiating bean", e);
            }
        }

        return bean;

    }

    /**
     * 行の各カラムの値に対して、CellProcessorを適用します。
     * @param destination
     * @param source
     * @param processors
     * @param context
     * @throws SuperCsvNoMatchColumnSizeException カラムサイズが定義と一致しない場合
     * @throws SuperCsvRowException CellProcessor内で発生した例外
     */
    protected void executeCellProcessor(final List<Object> destination, final List<String> source,
            final CellProcessor[] processors, final CsvContext context) {

        if(source.size() != processors.length) {
            throw new SuperCsvNoMatchColumnSizeException(source.size(), processors.length, context);

        }

        destination.clear();

        final SuperCsvRowExceptionvRowException.html#SuperCsvRowException">SuperCsvRowException rowException = new SuperCsvRowException(
                String.format("row (%d) has errors column", context.getRowNumber()), context);

        for( int i = 0; i < source.size(); i++ ) {

            try {
                context.setColumnNumber(i + 1); // update context (columns start at 1)

                if( processors[i] == null ) {
                    destination.add(source.get(i)); // no processing required
                } else {
                    destination.add(processors[i].execute(source.get(i), context)); // execute the processor chain
                }
            } catch(SuperCsvCellProcessorException e) {
                rowException.addError(e);

                // 各カラムでエラーがあっても、後の入力値検証で処理を続けるために、仮に値を設定する。
                destination.add(source.get(i));

            } catch(SuperCsvException e) {

                throw e;

            }
        }

        if(rowException.isNotEmptyColumnErrors()) {
            throw rowException;
        }

    }

    /**
     * Beanの各フィールドに対して値を設定する。
     * @param resultBean
     * @param nameMapping
     * @param bindingErrors
     */
    protected void populateBean(final T resultBean, final String[] nameMapping, final CsvBindingErrors bindingErrors) {

        // map each column to its associated field on the bean
        for( int i = 0; i < nameMapping.length; i++ ) {
            final String fieldName = nameMapping[i];
            final Object fieldValue = processedColumns.get(i);

            // don't call a set-method in the bean if there is no name mapping for the column or no result to store
            if( fieldName == null || fieldValue == null || bindingErrors.hasFieldErrors(fieldName)) {
                continue;
            }

            // invoke the setter on the bean
            final Method setMethod = cache.getSetMethod(resultBean, fieldName, fieldValue.getClass());
            try {
                setMethod.invoke(resultBean, fieldValue);

            } catch(final Exception e) {
                throw new SuperCsvReflectionException(String.format("error invoking method %s()", setMethod.getName()), e);
            }

        }

    }

    /**
     * Beanのマッピング情報をキャッシュするクラスを取得します。
     * @return Beanのマッピング情報をキャッシュするクラス
     */
    protected BeanMappingCache<T> getBeanMappingCache() {
        return beanMappingCache;
    }

    /**
     * Beanのマッピング情報をキャッシュするクラスを設定します。
     * @param beanMappingCache Beanのマッピング情報をキャッシュするクラス
     */
    protected void setBeanMappingCache(BeanMappingCache<T> beanMappingCache) {
        this.beanMappingCache = beanMappingCache;
    }

    /**
     * Beanクラスを元に作成したヘッダー情報を取得する。
     * @return ヘッダー一覧。
     */
    public String[] getDefinedHeader() {
        return beanMappingCache.getHeader();
    }

    /**
     * Beanのマッピング情報を取得します。
     * @return Beanのマッピング情報
     */
    public BeanMapping<T> getBeanMapping() {
        return beanMappingCache.getOriginal();
    }

    /**
     * エラーメッセージを取得します。
     * @return 処理中に発生した例外をメッセージに変換した
     */
    public List<String> getErrorMessages() {
        return errorMessages;
    }

    /**
     * 処理中に発生した例外をメッセージに変換するクラスを取得します。
     * @return
     */
    public CsvExceptionConverter getExceptionConverter() {
        return exceptionConverter;
    }

    /**
     * 処理中に発生した例外をメッセージに変換するクラスを設定します。
     * @param exceptionConverter 独自にカスタマイズした値を設定します。
     */
    public void setExceptionConverter(CsvExceptionConverter exceptionConverter) {
        this.exceptionConverter = exceptionConverter;
    }

    /**
     * レコードの値を検証するValidatorを追加します。
     * @param validators {@link CsvValidator}の実装クラスを設定します。
     */
    @SuppressWarnings("unchecked")
    public void addValidator(CsvValidator<T>... validators) {
        this.validators.addAll(Arrays.asList(validators));
    }

    /**
     * レコードの値を検証するValidatorを取得します。
     * @return {@link CsvValidator}の実装クラスを設定します。
     */
    public List<CsvValidator<T>> getValidators() {
        return validators;
    }

}