%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.