revisted the model to speed up the validation and to have a better control how much revalitaions have to be done when something changes

src/main/java/ninja/javafx/smartcsv/validation/Validator.java

@@ -26,18 +26,10 @@
 
 package ninja.javafx.smartcsv.validation;
 
-import groovy.lang.Binding;
-import groovy.lang.GroovyShell;
-import groovy.lang.Script;
-import org.codehaus.groovy.control.CompilationFailedException;
-
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import static java.util.stream.Collectors.joining;
-import static org.apache.commons.validator.GenericValidator.*;
-
 /**
  * This class checks all the validations defined in the
  * Config against a given value
@@ -49,7 +41,7 @@ public class Validator {
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     private ValidationConfiguration validationConfig;
-    private ColumnValidations columnValidations = new ColumnValidations();
+    private Map<String, Map<Validation.Type, Validation>> columnValidationMap = new HashMap<>();
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     // constructors
@@ -57,10 +49,11 @@ public class Validator {
 
     /**
      * JSON configuration for this validator
+     *
      * @param validationConfig
      */
     public Validator(ValidationConfiguration validationConfig) {
-         this.validationConfig = validationConfig;
+        this.validationConfig = validationConfig;
         initColumnValidations();
     }
 
@@ -69,16 +62,40 @@ public class Validator {
     // public methods
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    public boolean needsColumnValidation(String column) {
+        Map<Validation.Type, Validation> validationMap = columnValidationMap.get(column);
+        if (validationMap != null) {
+            return validationMap.containsKey(Validation.Type.UNIQUE);
+        }
+        return false;
+
+    }
+
+
     /**
      * checks if the value is valid for the column configuration
+     *
      * @param column the column name
-     * @param value the value to check
+     * @param value  the value to check
      * @return ValidationError with information if valid and if not which getMessage happened
      */
-    public ValidationError isValid(Integer lineNumber, String column, String value) {
+    public ValidationError isValid(Integer row, String column, String value) {
         ValidationError result = null;
         if (hasConfig()) {
-            ValidationError error = columnValidations.isValid(lineNumber, column, value);
+            ValidationError error = ValidationError.withLineNumber(row);
+            Map<Validation.Type, Validation> validationMap = columnValidationMap.get(column);
+            if (validationMap != null) {
+                for (Validation validation: validationMap.values()) {
+
+                    if (validation.getType() == Validation.Type.NOT_EMPTY) {
+                        validation.check(row, value, error);
+                    } else {
+                        if (value != null && !value.isEmpty()) {
+                            validation.check(row, value, error);
+                        }
+                    }
+                }
+            }
             if (!error.isEmpty()) {
                 result = error;
             }
@@ -91,68 +108,93 @@ public class Validator {
         return validationConfig != null;
     }
 
+    public void reinitializeColumn(String column) {
+        clear(column);
+        initializeColumnWithRules(column);
+    }
+
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     // private methods
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    private void add(String column, Validation validation) {
+        Map<Validation.Type, Validation> validationMap = columnValidationMap.get(column);
+        if (validationMap == null) {
+            validationMap = new HashMap<>();
+            columnValidationMap.put(column, validationMap);
+        }
+        validationMap.put(validation.getType(), validation);
+    }
+
+    private void clear(String column) {
+        Map<Validation.Type, Validation> validationMap = columnValidationMap.get(column);
+        if (validationMap != null) {
+            validationMap.clear();
+        }
+    }
+
     private void initColumnValidations() {
         if (hasConfig()) {
-        String[] columns = validationConfig.headerNames();
-        for(String column: columns) {
-            Boolean alphaNumeric = validationConfig.getAlphanumericRuleFor(column);
-            if (alphaNumeric != null && alphaNumeric) {
-                columnValidations.add(column, new AlphaNumericValidation());
-            }
-
-            Boolean doubleRule = validationConfig.getDoubleRuleFor(column);
-            if (doubleRule != null && doubleRule) {
-                columnValidations.add(column, new DoubleValidation());
-            }
-
-            Boolean integerRule = validationConfig.getIntegerRuleFor(column);
-            if (integerRule != null && integerRule) {
-                columnValidations.add(column, new IntegerValidation());
-            }
-
-            Boolean notEmptyRule = validationConfig.getNotEmptyRuleFor(column);
-            if (notEmptyRule != null && notEmptyRule) {
-                columnValidations.add(column, new NotEmptyValidation());
-            }
-
-            Boolean uniqueRule = validationConfig.getUniqueRuleFor(column);
-            if (uniqueRule != null && uniqueRule) {
-                columnValidations.add(column, new UniqueValidation());
-            }
-
-            String dateRule = validationConfig.getDateRuleFor(column);
-            if (dateRule != null && !dateRule.trim().isEmpty()) {
-                columnValidations.add(column, new DateValidation(dateRule));
-            }
-
-            Integer minLength = validationConfig.getMinLengthRuleFor(column);
-            if (minLength != null) {
-                columnValidations.add(column, new MinLengthValidation(minLength));
-            }
-
-            Integer maxLength = validationConfig.getMaxLengthRuleFor(column);
-            if (maxLength != null) {
-                columnValidations.add(column, new MaxLengthValidation(maxLength));
-            }
-
-            String regexp = validationConfig.getRegexpRuleFor(column);
-            if (regexp != null && !regexp.trim().isEmpty()) {
-                columnValidations.add(column, new RegExpValidation(regexp));
-            }
-
-            String groovy = validationConfig.getGroovyRuleFor(column);
-            if (groovy != null && !groovy.trim().isEmpty()) {
-                columnValidations.add(column, new GroovyValidation(groovy));
-            }
-            List<String> valueOfRule = validationConfig.getValueOfRuleFor(column);
-            if (valueOfRule != null && !valueOfRule.isEmpty()) {
-                columnValidations.add(column, new ValueOfValidation(valueOfRule));
+            String[] columns = validationConfig.headerNames();
+            for (String column : columns) {
+                initializeColumnWithRules(column);
             }
         }
+    }
+
+    private void initializeColumnWithRules(String column) {
+        Boolean alphaNumeric = validationConfig.getAlphanumericRuleFor(column);
+        if (alphaNumeric != null && alphaNumeric) {
+            add(column, new AlphaNumericValidation());
+        }
+
+        Boolean doubleRule = validationConfig.getDoubleRuleFor(column);
+        if (doubleRule != null && doubleRule) {
+            add(column, new DoubleValidation());
+        }
+
+        Boolean integerRule = validationConfig.getIntegerRuleFor(column);
+        if (integerRule != null && integerRule) {
+            add(column, new IntegerValidation());
+        }
+
+        Boolean notEmptyRule = validationConfig.getNotEmptyRuleFor(column);
+        if (notEmptyRule != null && notEmptyRule) {
+            add(column, new NotEmptyValidation());
+        }
+
+        Boolean uniqueRule = validationConfig.getUniqueRuleFor(column);
+        if (uniqueRule != null && uniqueRule) {
+            add(column, new UniqueValidation());
+        }
+
+        String dateRule = validationConfig.getDateRuleFor(column);
+        if (dateRule != null && !dateRule.trim().isEmpty()) {
+            add(column, new DateValidation(dateRule));
+        }
+
+        Integer minLength = validationConfig.getMinLengthRuleFor(column);
+        if (minLength != null) {
+            add(column, new MinLengthValidation(minLength));
+        }
+
+        Integer maxLength = validationConfig.getMaxLengthRuleFor(column);
+        if (maxLength != null) {
+            add(column, new MaxLengthValidation(maxLength));
+        }
+
+        String regexp = validationConfig.getRegexpRuleFor(column);
+        if (regexp != null && !regexp.trim().isEmpty()) {
+            add(column, new RegExpValidation(regexp));
+        }
+
+        String groovy = validationConfig.getGroovyRuleFor(column);
+        if (groovy != null && !groovy.trim().isEmpty()) {
+            add(column, new GroovyValidation(groovy));
+        }
+        List<String> valueOfRule = validationConfig.getValueOfRuleFor(column);
+        if (valueOfRule != null && !valueOfRule.isEmpty()) {
+            add(column, new ValueOfValidation(valueOfRule));
         }
     }
 
@@ -171,7 +213,7 @@ public class Validator {
 
                 ValidationError error = ValidationError.withoutLineNumber();
 
-                for(int i=0; i<headerNamesConfig.length; i++) {
+                for (int i = 0; i < headerNamesConfig.length; i++) {
                     if (!headerNamesConfig[i].equals(headerNames[i])) {
                         error.add("validation.message.header.match",
                                 Integer.toString(i),