package net.sourceforge.argval.impl;
   
   
   import java.io.File;
   import java.net.MalformedURLException;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.net.URL;
   import java.text.DateFormat;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  import java.util.Set;
  
  import net.sourceforge.argval.ArgumentValidation;
  import net.sourceforge.argval.lang.SystemConstants;
  import net.sourceforge.argval.utils.StringUtil;
  
  import org.apache.oro.text.regex.MalformedPatternException;
  import org.apache.oro.text.regex.Pattern;
  import org.apache.oro.text.regex.PatternCompiler;
  import org.apache.oro.text.regex.PatternMatcher;
  import org.apache.oro.text.regex.Perl5Compiler;
  import org.apache.oro.text.regex.Perl5Matcher;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  /**
   * The class for validating arguments of (public) methods and constructors (precondition checking).
   * For each argument that does not fulfill the required 
   * conditions, a message is added. These messages are used to create an <code>IllegalArgumentException</code> 
   * before the real work of the method / constructor should be started.
   *
   * <a  name="exampleSimple">
   * <h4>A simple example without pattern matching</h4>
   * </a>
   * <p>
   * First the incoming Strings are polished, which in fact means that they are trimmed (str.trim()) and when only a 
   * empty string remains it's changed into <code>null</code>.
   * 
   * <iframe  src="{@docRoot}/example/net/sourceforge/argval/example/ValidationDataSourceVersion.html" 
   *   width="100%"  height="400">
   * 
   * <pre>
   *   public ValidationDataSourceVersion(DataSource dataSource, String sqlQuery, String columnName, String version) {
   *       // First polish the incoming String instances.
   *       sqlQuery = ArgumentValidation.polish(sqlQuery);
   *       version = ArgumentValidation.polish(version);
   *       columnName = ArgumentValidation.polish(columnName);
  
   *       // Create the ArgumentValidation instance. 
   *       ArgumentValidation argVal = new ArgumentValidation();
   *       
   *       // Check the conditions.
   *       argVal.isValidWhenNotNull("dataSource", dataSource);
   *       argVal.isValidWhenNotNull("sqlQuery", sqlQuery);
   *       argVal.isValidWhenNotNull("version", version);
   *       argVal.isValidWhenNotNull("columnName", columnName);
   *       
   *       // Create an IllegalArgumentException if not all argument conditions are met.
   *       if (argVal.containsIllegalArgument()) throw argVal.createIllegalArgumentException();
   *   
   *       // Doing the real work for this method
   *       .....
   *   }
   * </pre>
   * </iframe>
   * 
   * There are several methods <code>isValidXxxx</code>, which can be used to validate all kinds of conditions. 
   * </p>
   *
   * 
   * <a  name="examplePatternSet">
   * <h4>An example with pattern matching and set matching</h4>
   * </a>
   * <pre>
   * public class Address {
   *     private final static String PATTERN_DUTCH_POSTALCODE = "dutch_postalcode";
   *     
   *     private static Map patternMap;
   *     private static Set countrySet;
   *     
   *     static {
   *         patternMap = new HashMap();
   *         patternMap.put(PATTERN_DUTCH_POSTALCODE, "^[0-9]{4}[ ]?[A-Z]{2}$");
   *     
   *         countrySet = new HashSet();
   *         countrySet.add("The Netherlands");
   *     }
   *     
   * public Address(String street, Integer houseNumber, String postbox, String postalCode, String city, String country) {
   *     street = ArgumentValidation.polish(street);
  *     postalCode = ArgumentValidation.polish(postalCode);
  *     city = ArgumentValidation.polish(city);
  *     country = ArgumentValidation.polish(country);
  *     
  *     ArgumentValidation argVal = new ArgumentValidation(patternMap);
  *         if (argVal.isValidWhenNotNull("street", street)) {
  *             argVal.isValidWhenGreaterThen("houseNumber", houseNumber.intValue(), 0);
  *     	
  *         if (postalCode != null) {
  *             argVal.addError("When argument 'street' is given, no value for argument 'postbox' is expected.");
  *         }
  *     }
  *     else if (argVal.isValidWhenNotNull("postbox", postbox)) {
  *         if (argVal.isValidWhenNotNull("street", street)
  *                 || argVal.isValidWhenGreaterThen("houseNumber", houseNumber.intValue(), 0)) {
  *             argVal.addError("When argument 'postbox' is given, no values for argument 'street' and 'houseNumber' are expected.");
  *         }
  *     }
  *     argVal.isValidMatchingPattern("postalCode", postalCode, PATTERN_DUTCH_POSTALCODE);
  *     argVal.isValidWhenNotNull("city", city);
  *     argVal.isValidWhenInSet("country", country, countrySet);
  *     if (argVal.containsIllegalArgument()) throw argVal.createIllegalArgumentException();
  *     
  *     }
  *     
  * }
  * </pre>
  * 
  * 
  * <a  name="examplePattern">
  * <h4>An example with pattern matching, patterns added through a Properties instance</h4>
  * </a>
  * <p>
  * <pre>
  *   private final static String PATTERN_NUMBER = "number";
  *   private final static String PATTERN_DUTCH_POSTALCODE = "dutch_postalcode";
  * 
  *   private static Properties properties;
  *   
  *   // Inside the constructor (or static initialization) create a (static) Properties instance, or inject it!
  *   public Constructor() {
  *       // Creating a Properties instance, with two pattern names {'number', postalcode'}.
  *       // Add for each pattern name a regular expression. As property file it should look like:
  *       // argument_validation.patterns = number postalcode 
  *       // argument_validation.number.regexp = ^[0-9]+$
  *       // argument_validation.postalcode.regexp = ^[0-9]{4}[ ]?[A-Z]{2}$
  *       properties = new Properties();
  *       properties.setProperty(ConfigurationManager.PROP_ARG_VAL_PATTERNS, PATTERN_NUMBER + " " + PATTERN_DUTCH_POSTALCODE);
  *       properties.setProperty(PropertiesUtil.createKey(
  *    		   ConfigurationManager.PROP_ARG_VAL, PATTERN_NUMBER, ConfigurationManager.PROP_POSTFIX_REG_EXP), "^[0-9]+$");
  *       properties.setProperty(PropertiesUtil.createKey(
  *    		   ConfigurationManager.PROP_ARG_VAL, PATTERN_DUTCH_POSTALCODE, ConfigurationManager.PROP_POSTFIX_REG_EXP), "^[0-9]{4}[ ]?[A-Z]{2}$");
  *   }
  *   
  *   
  *   public void doSomething(String number, String postalcode) {
  *       postalcode = ArgumentValidation.polishToUpper(postalcode);     
  *       ArgumentValidation argVal = new ArgumentValidation(properties);
  *       
  *       // Check the conditions by using regular expressions
  *       argVal.isValidMatchingPattern("number", number, PATTERN_NUMBER);
  *       argVal.isValidMatchingPattern("postalcode", postalcode, PATTERN_DUTCH_POSTALCODE);
  *       
  *       // Create an IllegalArgumentException if not all argument conditions are met.
  *       if (argVal.containsIllegalArgument()) throw argVal.createIllegalArgumentException();
  *       
  *       // Doing the real work for this method
  *       .....
  *   }
  * </pre>
  * </p>
  * <p>
  * The patterns can also be added through a properties file. Each pattern must have a name, through which the 
  * method <code>isValidMatchingPattern(&lt;arg as string&gt;, &lt;arg&gt;, &lt;pattern name&gt;)</code> will 
  * access the regular expression. Each pattern name has to be named under the key 
  * <code>argument_validation.patterns</code>. To assign each pattern name a regular expression, the key
  * combination of <code>argument_validation.&lt;pattern name&gt;.regexp</code> is used. 
  * <pre>
  * argument_validation.patterns = number postalcode 
  * argument_validation.number.regexp = ^[0-9]+$
  * argument_validation.postalcode.regexp = ^[0-9]{4}[ ]?[A-Z]{2}$
  * </pre>
  * </p>
  * 
  * @author T. Verhagen
  */
 public class ArgumentValidationImpl implements ArgumentValidation {
     /** The logging instance. */
     transient static Logger logger = LoggerFactory.getLogger(ArgumentValidationImpl.class);
 
     /** The line separator. */
     private final static String SEPARATOR = System.getProperty(SystemConstants.LINE_SEPARATOR);
     /** This list contains the messages about the conditions that are not satisfied. */
     private List<String> errorList;
     
     private Map<String, DateFormat> dateFormatMap;
     /** This map contains the pattern names and their related regular expressions, which are 
      * used by the validations with regularExpressions. */
     private Map<String, Pattern> patternMap;
     ///** The regular expression pattern compiler. */
     //private PatternCompiler compiler;
     /** The regular expression pattern matcher. */
     private PatternMatcher matcher;
     
     private String validationTypeName = ArgumentValidation.VALIDATION_TYPE_NAME_ARGUMENT;
 
     /** The default constructor. */
     public ArgumentValidationImpl() {
     	this((String)null);
     }
     /** The default constructor. */
     public ArgumentValidationImpl(String validationTypeName) {
         super();
     	validationTypeName = polish(validationTypeName);
     	
     	if (validationTypeName != null) {
     		this.validationTypeName = validationTypeName;
     	}
     	else {
     		this.validationTypeName = ArgumentValidation.VALIDATION_TYPE_NAME_ARGUMENT; 
     	}
         errorList = new ArrayList<String>();
         dateFormatMap = new HashMap<String, DateFormat>();
         patternMap = new HashMap<String, Pattern>();
     }
     /**
      * Construct an <code>ArgumentValidation</code> instance, which can also validate 
      * against regular expressions. It will use the <code>org.apache.oro.text.regex.Perl5Compiler</code> 
      * and <code>org.apache.oro.text.regex.Perl5Matcher</code>. See for detailed information on 
      * <a  href="http://jakarta.apache.org/oro/api/org/apache/oro/text/regex/package-summary.html#package_description}">
      * creating regular expressions</a> the package description.
      * 
      * @param  patternMap  A <code>Map</code> instance, containing pattern names and their regular expressions.
      */
     public ArgumentValidationImpl(Map<String, String> patternMap) {
         this(patternMap, new Perl5Compiler(), new Perl5Matcher());
     }
     public ArgumentValidationImpl(Map<String, String> patternMap, String validationTypeName) {
         this(patternMap, new Perl5Compiler(), new Perl5Matcher(), validationTypeName);
     }
     // TODO
     public ArgumentValidationImpl(Map<String, String> patternMap, Map<String, String> dateFormatMap) {
         this(patternMap, new Perl5Compiler(), new Perl5Matcher(), dateFormatMap);
     }
     public ArgumentValidationImpl(Map<String, String> patternMap, Map<String, String> dateFormatMap, String validationTypeName) {
         this(patternMap, new Perl5Compiler(), new Perl5Matcher(), dateFormatMap, validationTypeName);
     }
     /**
      * Construct an <code>ArgumentValidation</code> instance, which can also validate 
      * against regular expressions. It will use the <code>org.apache.oro.text.regex.Perl5Compiler</code> 
      * and <code>org.apache.oro.text.regex.Perl5Matcher</code>. See for detailed information on 
      * <a  href="http://jakarta.apache.org/oro/api/org/apache/oro/text/regex/package-summary.html#package_description}">
      * creating regular expressions</a> the package description.
      * 
      * @param  properties  A properties instance, containing pattern names and their regular expressions.
      * /
     public ArgumentValidation(Properties properties) {
         this(properties, new Perl5Compiler(), new Perl5Matcher());
     }//*/
     /**
      * Construct an <code>ArgumentValidation</code> instance, which can also validate 
      * against regular expressions. See for detailed information on 
      * <a  href="http://jakarta.apache.org/oro/api/org/apache/oro/text/regex/package-summary.html#package_description}">
      * creating regular expressions</a> the package description.  
      *  
      * @param  patternMap  A <code>Map</code> instance, containing pattern names and their regular expressions.
      * @param  compiler  A <code>org.apache.oro.text.regex.PatternCompiler</code> compiler.
      * @param  matcher  A <code>org.apache.oro.text.regex.PatternMatcher</code> matcher.
      */
     public ArgumentValidationImpl(Map<String, String> patternMap, PatternCompiler compiler, PatternMatcher matcher) {
         this(patternMap, compiler, matcher, new HashMap<String, String>());
     }
     public ArgumentValidationImpl(Map<String, String> patternMap, PatternCompiler compiler, PatternMatcher matcher,
     		String validationTypeName) {
         this(patternMap, compiler, matcher, new HashMap<String, String>(), validationTypeName);
     }
     // TODO [2007.07.18 tv] Add javadoc.
     public ArgumentValidationImpl(Map<String, String> patternMap, 
             PatternCompiler compiler, PatternMatcher matcher, Map<String, String> dateFormatMap) {
     	this(patternMap, compiler, matcher, dateFormatMap, null);
     }
     /**
      * 
      * @param patternMap
      * @param compiler
      * @param matcher
      * @param dateFormatMap
      * @param validationTypeName - The type of validation (default 'Argument'), but use this
      *                             for checking other type of things like 'Property-key's.
      */
     public ArgumentValidationImpl(Map<String, String> patternMap, 
             PatternCompiler compiler, PatternMatcher matcher, Map<String, String> dateFormatMap,
             String validationTypeName) {
         this();
         if (patternMap == null) {
             throw new IllegalArgumentException("Argument 'patternMap' should not be null.");
         }
         if (compiler == null) {
             throw new IllegalArgumentException("Argument 'compiler' should not be null.");
         }
         if (matcher == null) {
             throw new IllegalArgumentException("Argument 'matcher' should not be null.");
         }
         if (dateFormatMap == null) {
             throw new IllegalArgumentException("Argument 'dateFormatMap' should not be null.");
         }
         
         validationTypeName = polish(validationTypeName);
         if (validationTypeName == null) {
         	validationTypeName = ArgumentValidation.VALIDATION_TYPE_NAME_ARGUMENT;
         }
         
         //this.compiler = compiler;
         this.matcher = matcher;
 
         for (Iterator<String> iter = patternMap.keySet().iterator(); iter.hasNext();) {
             String patternName = (String)iter.next();
             String regExpStr = (String)patternMap.get(patternName);
             try {
                 Pattern pattern = compiler.compile(regExpStr);
                 this.patternMap.put(patternName, pattern);
                 logger.debug("Created Pattern instance '" + patternName + "' with reg exp '" + regExpStr + "'.");
             }
             catch (MalformedPatternException mpe) {
                 logger.error("The pattern '" + patternName + "' with regular expression '" + regExpStr + "' is not correct.", mpe);
             }
         }
         
         for (Iterator<String> iter = dateFormatMap.keySet().iterator(); iter.hasNext();) {
             String dateFormatName = (String)iter.next();
             String datePattern = (String)dateFormatMap.get(dateFormatName);
             try {
                 DateFormat dateFormat = new SimpleDateFormat(datePattern);
                 this.dateFormatMap.put(dateFormatName, dateFormat);
                 logger.debug("Created DateFormat instance '" + dateFormatName + "' with simple date pattern '" + datePattern + "'.");
             }
             catch (NullPointerException npe) {
                 logger.error("The date format name '" + dateFormatName + "' with simple date pattern '" + datePattern + "' is not correct.", npe);
             }
             catch (IllegalArgumentException iae) {
                 logger.error("The date format name '" + dateFormatName + "' with simple date pattern '" + datePattern + "' is not correct.", iae);
             }
         }
     }
     /**
      * TODO [2007.07.18 tv] update with date pattern
      * Construct an <code>ArgumentValidation</code> instance, which can also validate 
      * against regular expressions. See for detailed information on 
      * <a  href="http://jakarta.apache.org/oro/api/org/apache/oro/text/regex/package-summary.html#package_description}">
      * creating regular expressions</a> the package description.  
      *  
      * @param  properties  A properties instance, containing pattern names and their regular expressions.
      * @param  compiler  A <code>org.apache.oro.text.regex.PatternCompiler</code> compiler.
      * @param  matcher  A <code>org.apache.oro.text.regex.PatternMatcher</code> matcher.
      */
     public ArgumentValidationImpl(Properties properties, PatternCompiler compiler, PatternMatcher matcher) {
         this(new PropertiesConfigurationManager().createPatternMap(properties), compiler, matcher, new PropertiesConfigurationManager().createDateFormatMap(properties));
     }
     
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#getMessage()
      */
     public String getMessage() {
         if (errorList.size() == 0) {
             return null;
         }
         StringBuffer strBuf = new StringBuffer();
         boolean isFirst = true;
         Iterator<String> iter = errorList.iterator();
         while (iter.hasNext()) {
             strBuf.append(isFirst ? "" : SEPARATOR ).append(iter.next());
             isFirst = false;
         }
         
         return strBuf.toString();
     }
 
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#containsIllegalArgument()
      */
     public boolean containsIllegalArgument() {
         return errorList.size() > 0;
     }
 
 
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#createIllegalArgumentException()
      */
     public IllegalArgumentException createIllegalArgumentException() {
         return new IllegalArgumentException(getMessage());
     }
 
 
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidWhenNotNull(java.lang.String, java.lang.Object)
      */
     public boolean isValidWhenNotNull(String argumentName, Object argumentValue) {
         if (argumentValue == null) {
             addError(argumentName, "should not be null.");
             return false;
         }
         return true;
     }
 
     public boolean isValidWhenNotNullInCollection(String argumentName, Collection<?> argumentValue) {
         if (isValidWhenNotNull(argumentName, argumentValue)) {
             Object[] argValueArray = argumentValue.toArray(new Object[argumentValue.size()]);
             for (int index = 0; index < argValueArray.length; index++) {
                 if (argValueArray[index] == null) {
                     return false;
                 }
             }
             return true;
         }
         return false;
     }
 
     /**
      * Add an error message, for the given argumentName, to the list of error messages.
      * @param argumentName - the argument (or property-key) in which the problem is found. 
      * @param message - the message that describes the problem.
      */
     public void addError(String argumentName, String message) {
     	errorList.add(validationTypeName + " '" + argumentName + "' " + message);
 	}
 
     public void addError(String argumentName, String key, String message) {
         errorList.add(validationTypeName + " '" + argumentName + "[" + key + "]' " + message);
     }
     
 	/* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidWhenBoolean(java.lang.String, java.lang.String)
      */
     public boolean isValidWhenBoolean(String argumentName, String argumentValue) {
         if (isValidWhenNotNull(argumentName, argumentValue)) {
             if (Boolean.FALSE.toString().toLowerCase().equals(argumentValue.toLowerCase())
                     || Boolean.TRUE.toString().toLowerCase().equals(argumentValue.toLowerCase())) {
                 return true;
             }
             else {
             	addError(argumentName, "should be a boolean.");
             }
         }
         return false;
     }
 
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidWhenInteger(java.lang.String, java.lang.String)
      */
     public boolean isValidWhenInteger(String argumentName, String argumentValue) {
         try {
             Integer.parseInt(argumentValue);
         }
         catch (NumberFormatException nfe) {
         	addError(argumentName, "should be a number which can be parsed into an Integer.");
             return false;
         }
         return true;
     }
 
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidWhenLong(java.lang.String, java.lang.String)
      */
     public boolean isValidWhenLong(String argumentName, String argumentValue) {
         try {
             Long.parseLong(argumentValue);
         }
         catch (NumberFormatException nfe) {
         	addError(argumentName, "should be a number which can be parsed into a Long.");
             return false;
         }
         return true;
     }
 
 
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidWhenDirectory(java.lang.String, java.lang.String)
      */
     public boolean isValidWhenDirectory(String argumentName, String argumentValue) {
         if (! isValidWhenNotNull(argumentName, argumentValue)) {
         	return false;
         }
         return isValidWhenDirectory(argumentName, new File(argumentValue));
     }
     public boolean isValidWhenDirectory(String argumentName, File argumentValue) {
         if (! isValidWhenNotNull(argumentName, argumentValue)) {
         	return false;
         }
         if (! argumentValue.isDirectory() || ! argumentValue.exists()) {
         	addError(argumentName, "with value '" + argumentValue + "' should be an existing path.");
             return false;
         }
         return true;
     }
     
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidWhenFile(java.lang.String, java.lang.String)
      */
     public boolean isValidWhenFile(String argumentName, String argumentValue) {
         if (! isValidWhenNotNull(argumentName, argumentValue)) {
         	return false;
         }
         return isValidWhenFile(argumentName, new File(argumentValue));
     }
     public boolean isValidWhenFile(String argumentName, File argumentValue) {
         if (! isValidWhenNotNull(argumentName, argumentValue)) {
         	return false;
         }
         if (! argumentValue.isFile() || ! argumentValue.exists()) {
         	addError(argumentName, "with value '" + argumentValue + "' should be an existing file.");
             return false;
         }
         return true;
     }
 
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidWhenUrl(java.lang.String, java.lang.String)
      */
     public boolean isValidWhenUrl(String argumentName, String argumentValue) {
         try {
             new URL(argumentValue);
         } 
         catch (MalformedURLException murle) {
         	addError(argumentName, "with value '" + argumentValue + "' is not a valid url.");
             return false;
         }
         return true;
     }
     
     
     public boolean isValidWhenUri(String argumentName, String argumentValue) {
         try {
             new URI(argumentValue);
         } 
         catch (URISyntaxException urise) {
         	addError(argumentName, "with value '" + argumentValue + "' is not a valid uri.");
             return false;
 		}
         return true;
     }
     
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidWhenInSet(java.lang.String, java.lang.String, java.util.Set)
      */
     public boolean isValidWhenInSet(String argumentName, String argumentValue, Set<String> argumentSet) {
         if (isValidWhenNotNull(argumentName, argumentValue)) {
             if (! argumentSet.contains(argumentValue)) {
                 StringBuffer strBuf = new StringBuffer();
                 strBuf.append(validationTypeName).append(" '").append(argumentName).append("' with value '").append(argumentValue);
                 strBuf.append("' should contain one of the following values { ");
                 boolean isFirst = true;
                 Iterator<String> iter = argumentSet.iterator();
                 while (iter.hasNext()) {
                     strBuf.append((isFirst) ? "'" : "', '");
                     strBuf.append(iter.next().toString());
                     isFirst = false;
                 }
                 if (!isFirst) {
                     strBuf.append("'");
                 }
                 strBuf.append(" }.");
                 errorList.add(strBuf.toString());
                 return false;
             }
             return true;
         }
         return false;
     }
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidWhenNotInSet(java.lang.String, java.lang.String, java.util.Set)
      */
     public boolean isValidWhenNotInSet(String argumentName, String argumentValue, Set<String> argumentSet) {
         if (isValidWhenNotNull(argumentName, argumentValue)) {
             if (argumentSet.contains(argumentValue)) {
                 StringBuffer strBuf = new StringBuffer();
                 strBuf.append(validationTypeName).append(" '").append(argumentName).append("' with value '").append(argumentValue);
                 strBuf.append("' should not be contained by the given set.");
                 errorList.add(strBuf.toString());
                 return false;
             }
             return true;
         }
         return false;
     }
     
     
     public boolean isValidCollectionWhenNoNulls(String argumentName, Collection<?> argumentValue) {
         if (isValidWhenNotNull(argumentName, argumentValue)) {
         	if (argumentValue.size() > 0) {
         		Object[] argumentValueArray = argumentValue.toArray();
         		StringBuilder builder = new StringBuilder();
         		for (int index = 0; index < argumentValueArray.length; index++) {
         			Object element = argumentValueArray[index];
 					if (element instanceof String) {
 						String elementStr = polish((String)element);
 						if (elementStr == null) {
 	        				if (builder.length() > 0) {
 	        					builder.append(", ");
 	        				}
 	        				builder.append(index);
 						}
 					}
 					else if (element == null) {
         				if (builder.length() > 0) {
         					builder.append(", ");
         				}
         				builder.append(index);
         			}
 				}
 				if (builder.length() > 0) {
 					addError(argumentName , "is expected to have no null elements. Found null on following elements '"
 							+ builder + "'.");
 					return false;
 				}
         	}
         	return true;
         }
         return false;
     }
     
 
     public boolean isValidCollectionWhenMinElements(String argumentName, Collection<?> argumentValue, int minElements) {
         if (isValidWhenNotNull(argumentName, argumentValue)) {
         	if (argumentValue.size() < minElements) {
         		addError(argumentName, "is expected to have at least " + minElements + " element(s).");
 				return false;
         	}
         	return true;
         }
         return false;
     }
 
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidWhenGreaterThen(java.lang.String, int, int)
      */
     public boolean isValidWhenGreaterThen(String argumentName, int argumentValue, int value) {
         if (argumentValue > value) {
             return true;
         }
         StringBuffer strBuf = new StringBuffer();
         strBuf.append(validationTypeName).append(" '").append(argumentName).append("' should have at least a value of '")
                 .append(argumentValue).append("'. The given value is '")
                 .append(argumentValue).append("'.");
         errorList.add(strBuf.toString());
         return false;
     }
 
 
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidStringMinLength(java.lang.String, java.lang.String, int)
      */
     public boolean isValidStringMinLength(String argumentName, String argumentValue, int minLength) {
         if (isValidWhenNotNull(argumentName, argumentValue)) {
             if (argumentValue.length() < minLength) {
                 createErrorInLength(argumentName, argumentValue, minLength, "a minimal");
                 return false;
             }
         }
         return true;
     }
 
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidStringMaxLength(java.lang.String, java.lang.String, int)
      */
     public boolean isValidStringMaxLength(String argumentName, String argumentValue, int maxLength) {
         if (isValidWhenNotNull(argumentName, argumentValue)) {
             if (argumentValue.length() > maxLength) {
                 createErrorInLength(argumentName, argumentValue, maxLength, "a maximal");
                 return false;
             }
         }
         return true;
     }
 
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidStringLength(java.lang.String, java.lang.String, int)
      */
     public boolean isValidStringLength(String argumentName, String argumentValue, int length) {
         if (isValidWhenNotNull(argumentName, argumentValue)) {
             if (argumentValue.length() != length) {
                 createErrorInLength(argumentName, argumentValue, length, "an exact");
                 return false;
             }
         }
         return true;
     }
     
 
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidStringMinAndMaxLength(java.lang.String, java.lang.String, int, int)
      */
     public boolean isValidStringMinAndMaxLength(String argumentName, String argumentValue, int minLength, int maxLength) {
         if (isValidWhenNotNull(argumentName, argumentValue)) {
             if (argumentValue.length() < minLength) {
                 createErrorInLength(argumentName, argumentValue, minLength, "a minimal");
                 return false;
             }
             else if (argumentValue.length() > maxLength) {
                 createErrorInLength(argumentName, argumentValue, maxLength, "a maximal");
                 return false;
             }
         }
         return true;
     }
     
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidMatchingDateFormat(java.lang.String, java.lang.String, java.text.DateFormat)
      */
     public boolean isValidMatchingDateFormat(String argumentName, String argumentValue, DateFormat dateFormat) {
         if (! isValidWhenNotNull(argumentName, argumentValue)) {
             return false;
         }
         try {
             dateFormat.parse(argumentValue);
         } 
         catch (ParseException e) {
             //e.printStackTrace();
         	addError(argumentName, "with value '" + argumentValue 
                     + "' does not match the given date format pattern '" 
                     + ((dateFormat instanceof SimpleDateFormat) 
                             ? ((SimpleDateFormat)dateFormat).toPattern() : dateFormat.toString())
                     + "'.");
             return false;
         }
         
         return true;
     }
     
 
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidMatchingDateFormat(java.lang.String, java.lang.String, java.lang.String)
      */
     public boolean isValidMatchingDateFormat(String argumentName, String argumentValue, String dateFormatName) {
         if (dateFormatName != null && ! dateFormatMap.keySet().contains(dateFormatName)) {
             throw new IllegalArgumentException("There is no date format known with the name '" + dateFormatName + "'.");
         }
         DateFormat dateFormat = (DateFormat)dateFormatMap.get(dateFormatName);
         
         logger.debug((dateFormat != null) ? "Date format '" + dateFormatName + "' is available as '" 
                 + ((dateFormat instanceof SimpleDateFormat) 
                         ? ((SimpleDateFormat)dateFormat).toPattern() : dateFormat.toString()) 
                 + "'" : "No date format available.");
 
         return isValidMatchingDateFormat(argumentName, argumentValue, dateFormat);
 //        if (! isValidWhenNotNull(argumentName, argumentValue)) {
 //            return false;
 //        }
 //        try {
 //            dateFormat.parse(argumentValue);
 //        } 
 //        catch (ParseException e) {
 //            //e.printStackTrace();
 //            errorList.add("Argument '" + argumentName + "' with value '" + argumentValue 
 //                    + "' does not match the given date format pattern '" 
 //                    + ((dateFormat instanceof SimpleDateFormat) 
 //                            ? ((SimpleDateFormat)dateFormat).toPattern() : dateFormat.toString())
 //                    + "'.");
 //            return false;
 //        }
 //
 //        return true;
     }
 
 
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#isValidMatchingPattern(java.lang.String, java.lang.String, java.lang.String)
      */
     public boolean isValidMatchingPattern(String argumentName, String argumentValue, String patternName) {
         if (patternName != null && ! patternMap.keySet().contains(patternName)) {
             throw new IllegalArgumentException("There is no pattern known with the name '" + patternName + "'.");
         }
         Pattern pattern = (Pattern)patternMap.get(patternName);
         logger.debug((pattern != null) ? "Pattern '" + patternName + "' is available as '" + pattern.getPattern() + "'" : "No pattern available.");
 
         if (! isValidWhenNotNull(argumentName, argumentValue)) {
             return false;
         }
         if (! matcher.matches(argumentValue, pattern)) {
             errorList.add("Argument '" + argumentName + "' with value '" + argumentValue 
                     + "' does not match the given regular expression pattern '" 
                     + pattern.getPattern() + "'.");
             return false;
         }
         
         return true;
     }
     
     
     /**
      * Helper method for creating an error message about the length conditions for a String argument.
      *  
      * @param  argumentName  The name of the argument as it is named in the method.
      * @param  argumentValue
      * @param  theLength
      * @param  lengthConditionStr
      */
     private void createErrorInLength(String argumentName, String argumentValue, int theLength, String lengthConditionStr) {
         StringBuffer strBuf = new StringBuffer();
         strBuf.append(validationTypeName).append(" '").append(argumentName).append("' should have ").append(lengthConditionStr);
         strBuf.append(" length of '").append(theLength).append("'. The given value has a length of '");
         strBuf.append(argumentValue.length()).append("'.");
         errorList.add(strBuf.toString());
     }
     
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#addError(java.lang.String)
      */
     public void addError(String error) {
         error = ArgumentValidationImpl.polish(error);
         if (error == null) {
             return;
         }
         errorList.add(error);
     }
 
 
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#getPatternNames()
      */
     public Set<String> getPatternNames() {
         return patternMap.keySet();
     }
     
 
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#getPattern()
      */
     public Map<String, String> getPattern() {
         Map<String, String> patternMap = new HashMap<String, String>();
         for (Iterator<String> iter = this.patternMap.keySet().iterator(); iter.hasNext(); ) {
             String patternName = (String)iter.next();
             patternMap.put(patternName, ((Pattern)this.patternMap.get(patternName)).getPattern());
         }
         return patternMap;
     }
     
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#getPattern(java.lang.String)
      */
     public Pattern getPattern(String patternName) {
         if (! patternMap.containsKey(patternName)) {
             throw new IllegalArgumentException("Argument 'patternName' with the value '" 
                     + patternName + "' is not known.");
         }
         return (Pattern)patternMap.get(patternName);
     }
     
     
     /* (non-Javadoc)
      * @see net.sourceforge.argval.ArgumentValidation#getRegularExpression(java.lang.String)
      */
     public String getRegularExpression(String patternName) {
         if (! patternMap.containsKey(patternName)) {
             throw new IllegalArgumentException("Argument 'patternName' with the value '" 
                     + patternName + "' is not known.");
         }
         return ((Pattern)patternMap.get(patternName)).getPattern();
     }
     
     
     /**
      * Returns the incoming text, but stripes leading and trailing spaces and returns <code>null</code> 
      * when the (remaining) text is an empty String instance.
      * 
      * @param  text  The text to polish.
      * @return  The text without leading and trailing spaces that remains or 
      *          <code>null</code>, when no characters are left.
      */
     public static String polish(String text) {
         if (text == null) {
             return null;
         }
         text = text.trim();
         
         if (text.length() == 0) {
             return null;
         }
         return text;
     }
     /**
      * Returns the incoming text polished (see {@link #polish(String)} and converted into lower case.
      * 
      * @param  text  The text to polish and convert.
      * @return  The polished and to lower case converted text. 
      * 
      * @see #polish(String)
      */
     public static String polishToLower(String text) {
         text = ArgumentValidationImpl.polish(text);
         return text == null ? null : text.toLowerCase();
     }
     /**
      * Returns the incoming text polished (see {@link #polish(String)} and converted into upper case.
      * 
      * @param  text  The text to polish and convert.
      * @return  The polished and to upper case converted text. 
      * 
      * @see #polish(String)
      */
     public static String polishToUpper(String text) {
         text = ArgumentValidationImpl.polish(text);
         return text == null ? null : text.toUpperCase();
     }
     
     public boolean isValidNotNullForKey(String argumentName, Map<String, String> argumentValueMap, String key) {
         String value = StringUtil.polish(argumentValueMap.get(key));
         if (value == null) {
             addError(argumentName, key, "should not be null.");
             return false;
         }
         return true;
     }
 
 }