DateTimeRange.java

package com.github.mygreen.supercsv.cellprocessor.constraint;

import org.supercsv.cellprocessor.ift.CellProcessor;
import org.supercsv.cellprocessor.ift.DateCellProcessor;
import org.supercsv.exception.SuperCsvCellProcessorException;
import org.supercsv.util.CsvContext;

import com.github.mygreen.supercsv.cellprocessor.ValidationCellProcessor;
import com.github.mygreen.supercsv.cellprocessor.format.TextPrinter;


/**
 * 日時が指定した期間内かどうか検証するCellProcessor.
 * 
 * @version 2.0
 * @author T.TSUCHIE
 *
 */
public class DateTimeRange<T extends Comparable<T>> extends ValidationCellProcessor implements DateCellProcessor {
    
    private final T min;
    
    private final T max;
    
    private final boolean inclusive;
    
    private final TextPrinter<T> printer;
    
    public DateTimeRange(final T min, final T max, final boolean inclusive, final TextPrinter<T> printer) {
        super();
        checkPreconditions(min, max, printer);
        this.min = min;
        this.max = max;
        this.inclusive = inclusive;
        this.printer = printer;
    }
    
    public DateTimeRange(final T min, final T max, final boolean inclusive, final TextPrinter<T> printer, final CellProcessor next) {
        super(next);
        checkPreconditions(min, max, printer);
        this.min = min;
        this.max = max;
        this.inclusive = inclusive;
        this.printer = printer;
    }
    
    private static <T extends Comparable<T>> void checkPreconditions(final T min, final T max,
            final TextPrinter<T> printer) {
        if(min == null || max == null || printer == null) {
            throw new NullPointerException("min or max or printer should not be null");
        }
        
        if(min.compareTo(max) > 0) {
            throw new IllegalArgumentException(String.format("max (%s) should not be < min (%s)", max, min));
        }
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public Object execute(final Object value, final CsvContext context) {
        
        if(value == null) {
            return next.execute(value, context);
        }
        
        final Class<?> exepectedClass = getMin().getClass();
        if(!exepectedClass.isAssignableFrom(value.getClass())) {
            throw new SuperCsvCellProcessorException(exepectedClass, value, context, this);
        }
        
        final T result = (T) value;
        if(!validate(result)) {
            throw createValidationException(context)
                .messageFormat("%s does not lie between the min (%s) and maxx (%s) values (inclusive)", 
                        printValue(result), printValue(min), printValue(max))
                .rejectedValue(value)
                .messageVariables("min", getMin())
                .messageVariables("max", getMax())
                .messageVariables("inclusive", isInclusive())
                .messageVariables("printer", getPrinter())
                .build();
                
        }   
        
        return next.execute(result, context);
    }
    
    private boolean validate(final T value) {
        final int comparedMin = value.compareTo(min);
        final int comparedMax = value.compareTo(max);
        
        if(comparedMin > 0 && comparedMax < 0) {
            return true;
        }
        
        if(inclusive && (comparedMin == 0 || comparedMax == 0)) {
            return true;
        }
        
        return false;
        
    }
    
    private String printValue(final T value) {
        return getPrinter().print(value);
    }
    
    /**
     * 
     * @return 設定された未来日（最小値）を取得する。
     */
    public T getMin() {
        return min;
    }
    
    /**
     * 
     * @return 設定された過去日（最大値）を取得する。
     */
    public T getMax() {
        return max;
    }
    
    /**
     *  値を比較する際に指定した値を含むかどうか。
     * @return
     */
    public boolean isInclusive() {
        return inclusive;
    }
    
    /**
     * 
     * @return フォーマッタを取得する
     */
    public TextPrinter<T> getPrinter() {
        return printer;
    }
    
    
}