Coverage report

  %line %branch
org.apache.commons.validator.GenericTypeValidator
82% 
76% 

 1  
 /*
 2  
  * $Id: GenericTypeValidator.java 384656 2006-03-10 00:36:37Z niallp $
 3  
  * $Rev: 384656 $
 4  
  * $Date: 2006-03-10 00:36:37 +0000 (Fri, 10 Mar 2006) $
 5  
  *
 6  
  * ====================================================================
 7  
  * Copyright 2001-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;
 22  
 
 23  
 import java.io.Serializable;
 24  
 import java.util.Date;
 25  
 import java.util.Locale;
 26  
 import java.text.DateFormat;
 27  
 import java.text.SimpleDateFormat;
 28  
 import java.text.NumberFormat;
 29  
 import java.text.ParseException;
 30  
 import java.text.ParsePosition;
 31  
 import org.apache.commons.logging.Log;
 32  
 import org.apache.commons.logging.LogFactory;
 33  
 
 34  
 /**
 35  
  *  This class contains basic methods for performing validations that return the
 36  
  *  correctly typed class based on the validation performed.
 37  
  */
 38  1
 public class GenericTypeValidator implements Serializable {
 39  
 
 40  
     /**
 41  
      *  Checks if the value can safely be converted to a byte primitive.
 42  
      *
 43  
      *@param  value  The value validation is being performed on.
 44  
      *@return the converted Byte value.
 45  
      */
 46  
     public static Byte formatByte(String value) {
 47  9
         if (value == null) {
 48  2
             return null;
 49  
         }
 50  
 
 51  
         try {
 52  7
             return new Byte(value);
 53  
         } catch (NumberFormatException e) {
 54  2
             return null;
 55  
         }
 56  
 
 57  
     }
 58  
 
 59  
     /**
 60  
      *  Checks if the value can safely be converted to a byte primitive.
 61  
      *
 62  
      *@param  value   The value validation is being performed on.
 63  
      *@param  locale  The locale to use to parse the number (system default if
 64  
      *      null)
 65  
      *@return the converted Byte value.
 66  
      */
 67  
     public static Byte formatByte(String value, Locale locale) {
 68  2
         Byte result = null;
 69  
 
 70  2
         if (value != null) {
 71  2
             NumberFormat formatter = null;
 72  2
             if (locale != null) {
 73  2
                 formatter = NumberFormat.getNumberInstance(locale);
 74  
             } else {
 75  0
                 formatter = NumberFormat.getNumberInstance(Locale.getDefault());
 76  
             }
 77  2
             formatter.setParseIntegerOnly(true);
 78  2
             ParsePosition pos = new ParsePosition(0);
 79  2
             Number num = formatter.parse(value, pos);
 80  
 
 81  
             // If there was no error      and we used the whole string
 82  2
             if (pos.getErrorIndex() == -1 && pos.getIndex() == value.length()) {
 83  2
                 if (num.doubleValue() >= Byte.MIN_VALUE &&
 84  
                     num.doubleValue() <= Byte.MAX_VALUE) {
 85  2
                     result = new Byte(num.byteValue());
 86  
                 }
 87  
             }
 88  
         }
 89  
 
 90  2
         return result;
 91  
     }
 92  
 
 93  
     /**
 94  
      *  Checks if the value can safely be converted to a short primitive.
 95  
      *
 96  
      *@param  value  The value validation is being performed on.
 97  
      *@return the converted Short value.
 98  
      */
 99  
     public static Short formatShort(String value) {
 100  7
         if (value == null) {
 101  1
             return null;
 102  
         }
 103  
 
 104  
         try {
 105  6
             return new Short(value);
 106  
         } catch (NumberFormatException e) {
 107  2
             return null;
 108  
         }
 109  
 
 110  
     }
 111  
 
 112  
     /**
 113  
      *  Checks if the value can safely be converted to a short primitive.
 114  
      *
 115  
      *@param  value   The value validation is being performed on.
 116  
      *@param  locale  The locale to use to parse the number (system default if
 117  
      *      null)vv
 118  
      *@return the converted Short value.
 119  
      */
 120  
     public static Short formatShort(String value, Locale locale) {
 121  2
         Short result = null;
 122  
 
 123  2
         if (value != null) {
 124  2
             NumberFormat formatter = null;
 125  2
             if (locale != null) {
 126  2
                 formatter = NumberFormat.getNumberInstance(locale);
 127  
             } else {
 128  0
                 formatter = NumberFormat.getNumberInstance(Locale.getDefault());
 129  
             }
 130  2
             formatter.setParseIntegerOnly(true);
 131  2
             ParsePosition pos = new ParsePosition(0);
 132  2
             Number num = formatter.parse(value, pos);
 133  
 
 134  
             // If there was no error      and we used the whole string
 135  2
             if (pos.getErrorIndex() == -1 && pos.getIndex() == value.length()) {
 136  2
                 if (num.doubleValue() >= Short.MIN_VALUE &&
 137  
                     num.doubleValue() <= Short.MAX_VALUE) {
 138  2
                     result = new Short(num.shortValue());
 139  
                 }
 140  
             }
 141  
         }
 142  
 
 143  2
         return result;
 144  
     }
 145  
 
 146  
     /**
 147  
      *  Checks if the value can safely be converted to a int primitive.
 148  
      *
 149  
      *@param  value  The value validation is being performed on.
 150  
      *@return the converted Integer value.
 151  
      */
 152  
     public static Integer formatInt(String value) {
 153  16
         if (value == null) {
 154  2
             return null;
 155  
         }
 156  
 
 157  
         try {
 158  14
             return new Integer(value);
 159  
         } catch (NumberFormatException e) {
 160  5
             return null;
 161  
         }
 162  
 
 163  
     }
 164  
 
 165  
     /**
 166  
      *  Checks if the value can safely be converted to an int primitive.
 167  
      *
 168  
      *@param  value   The value validation is being performed on.
 169  
      *@param  locale  The locale to use to parse the number (system default if
 170  
      *      null)
 171  
      *@return the converted Integer value.
 172  
      */
 173  
     public static Integer formatInt(String value, Locale locale) {
 174  2
         Integer result = null;
 175  
 
 176  2
         if (value != null) {
 177  2
             NumberFormat formatter = null;
 178  2
             if (locale != null) {
 179  2
                 formatter = NumberFormat.getNumberInstance(locale);
 180  
             } else {
 181  0
                 formatter = NumberFormat.getNumberInstance(Locale.getDefault());
 182  
             }
 183  2
             formatter.setParseIntegerOnly(true);
 184  2
             ParsePosition pos = new ParsePosition(0);
 185  2
             Number num = formatter.parse(value, pos);
 186  
 
 187  
             // If there was no error      and we used the whole string
 188  2
             if (pos.getErrorIndex() == -1 && pos.getIndex() == value.length()) {
 189  2
                 if (num.doubleValue() >= Integer.MIN_VALUE &&
 190  
                     num.doubleValue() <= Integer.MAX_VALUE) {
 191  2
                     result = new Integer(num.intValue());
 192  
                 }
 193  
             }
 194  
         }
 195  
 
 196  2
         return result;
 197  
     }
 198  
 
 199  
     /**
 200  
      *  Checks if the value can safely be converted to a long primitive.
 201  
      *
 202  
      *@param  value  The value validation is being performed on.
 203  
      *@return the converted Long value.
 204  
      */
 205  
     public static Long formatLong(String value) {
 206  9
         if (value == null) {
 207  2
             return null;
 208  
         }
 209  
 
 210  
         try {
 211  7
             return new Long(value);
 212  
         } catch (NumberFormatException e) {
 213  2
             return null;
 214  
         }
 215  
 
 216  
     }
 217  
 
 218  
     /**
 219  
      *  Checks if the value can safely be converted to a long primitive.
 220  
      *
 221  
      *@param  value   The value validation is being performed on.
 222  
      *@param  locale  The locale to use to parse the number (system default if
 223  
      *      null)
 224  
      *@return the converted Long value.
 225  
      */
 226  
     public static Long formatLong(String value, Locale locale) {
 227  2
         Long result = null;
 228  
 
 229  2
         if (value != null) {
 230  2
             NumberFormat formatter = null;
 231  2
             if (locale != null) {
 232  2
                 formatter = NumberFormat.getNumberInstance(locale);
 233  
             } else {
 234  0
                 formatter = NumberFormat.getNumberInstance(Locale.getDefault());
 235  
             }
 236  2
             formatter.setParseIntegerOnly(true);
 237  2
             ParsePosition pos = new ParsePosition(0);
 238  2
             Number num = formatter.parse(value, pos);
 239  
 
 240  
             // If there was no error      and we used the whole string
 241  2
             if (pos.getErrorIndex() == -1 && pos.getIndex() == value.length()) {
 242  2
                 if (num.doubleValue() >= Long.MIN_VALUE &&
 243  
                     num.doubleValue() <= Long.MAX_VALUE) {
 244  2
                     result = new Long(num.longValue());
 245  
                 }
 246  
             }
 247  
         }
 248  
 
 249  2
         return result;
 250  
     }
 251  
 
 252  
     /**
 253  
      *  Checks if the value can safely be converted to a float primitive.
 254  
      *
 255  
      *@param  value  The value validation is being performed on.
 256  
      *@return the converted Float value.
 257  
      */
 258  
     public static Float formatFloat(String value) {
 259  7
         if (value == null) {
 260  2
             return null;
 261  
         }
 262  
 
 263  
         try {
 264  5
             return new Float(value);
 265  
         } catch (NumberFormatException e) {
 266  0
             return null;
 267  
         }
 268  
 
 269  
     }
 270  
 
 271  
     /**
 272  
      *  Checks if the value can safely be converted to a float primitive.
 273  
      *
 274  
      *@param  value   The value validation is being performed on.
 275  
      *@param  locale  The locale to use to parse the number (system default if
 276  
      *      null)
 277  
      *@return the converted Float value.
 278  
      */
 279  
     public static Float formatFloat(String value, Locale locale) {
 280  2
         Float result = null;
 281  
 
 282  2
         if (value != null) {
 283  2
             NumberFormat formatter = null;
 284  2
             if (locale != null) {
 285  2
                 formatter = NumberFormat.getInstance(locale);
 286  
             } else {
 287  0
                 formatter = NumberFormat.getInstance(Locale.getDefault());
 288  
             }
 289  2
             ParsePosition pos = new ParsePosition(0);
 290  2
             Number num = formatter.parse(value, pos);
 291  
 
 292  
             // If there was no error      and we used the whole string
 293  2
             if (pos.getErrorIndex() == -1 && pos.getIndex() == value.length()) {
 294  2
                 if (num.doubleValue() >= (Float.MAX_VALUE * -1) &&
 295  
                     num.doubleValue() <= Float.MAX_VALUE) {
 296  2
                     result = new Float(num.floatValue());
 297  
                 }
 298  
             }
 299  
         }
 300  
 
 301  2
         return result;
 302  
     }
 303  
 
 304  
     /**
 305  
      *  Checks if the value can safely be converted to a double primitive.
 306  
      *
 307  
      *@param  value  The value validation is being performed on.
 308  
      *@return the converted Double value.
 309  
      */
 310  
     public static Double formatDouble(String value) {
 311  7
         if (value == null) {
 312  2
             return null;
 313  
         }
 314  
 
 315  
         try {
 316  5
             return new Double(value);
 317  
         } catch (NumberFormatException e) {
 318  0
             return null;
 319  
         }
 320  
 
 321  
     }
 322  
 
 323  
     /**
 324  
      *  Checks if the value can safely be converted to a double primitive.
 325  
      *
 326  
      *@param  value   The value validation is being performed on.
 327  
      *@param  locale  The locale to use to parse the number (system default if
 328  
      *      null)
 329  
      *@return the converted Double value.
 330  
      */
 331  
     public static Double formatDouble(String value, Locale locale) {
 332  2
         Double result = null;
 333  
 
 334  2
         if (value != null) {
 335  2
             NumberFormat formatter = null;
 336  2
             if (locale != null) {
 337  2
                 formatter = NumberFormat.getInstance(locale);
 338  
             } else {
 339  0
                 formatter = NumberFormat.getInstance(Locale.getDefault());
 340  
             }
 341  2
             ParsePosition pos = new ParsePosition(0);
 342  2
             Number num = formatter.parse(value, pos);
 343  
 
 344  
             // If there was no error      and we used the whole string
 345  2
             if (pos.getErrorIndex() == -1 && pos.getIndex() == value.length()) {
 346  2
                 if (num.doubleValue() >= (Double.MAX_VALUE * -1) &&
 347  
                     num.doubleValue() <= Double.MAX_VALUE) {
 348  2
                     result = new Double(num.doubleValue());
 349  
                 }
 350  
             }
 351  
         }
 352  
 
 353  2
         return result;
 354  
     }
 355  
 
 356  
     /**
 357  
      *  <p>
 358  
      *
 359  
      *  Checks if the field is a valid date. The <code>Locale</code> is used
 360  
      *  with <code>java.text.DateFormat</code>. The setLenient method is set to
 361  
      *  <code>false</code> for all.</p>
 362  
      *
 363  
      *@param  value   The value validation is being performed on.
 364  
      *@param  locale  The Locale to use to parse the date (system default if
 365  
      *      null)
 366  
      *@return the converted Date value.
 367  
      */
 368  
     public static Date formatDate(String value, Locale locale) {
 369  2
         Date date = null;
 370  
 
 371  2
         if (value == null) {
 372  2
             return null;
 373  
         }
 374  
 
 375  
         try {
 376  0
             DateFormat formatter = null;
 377  0
             if (locale != null) {
 378  0
                 formatter =
 379  
                     DateFormat.getDateInstance(DateFormat.SHORT, locale);
 380  
             } else {
 381  0
                 formatter =
 382  
                     DateFormat.getDateInstance(
 383  
                     DateFormat.SHORT,
 384  
                     Locale.getDefault());
 385  
             }
 386  
 
 387  0
             formatter.setLenient(false);
 388  
 
 389  0
             date = formatter.parse(value);
 390  0
         } catch (ParseException e) {
 391  
             // Bad date so return null
 392  0
             Log log = LogFactory.getLog(GenericTypeValidator.class);
 393  0
             if (log.isDebugEnabled()) {
 394  0
                 log.debug("Date parse failed value=[" + value  + "], " +
 395  
                                            "locale=[" + locale + "] "  + e);
 396  
             }
 397  
         }
 398  
 
 399  0
         return date;
 400  
     }
 401  
 
 402  
     /**
 403  
      *  <p>
 404  
      *  Checks if the field is a valid date. The pattern is used with <code>java.text.SimpleDateFormat</code>
 405  
      *  . If strict is true, then the length will be checked so '2/12/1999' will
 406  
      *  not pass validation with the format 'MM/dd/yyyy' because the month isn't
 407  
      *  two digits. The setLenient method is set to <code>false</code> for all.
 408  
      *  </p>
 409  
      *
 410  
      *@param  value        The value validation is being performed on.
 411  
      *@param  datePattern  The pattern passed to <code>SimpleDateFormat</code>.
 412  
      *@param  strict       Whether or not to have an exact match of the
 413  
      *      datePattern.
 414  
      *@return the converted Date value.
 415  
      */
 416  
     public static Date formatDate(String value, String datePattern, boolean strict) {
 417  2
         Date date = null;
 418  
 
 419  2
         if (value == null
 420  
              || datePattern == null
 421  
              || datePattern.length() == 0) {
 422  0
             return null;
 423  
         }
 424  
 
 425  
         try {
 426  2
             SimpleDateFormat formatter = new SimpleDateFormat(datePattern);
 427  2
             formatter.setLenient(false);
 428  
 
 429  2
             date = formatter.parse(value);
 430  
 
 431  1
             if (strict) {
 432  0
                 if (datePattern.length() != value.length()) {
 433  0
                     date = null;
 434  
                 }
 435  
             }
 436  1
         } catch (ParseException e) {
 437  
             // Bad date so return null
 438  1
             Log log = LogFactory.getLog(GenericTypeValidator.class);
 439  1
             if (log.isDebugEnabled()) {
 440  0
                 log.debug("Date parse failed value=[" + value       + "], " +
 441  
                                           "pattern=[" + datePattern + "], " +
 442  
                                            "strict=[" + strict      + "] "  + e);
 443  
             }
 444  
         }
 445  
 
 446  2
         return date;
 447  
     }
 448  
 
 449  
     /**
 450  
      *  <p>
 451  
      *  Checks if the field is a valid credit card number.</p> <p>
 452  
      *
 453  
      *  Reference Sean M. Burke's <a href="http://www.ling.nwu.edu/~sburke/pub/luhn_lib.pl">
 454  
      *  script</a> .</p>
 455  
      *
 456  
      *@param  value  The value validation is being performed on.
 457  
      *@return the converted Credit Card number.
 458  
      */
 459  
     public static Long formatCreditCard(String value) {
 460  0
         return GenericValidator.isCreditCard(value) ? new Long(value) : null;
 461  
     }
 462  
 
 463  
 }
 464  
 

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