Coverage report

  %line %branch
org.apache.commons.validator.routines.AbstractNumberValidator
95% 
98% 

 1   
 /*
 2   
  * $Id: AbstractNumberValidator.java 386637 2006-03-17 13:22:26Z niallp $
 3   
  * $Revision: 386637 $
 4   
  * $Date: 2006-03-17 13:22:26 +0000 (Fri, 17 Mar 2006) $
 5   
  *
 6   
  * ====================================================================
 7   
  * Copyright 2006 The Apache Software Foundation
 8   
  *
 9   
  * Licensed under the Apache License, Version 2.0 (the "License");
 10   
  * you may not use this file except in compliance with the License.
 11   
  * You may obtain a copy of the License at
 12   
  *
 13   
  *     http://www.apache.org/licenses/LICENSE-2.0
 14   
  *
 15   
  * Unless required by applicable law or agreed to in writing, software
 16   
  * distributed under the License is distributed on an "AS IS" BASIS,
 17   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 18   
  * See the License for the specific language governing permissions and
 19   
  * limitations under the License.
 20   
  */
 21   
 package org.apache.commons.validator.routines;
 22   
 
 23   
 import java.text.DecimalFormatSymbols;
 24   
 import java.text.Format;
 25   
 import java.text.NumberFormat;
 26   
 import java.text.DecimalFormat;
 27   
 import java.util.Locale;
 28   
 
 29   
 /**
 30   
  * <p>Abstract class for Number Validation.</p>
 31   
  *
 32   
  * <p>This is a <i>base</i> class for building Number
 33   
  *    Validators using format parsing.</p>
 34   
  *
 35   
  * @version $Revision: 386637 $ $Date: 2006-03-17 13:22:26 +0000 (Fri, 17 Mar 2006) $
 36   
  * @since Validator 1.3.0
 37   
  */
 38   
 public abstract class AbstractNumberValidator extends AbstractFormatValidator {
 39   
 
 40   
     /** Standard <code>NumberFormat</code> type */
 41   
     public static final int STANDARD_FORMAT = 0;
 42   
 
 43   
     /** Currency <code>NumberFormat</code> type */
 44   
     public static final int CURRENCY_FORMAT = 1;
 45   
 
 46   
     /** Percent <code>NumberFormat</code> type */
 47   
     public static final int PERCENT_FORMAT  = 2;
 48   
 
 49   
     private boolean allowFractions;
 50   
     private int     formatType;
 51   
 
 52   
     /**
 53   
      * Construct an instance with specified <i>strict</i>
 54   
      * and <i>decimal</i> parameters.
 55   
      *
 56   
      * @param strict <code>true</code> if strict
 57   
      *        <code>Format</code> parsing should be used.
 58   
      * @param formatType The <code>NumberFormat</code> type to
 59   
      *        create for validation, default is STANDARD_FORMAT.
 60   
      * @param allowFractions <code>true</code> if fractions are
 61   
      *        allowed or <code>false</code> if integers only.
 62   
      */
 63   
     public AbstractNumberValidator(boolean strict, int formatType, class="keyword">boolean allowFractions) {
 64  196 
         super(strict);
 65  196 
         this.allowFractions = allowFractions;
 66  196 
         this.formatType = formatType;
 67  196 
     }
 68   
 
 69   
     /**
 70   
      * <p>Indicates whether the number being validated is
 71   
      *    a decimal or integer.</p>
 72   
      *
 73   
      * @return <code>true</code> if decimals are allowed
 74   
      *       or <code>false</code> if the number is an integer.
 75   
      */
 76   
     public boolean isAllowFractions() {
 77  737 
         return allowFractions;
 78   
     }
 79   
 
 80   
     /**
 81   
      * <p>Indicates the type of <code>NumberFormat</code> created
 82   
      *    by this validator instance.</p>
 83   
      *
 84   
      * @return the format type created.
 85   
      */
 86   
     public int getFormatType() {
 87  20 
         return formatType;
 88   
     }
 89   
 
 90   
     /**
 91   
      * <p>Validate using the specified <code>Locale</code>.</p>
 92   
      *
 93   
      * @param value The value validation is being performed on.
 94   
      * @param pattern The pattern used to validate the value against, or the
 95   
      *        default for the <code>Locale</code> if <code>null</code>.
 96   
      * @param locale The locale to use for the date format, system default if null.
 97   
      * @return <code>true</code> if the value is valid.
 98   
      */
 99   
     public boolean isValid(String value, String pattern, Locale locale) {
 100  388 
         Object parsedValue = parse(value, pattern, locale);
 101  388 
         return (parsedValue == null ? false : true);
 102   
     }
 103   
 
 104   
     /**
 105   
      * Check if the value is within a specified range.
 106   
      *
 107   
      * @param value The value validation is being performed on.
 108   
      * @param min The minimum value of the range.
 109   
      * @param max The maximum value of the range.
 110   
      * @return <code>true</code> if the value is within the
 111   
      *         specified range.
 112   
      */
 113   
     public boolean isInRange(Number value, Number min, Number max) {
 114  40 
         return (minValue(value, min) && maxValue(value, max));
 115   
     }
 116   
 
 117   
     /**
 118   
      * Check if the value is greater than or equal to a minimum.
 119   
      *
 120   
      * @param value The value validation is being performed on.
 121   
      * @param min The minimum value.
 122   
      * @return <code>true</code> if the value is greater than
 123   
      *         or equal to the minimum.
 124   
      */
 125   
     public boolean minValue(Number value, Number min) {
 126  64 
         if (isAllowFractions()) {
 127  24 
             return (value.doubleValue() >= min.doubleValue());
 128   
         } else {
 129  40 
             return (value.longValue() >= min.longValue());
 130   
         }
 131   
     }
 132   
 
 133   
     /**
 134   
      * Check if the value is less than or equal to a maximum.
 135   
      *
 136   
      * @param value The value validation is being performed on.
 137   
      * @param max The maximum value.
 138   
      * @return <code>true</code> if the value is less than
 139   
      *         or equal to the maximum.
 140   
      */
 141   
     public boolean maxValue(Number value, Number max) {
 142  56 
         if (isAllowFractions()) {
 143  21 
             return (value.doubleValue() <= max.doubleValue());
 144   
         } else {
 145  35 
             return (value.longValue() <= max.longValue());
 146   
         }
 147   
     }
 148   
 
 149   
     /**
 150   
      * <p>Parse the value using the specified pattern.</p>
 151   
      *
 152   
      * @param value The value validation is being performed on.
 153   
      * @param pattern The pattern used to validate the value against, or the
 154   
      *        default for the <code>Locale</code> if <code>null</code>.
 155   
      * @param locale The locale to use for the date format, system default if null.
 156   
      * @return The parsed value if valid or <code>null</code> if invalid.
 157   
      */
 158   
     protected Object parse(String value, String pattern, Locale locale) {
 159   
 
 160  903 
         value = (value == null ? class="keyword">null : value.trim());
 161  903 
         if (value == null || value.length() == 0) {
 162  136 
             return null;
 163   
         }
 164  767 
         Format formatter = getFormat(pattern, locale);
 165  767 
         return parse(value, formatter);
 166   
 
 167   
     }
 168   
 
 169   
     /**
 170   
      * <p>Process the parsed value, performing any further validation
 171   
      *    and type conversion required.</p>
 172   
      *
 173   
      * @param value The parsed object created.
 174   
      * @param formatter The Format used to parse the value with.
 175   
      * @return The parsed value converted to the appropriate type
 176   
      *         if valid or <code>null</code> if invalid.
 177   
      */
 178   
     protected abstract Object processParsedValue(Object value, Format formatter);
 179   
 
 180   
     /**
 181   
      * <p>Returns a <code>NumberFormat</code> for the specified <i>pattern</i>
 182   
      *    and/or <code>Locale</code>.</p>
 183   
      *
 184   
      * @param pattern The pattern used to validate the value against or
 185   
      *        <code>null</code> to use the default for the <code>Locale</code>.
 186   
      * @param locale The locale to use for the currency format, system default if null.
 187   
      * @return The <code>NumberFormat</code> to created.
 188   
      */
 189   
     protected Format getFormat(String pattern, Locale locale) {
 190   
 
 191  791 
         NumberFormat formatter = null;
 192  791 
         boolean usePattern = (pattern != null && pattern.length() > 0);
 193  791 
         if (!usePattern) {
 194  407 
             formatter = (NumberFormat)getFormat(locale);
 195  384 
         } else if (locale == null) {
 196  347 
             formatter =  new DecimalFormat(pattern);
 197   
         } else {
 198  37 
             DecimalFormatSymbols symbols = new DecimalFormatSymbols(locale);
 199  37 
             formatter = new DecimalFormat(pattern, symbols);
 200   
         }
 201   
 
 202  791 
         if (determineScale(formatter) == 0) {
 203  355 
             formatter.setParseIntegerOnly(true);
 204   
         }
 205  791 
         return formatter;
 206   
     }
 207   
 
 208   
     /**
 209   
      * <p>Returns the <i>multiplier</i> of the <code>NumberFormat</code>.</p>
 210   
      *
 211   
      * @param format The <code>NumberFormat</code> to determine the
 212   
      *        multiplier of.
 213   
      * @return The multiplying factor for the format..
 214   
      */
 215   
     protected int determineScale(NumberFormat format) {
 216  877 
         if (!isStrict()) {
 217  260 
             return -1;
 218   
         }
 219  617 
         if (!isAllowFractions() || format.isParseIntegerOnly()) {
 220  323 
             return 0;
 221   
         }
 222  294 
         int minimumFraction = format.getMinimumFractionDigits();
 223  294 
         int maximumFraction = format.getMaximumFractionDigits();
 224  294 
         if (minimumFraction != maximumFraction) {
 225  175 
             return -1;
 226   
         }
 227  119 
         int scale = minimumFraction;
 228  119 
         if (format instanceof DecimalFormat) {
 229  119 
             int multiplier = ((DecimalFormat)format).getMultiplier();
 230  119 
             if (multiplier == 100) {
 231  20 
                 scale += 2;
 232  99 
             } else if (multiplier == 1000) {
 233  0 
                 scale += 3;
 234   
             }
 235  0 
         } else if (formatType == PERCENT_FORMAT) {
 236  0 
             scale += 2;
 237   
         }
 238  119 
         return scale;
 239   
     }
 240   
 
 241   
     /**
 242   
      * <p>Returns a <code>NumberFormat</code> for the specified Locale.</p>
 243   
      *
 244   
      * @param locale The locale a <code>NumberFormat</code> is required for,
 245   
      *   system default if null.
 246   
      * @return The <code>NumberFormat</code> to created.
 247   
      */
 248   
     protected Format getFormat(Locale locale) {
 249  407 
         NumberFormat formatter = null;
 250  407 
         switch (formatType) {
 251   
         case CURRENCY_FORMAT:
 252  26 
             if (locale == null) {
 253  2 
                 formatter = NumberFormat.getCurrencyInstance();
 254   
             } else {
 255  24 
                 formatter = NumberFormat.getCurrencyInstance(locale);
 256   
             }
 257  24 
             break;
 258   
         case PERCENT_FORMAT:
 259  13 
             if (locale == null) {
 260  3 
                 formatter = NumberFormat.getPercentInstance();
 261   
             } else {
 262  10 
                 formatter = NumberFormat.getPercentInstance(locale);
 263   
             }
 264  10 
             break;
 265   
         default:
 266  368 
             if (locale == null) {
 267  48 
                 formatter = NumberFormat.getInstance();
 268   
             } else {
 269  320 
                 formatter = NumberFormat.getInstance(locale);
 270   
             }
 271   
             break;
 272   
         }
 273  407 
         return formatter;
 274   
     }
 275   
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.