Coverage Report

Coverage Report - org.apache.commons.beanutils.converters.DateTimeConverter

Classes in this File

Line Coverage

Branch Coverage

Complexity

DateTimeConverter

78%

149/191

72%

78/108

5.1

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.commons.beanutils.converters;
 
 import java.util.Date;
 import java.util.Locale;
 import java.util.Calendar;
 import java.util.TimeZone;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.text.ParsePosition;
 import org.apache.commons.beanutils.ConversionException;
 
 /**
  * {@link org.apache.commons.beanutils.Converter} implementaion
  * that handles conversion to and from <b>date/time</b> objects.
  * <p>
  * This implementation handles conversion for the following
  * <i>date/time</i> types.
  * <ul>
  *     <li><code>java.util.Date</code></li>
  *     <li><code>java.util.Calendar</code></li>
  *     <li><code>java.sql.Date</code></li>
  *     <li><code>java.sql.Time</code></li>
  *     <li><code>java.sql.Timestamp</code></li>
  * </ul>
  *
  * <h3>String Conversions (to and from)</h3>
  * This class provides a number of ways in which date/time
  * conversions to/from Strings can be achieved:
  * <ul>
  *    <li>Using the SHORT date format for the default Locale, configure using:</li>
  *        <ul>
  *           <li><code>setUseLocaleFormat(true)</code></li>
  *        </ul>
  *    <li>Using the SHORT date format for a specified Locale, configure using:</li>
  *        <ul>
  *           <li><code>setLocale(Locale)</code></li>
  *        </ul>
  *    <li>Using the specified date pattern(s) for the default Locale, configure using:</li>
  *        <ul>
  *           <li>Either <code>setPattern(String)</code> or
  *                      <code>setPatterns(String[])</code></li>
  *        </ul>
  *    <li>Using the specified date pattern(s) for a specified Locale, configure using:</li>
  *        <ul>
  *           <li><code>setPattern(String)</code> or
  *                    <code>setPatterns(String[]) and...</code></li>
  *           <li><code>setLocale(Locale)</code></li>
  *        </ul>
  *    <li>If none of the above are configured the
  *        <code>toDate(String)</code> method is used to convert
  *        from String to Date and the Dates's
  *        <code>toString()</code> method used to convert from
  *        Date to String.</li>
  * </ul>
  *
  * <p>
  * The <b>Time Zone</b> to use with the date format can be specified
  * using the <code>setTimeZone()</code> method.
  *
  * @version $Revision: 640131 $ $Date: 2008-03-22 22:10:31 -0400 (Sat, 22 Mar 2008) $
  * @since 1.8.0
  */
 public abstract class DateTimeConverter extends AbstractConverter {
 
     private String[] patterns;
     private String displayPatterns;
     private Locale locale;
     private TimeZone timeZone;
     private boolean useLocaleFormat;
 
 
     // ----------------------------------------------------------- Constructors
 
     /**
      * Construct a Date/Time <i>Converter</i> that throws a
      * <code>ConversionException</code> if an error occurs.
      */
     public DateTimeConverter() {
         super();
     }
 
     /**
      * Construct a Date/Time <i>Converter</i> that returns a default
      * value if an error occurs.
      *
      * @param defaultValue The default value to be returned
      * if the value to be converted is missing or an error
      * occurs converting the value.
      */
     public DateTimeConverter(Object defaultValue) {
         super(defaultValue);
     }
 
 
     // --------------------------------------------------------- Public Methods
 
     /**
      * Indicate whether conversion should use a format/pattern or not.
      *
      * @param useLocaleFormat <code>true</code> if the format
      * for the locale should be used, otherwise <code>false</code>
      */
     public void setUseLocaleFormat(boolean useLocaleFormat) {
         this.useLocaleFormat = useLocaleFormat;
     }
 
     /**
      * Return the Time Zone to use when converting dates
      * (or <code>null</code> if none specified.
      *
      * @return The Time Zone.
      */
     public TimeZone getTimeZone() {
         return timeZone;
     }
 
     /**
      * Set the Time Zone to use when converting dates.
      *
      * @param timeZone The Time Zone.
      */
     public void setTimeZone(TimeZone timeZone) {
         this.timeZone = timeZone;
     }
 
     /**
      * Return the Locale for the <i>Converter</i>
      * (or <code>null</code> if none specified).
      *
      * @return The locale to use for conversion
      */
     public Locale getLocale() {
         return locale;
     }
 
     /**
      * Set the Locale for the <i>Converter</i>.
      *
      * @param locale The Locale.
      */
     public void setLocale(Locale locale) {
         this.locale = locale;
         setUseLocaleFormat(true);
     }
 
     /**
      * Set a date format pattern to use to convert
      * dates to/from a <code>java.lang.String</code>.
      *
      * @see SimpleDateFormat
      * @param pattern The format pattern.
      */
     public void setPattern(String pattern) {
         setPatterns(new String[] {pattern});
     }
 
     /**
      * Return the date format patterns used to convert
      * dates to/from a <code>java.lang.String</code>
      * (or <code>null</code> if none specified).
      *
      * @see SimpleDateFormat
      * @return Array of format patterns.
      */
     public String[] getPatterns() {
         return patterns; 
     }
 
     /**
      * Set the date format patterns to use to convert
      * dates to/from a <code>java.lang.String</code>.
      *
      * @see SimpleDateFormat
      * @param patterns Array of format patterns.
      */
     public void setPatterns(String[] patterns) {
         this.patterns = patterns;
         if (patterns != null && patterns.length > 1) {
             StringBuffer buffer = new StringBuffer();
             for (int i = 0; i < patterns.length; i++) {
                 if (i > 0) {
                     buffer.append(", ");
                 }
                 buffer.append(patterns[i]);
             }
             displayPatterns = buffer.toString();
         }
         setUseLocaleFormat(true);
     }
 
     // ------------------------------------------------------ Protected Methods
 
     /**
      * Convert an input Date/Calendar object into a String.
      * <p>
      * <b>N.B.</b>If the converter has been configured to with
      * one or more patterns (using <code>setPatterns()</code>), then
      * the first pattern will be used to format the date into a String.
      * Otherwise the default <code>DateFormat</code> for the default locale
      * (and <i>style</i> if configured) will be used.
      *
      * @param value The input value to be converted
      * @return the converted String value.
      * @throws Throwable if an error occurs converting to a String
      */
     protected String convertToString(Object value) throws Throwable {
 
         Date date = null;
         if (value instanceof Date) {
             date = (Date)value;
         } else if (value instanceof Calendar) {
             date = ((Calendar)value).getTime();
         } else if (value instanceof Long) {
             date = new Date(((Long)value).longValue());
         }
 
         String result = null;
         if (useLocaleFormat && date != null) {
             DateFormat format = null;
             if (patterns != null && patterns.length > 0) {
                 format = getFormat(patterns[0]);
             } else {
                 format = getFormat(locale, timeZone);
             }
             logFormat("Formatting", format);
             result = format.format(date);
             if (log().isDebugEnabled()) {
                 log().debug("    Converted  to String using format '" + result + "'");
             }
         } else {
             result = value.toString();
             if (log().isDebugEnabled()) {
                 log().debug("    Converted  to String using toString() '" + result + "'");
              }
         }
         return result;
     }
 
     /**
      * Convert the input object into a Date object of the
      * specified type.
      * <p>
      * This method handles conversions between the following
      * types:
      * <ul>
      *     <li><code>java.util.Date</code></li>
      *     <li><code>java.util.Calendar</code></li>
      *     <li><code>java.sql.Date</code></li>
      *     <li><code>java.sql.Time</code></li>
      *     <li><code>java.sql.Timestamp</code></li>
      * </ul>
      *
      * It also handles conversion from a <code>String</code> to
      * any of the above types.
      * <p>
      *
      * For <code>String</code> conversion, if the converter has been configured
      * with one or more patterns (using <code>setPatterns()</code>), then
      * the conversion is attempted with each of the specified patterns.
      * Otherwise the default <code>DateFormat</code> for the default locale
      * (and <i>style</i> if configured) will be used.
      *
      * @param targetType Data type to which this value should be converted.
      * @param value The input value to be converted.
      * @return The converted value.
      * @throws Exception if conversion cannot be performed successfully
      */
     protected Object convertToType(Class targetType, Object value) throws Exception {
 
         Class sourceType = value.getClass();
 
         // Handle java.sql.Timestamp
         if (value instanceof java.sql.Timestamp) {
 
             // ---------------------- JDK 1.3 Fix ----------------------
             // N.B. Prior to JDK 1.4 the Timestamp's getTime() method
             //      didn't include the milliseconds. The following code
             //      ensures it works consistently accross JDK versions
             java.sql.Timestamp timestamp = (java.sql.Timestamp)value;
             long timeInMillis = ((timestamp.getTime() / 1000) * 1000);
             timeInMillis += timestamp.getNanos() / 1000000;
             // ---------------------- JDK 1.3 Fix ----------------------
             return toDate(targetType, timeInMillis);
         }
 
         // Handle Date (includes java.sql.Date & java.sql.Time)
         if (value instanceof Date) {
             Date date = (Date)value;
             return toDate(targetType, date.getTime());
         }
 
         // Handle Calendar
         if (value instanceof Calendar) {
             Calendar calendar = (Calendar)value;
             return toDate(targetType, calendar.getTime().getTime());
         }
 
         // Handle Long
         if (value instanceof Long) {
             Long longObj = (Long)value;
             return toDate(targetType, longObj.longValue());
         }
 
         // Convert all other types to String & handle
         String stringValue = value.toString().trim();
         if (stringValue.length() == 0) {
             return handleMissing(targetType);
         }
 
         // Parse the Date/Time
         if (useLocaleFormat) {
             Calendar calendar = null;
             if (patterns != null && patterns.length > 0) {
                 calendar = parse(sourceType, targetType, stringValue);
             } else {
                 DateFormat format = getFormat(locale, timeZone);
                 calendar = parse(sourceType, targetType, stringValue, format);
             }
             if (Calendar.class.isAssignableFrom(targetType)) {
                 return calendar;
             } else {
                 return toDate(targetType, calendar.getTime().getTime());
             }
         }
 
         // Default String conversion
         return toDate(targetType, stringValue);
 
     }
 
     /**
      * Convert a long value to the specified Date type for this
      * <i>Converter</i>.
      * <p>
      *
      * This method handles conversion to the following types:
      * <ul>
      *     <li><code>java.util.Date</code></li>
      *     <li><code>java.util.Calendar</code></li>
      *     <li><code>java.sql.Date</code></li>
      *     <li><code>java.sql.Time</code></li>
      *     <li><code>java.sql.Timestamp</code></li>
      * </ul>
      *
      * @param type The Date type to convert to
      * @param value The long value to convert.
      * @return The converted date value.
      */
     private Object toDate(Class type, long value) {
 
         // java.util.Date
         if (type.equals(Date.class)) {
             return new Date(value);
         }
 
         // java.sql.Date
         if (type.equals(java.sql.Date.class)) {
             return new java.sql.Date(value);
         }
 
         // java.sql.Time
         if (type.equals(java.sql.Time.class)) {
             return new java.sql.Time(value);
         }
 
         // java.sql.Timestamp
         if (type.equals(java.sql.Timestamp.class)) {
             return new java.sql.Timestamp(value);
         }
 
         // java.util.Calendar
         if (type.equals(Calendar.class)) {
             Calendar calendar = null;
             if (locale == null && timeZone == null) {
                 calendar = Calendar.getInstance();
             } else if (locale == null) {
                 calendar = Calendar.getInstance(timeZone);
             } else if (timeZone == null) {
                 calendar = Calendar.getInstance(locale);
             } else {
                 calendar = Calendar.getInstance(timeZone, locale);
             }
             calendar.setTime(new Date(value));
             calendar.setLenient(false);
             return calendar;
         }
 
         String msg = toString(getClass()) + " cannot handle conversion to '"
                    + toString(type) + "'";
         if (log().isWarnEnabled()) {
             log().warn("    " + msg);
         }
         throw new ConversionException(msg);
     }
 
     /**
      * Default String to Date conversion.
      * <p>
      * This method handles conversion from a String to the following types:
      * <ul>
      *     <li><code>java.sql.Date</code></li>
      *     <li><code>java.sql.Time</code></li>
      *     <li><code>java.sql.Timestamp</code></li>
      * </ul>
      * <p>
      * <strong>N.B.</strong> No default String conversion
      * mechanism is provided for <code>java.util.Date</code>
      * and <code>java.util.Calendar</code> type.
      *
      * @param type The Number type to convert to
      * @param value The String value to convert.
      * @return The converted Number value.
      */
     private Object toDate(Class type, String value) {
         // java.sql.Date
         if (type.equals(java.sql.Date.class)) {
             try {
                 return java.sql.Date.valueOf(value);
             } catch (IllegalArgumentException e) {
                 throw new ConversionException(
                         "String must be in JDBC format [yyyy-MM-dd] to create a java.sql.Date");
             }
         }
 
         // java.sql.Time
         if (type.equals(java.sql.Time.class)) {
             try {
                 return java.sql.Time.valueOf(value);
             } catch (IllegalArgumentException e) {
                 throw new ConversionException(
                         "String must be in JDBC format [HH:mm:ss] to create a java.sql.Time");
             }
         }
 
         // java.sql.Timestamp
         if (type.equals(java.sql.Timestamp.class)) {
             try {
                 return java.sql.Timestamp.valueOf(value);
             } catch (IllegalArgumentException e) {
                 throw new ConversionException(
                         "String must be in JDBC format [yyyy-MM-dd HH:mm:ss.fffffffff] " +
                         "to create a java.sql.Timestamp");
             }
         }
 
         String msg = toString(getClass()) + " does not support default String to '"
                    + toString(type) + "' conversion.";
         if (log().isWarnEnabled()) {
             log().warn("    " + msg);
             log().warn("    (N.B. Re-configure Converter or use alternative implementation)");
         }
         throw new ConversionException(msg);
     }
 
     /**
      * Return a <code>DateFormat<code> for the Locale.
      * @param locale The Locale to create the Format with (may be null)
      * @param timeZone The Time Zone create the Format with (may be null)
      *
      * @return A Date Format.
      */
     protected DateFormat getFormat(Locale locale, TimeZone timeZone) {
         DateFormat format = null;
         if (locale == null) {
             format = DateFormat.getDateInstance(DateFormat.SHORT);
         } else {
             format = DateFormat.getDateInstance(DateFormat.SHORT, locale);
         }
         if (timeZone != null) {
             format.setTimeZone(timeZone);
         }
         return format;
     }
 
     /**
      * Create a date format for the specified pattern.
      *
      * @param pattern The date pattern
      * @return The DateFormat
      */
     private DateFormat getFormat(String pattern) {
         DateFormat format = new SimpleDateFormat(pattern);
         if (timeZone != null) {
             format.setTimeZone(timeZone);
         }
         return format;
     }
 
     /**
      * Parse a String date value using the set of patterns.
      *
      * @param sourceType The type of the value being converted
      * @param targetType The type to convert the value to.
      * @param value The String date value.
      *
      * @return The converted Date object.
      * @throws Exception if an error occurs parsing the date.
      */
     private Calendar parse(Class sourceType, Class targetType, String value) throws Exception {
         Exception firstEx = null;
         for (int i = 0; i < patterns.length; i++) {
             try {
                 DateFormat format = getFormat(patterns[i]);
                 Calendar calendar = parse(sourceType, targetType, value, format);
                 return calendar;
             } catch (Exception ex) {
                 if (firstEx == null) {
                     firstEx = ex;
                 }
             }
         }
         if (patterns.length > 1) {
             throw new ConversionException("Error converting '" + toString(sourceType) + "' to '" + toString(targetType)
                     + "' using  patterns '" + displayPatterns + "'");
         } else {
             throw firstEx;
         }
     }
 
     /**
      * Parse a String into a <code>Calendar</code> object
      * using the specified <code>DateFormat</code>.
      *
      * @param sourceType The type of the value being converted
      * @param targetType The type to convert the value to
      * @param value The String date value.
      * @param format The DateFormat to parse the String value.
      *
      * @return The converted Calendar object.
      * @throws ConversionException if the String cannot be converted.
      */
     private Calendar parse(Class sourceType, Class targetType, String value, DateFormat format) {
         logFormat("Parsing", format);
         format.setLenient(false);
         ParsePosition pos = new ParsePosition(0);
         Date parsedDate = format.parse(value, pos); // ignore the result (use the Calendar)
         if (pos.getErrorIndex() >= 0 || pos.getIndex() != value.length() || parsedDate == null) {
             String msg = "Error converting '" + toString(sourceType) + "' to '" + toString(targetType) + "'";
             if (format instanceof SimpleDateFormat) {
                 msg += " using pattern '" + ((SimpleDateFormat)format).toPattern() + "'";
             }
             if (log().isDebugEnabled()) {
                 log().debug("    " + msg);
             }
             throw new ConversionException(msg);
         }
         Calendar calendar = format.getCalendar();
         return calendar;
     }
 
     /**
      * Provide a String representation of this date/time converter.
      *
      * @return A String representation of this date/time converter
      */
     public String toString() {
         StringBuffer buffer = new StringBuffer();
         buffer.append(toString(getClass()));
         buffer.append("[UseDefault=");
         buffer.append(isUseDefault());
         buffer.append(", UseLocaleFormat=");
         buffer.append(useLocaleFormat);
         if (displayPatterns != null) {
             buffer.append(", Patterns={");
             buffer.append(displayPatterns);
             buffer.append('}');
         }
         if (locale != null) {
             buffer.append(", Locale=");
             buffer.append(locale);
         }
         if (timeZone != null) {
             buffer.append(", TimeZone=");
             buffer.append(timeZone);
         }
         buffer.append(']');
         return buffer.toString();
     }
 
     /**
      * Log the <code>DateFormat<code> creation.
      * @param action The action the format is being used for
      * @param format The Date format
      */
     private void logFormat(String action, DateFormat format) {
         if (log().isDebugEnabled()) {
             StringBuffer buffer = new StringBuffer(45);
             buffer.append("    ");
             buffer.append(action);
             buffer.append(" with Format");
             if (format instanceof SimpleDateFormat) {
                 buffer.append("[");
                 buffer.append(((SimpleDateFormat)format).toPattern());
                 buffer.append("]");
             }
             buffer.append(" for ");
             if (locale == null) {
                 buffer.append("default locale");
             } else {
                 buffer.append("locale[");
                 buffer.append(locale);
                 buffer.append("]");
             }
             if (timeZone != null) {
                 buffer.append(", TimeZone[");
                 buffer.append(timeZone);
                 buffer.append("]");
             }
             log().debug(buffer.toString());
         }
     }
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one or more
3		* contributor license agreements. See the NOTICE file distributed with
4		* this work for additional information regarding copyright ownership.
5		* The ASF licenses this file to You under the Apache License, Version 2.0
6		* (the "License"); you may not use this file except in compliance with
7		* the License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17		package org.apache.commons.beanutils.converters;
18
19		import java.util.Date;
20		import java.util.Locale;
21		import java.util.Calendar;
22		import java.util.TimeZone;
23		import java.text.DateFormat;
24		import java.text.SimpleDateFormat;
25		import java.text.ParsePosition;
26		import org.apache.commons.beanutils.ConversionException;
27
28		/**
29		* {@link org.apache.commons.beanutils.Converter} implementaion
30		* that handles conversion to and from <b>date/time</b> objects.
31		* <p>
32		* This implementation handles conversion for the following
33		* <i>date/time</i> types.
34		* <ul>
35		* <li><code>java.util.Date</code></li>
36		* <li><code>java.util.Calendar</code></li>
37		* <li><code>java.sql.Date</code></li>
38		* <li><code>java.sql.Time</code></li>
39		* <li><code>java.sql.Timestamp</code></li>
40		* </ul>
41		*
42		* <h3>String Conversions (to and from)</h3>
43		* This class provides a number of ways in which date/time
44		* conversions to/from Strings can be achieved:
45		* <ul>
46		* <li>Using the SHORT date format for the default Locale, configure using:</li>
47		* <ul>
48		* <li><code>setUseLocaleFormat(true)</code></li>
49		* </ul>
50		* <li>Using the SHORT date format for a specified Locale, configure using:</li>
51		* <ul>
52		* <li><code>setLocale(Locale)</code></li>
53		* </ul>
54		* <li>Using the specified date pattern(s) for the default Locale, configure using:</li>
55		* <ul>
56		* <li>Either <code>setPattern(String)</code> or
57		* <code>setPatterns(String[])</code></li>
58		* </ul>
59		* <li>Using the specified date pattern(s) for a specified Locale, configure using:</li>
60		* <ul>
61		* <li><code>setPattern(String)</code> or
62		* <code>setPatterns(String[]) and...</code></li>
63		* <li><code>setLocale(Locale)</code></li>
64		* </ul>
65		* <li>If none of the above are configured the
66		* <code>toDate(String)</code> method is used to convert
67		* from String to Date and the Dates's
68		* <code>toString()</code> method used to convert from
69		* Date to String.</li>
70		* </ul>
71		*
72		* <p>
73		* The <b>Time Zone</b> to use with the date format can be specified
74		* using the <code>setTimeZone()</code> method.
75		*
76		* @version $Revision: 640131 $ $Date: 2008-03-22 22:10:31 -0400 (Sat, 22 Mar 2008) $
77		* @since 1.8.0
78		*/
79		public abstract class DateTimeConverter extends AbstractConverter {
80
81		private String[] patterns;
82		private String displayPatterns;
83		private Locale locale;
84		private TimeZone timeZone;
85		private boolean useLocaleFormat;
86
87
88		// ----------------------------------------------------------- Constructors
89
90		/**
91		* Construct a Date/Time <i>Converter</i> that throws a
92		* <code>ConversionException</code> if an error occurs.
93		*/
94		public DateTimeConverter() {
95	3629	super();
96	3629	}
97
98		/**
99		* Construct a Date/Time <i>Converter</i> that returns a default
100		* value if an error occurs.
101		*
102		* @param defaultValue The default value to be returned
103		* if the value to be converted is missing or an error
104		* occurs converting the value.
105		*/
106		public DateTimeConverter(Object defaultValue) {
107	120	super(defaultValue);
108	120	}
109
110
111		// --------------------------------------------------------- Public Methods
112
113		/**
114		* Indicate whether conversion should use a format/pattern or not.
115		*
116		* @param useLocaleFormat <code>true</code> if the format
117		* for the locale should be used, otherwise <code>false</code>
118		*/
119		public void setUseLocaleFormat(boolean useLocaleFormat) {
120	263	this.useLocaleFormat = useLocaleFormat;
121	263	}
122
123		/**
124		* Return the Time Zone to use when converting dates
125		* (or <code>null</code> if none specified.
126		*
127		* @return The Time Zone.
128		*/
129		public TimeZone getTimeZone() {
130	0	return timeZone;
131		}
132
133		/**
134		* Set the Time Zone to use when converting dates.
135		*
136		* @param timeZone The Time Zone.
137		*/
138		public void setTimeZone(TimeZone timeZone) {
139	0	this.timeZone = timeZone;
140	0	}
141
142		/**
143		* Return the Locale for the <i>Converter</i>
144		* (or <code>null</code> if none specified).
145		*
146		* @return The locale to use for conversion
147		*/
148		public Locale getLocale() {
149	0	return locale;
150		}
151
152		/**
153		* Set the Locale for the <i>Converter</i>.
154		*
155		* @param locale The Locale.
156		*/
157		public void setLocale(Locale locale) {
158	112	this.locale = locale;
159	112	setUseLocaleFormat(true);
160	112	}
161
162		/**
163		* Set a date format pattern to use to convert
164		* dates to/from a <code>java.lang.String</code>.
165		*
166		* @see SimpleDateFormat
167		* @param pattern The format pattern.
168		*/
169		public void setPattern(String pattern) {
170	135	setPatterns(new String[] {pattern});
171	135	}
172
173		/**
174		* Return the date format patterns used to convert
175		* dates to/from a <code>java.lang.String</code>
176		* (or <code>null</code> if none specified).
177		*
178		* @see SimpleDateFormat
179		* @return Array of format patterns.
180		*/
181		public String[] getPatterns() {
182	0	return patterns;
183		}
184
185		/**
186		* Set the date format patterns to use to convert
187		* dates to/from a <code>java.lang.String</code>.
188		*
189		* @see SimpleDateFormat
190		* @param patterns Array of format patterns.
191		*/
192		public void setPatterns(String[] patterns) {
193	140	this.patterns = patterns;
194	140	if (patterns != null && patterns.length > 1) {
195	5	StringBuffer buffer = new StringBuffer();
196	15	for (int i = 0; i < patterns.length; i++) {
197	10	if (i > 0) {
198	5	buffer.append(", ");
199		}
200	10	buffer.append(patterns[i]);
201		}
202	5	displayPatterns = buffer.toString();
203		}
204	140	setUseLocaleFormat(true);
205	140	}
206
207		// ------------------------------------------------------ Protected Methods
208
209		/**
210		* Convert an input Date/Calendar object into a String.
211		* <p>
212		* <b>N.B.</b>If the converter has been configured to with
213		* one or more patterns (using <code>setPatterns()</code>), then
214		* the first pattern will be used to format the date into a String.
215		* Otherwise the default <code>DateFormat</code> for the default locale
216		* (and <i>style</i> if configured) will be used.
217		*
218		* @param value The input value to be converted
219		* @return the converted String value.
220		* @throws Throwable if an error occurs converting to a String
221		*/
222		protected String convertToString(Object value) throws Throwable {
223
224	47	Date date = null;
225	47	if (value instanceof Date) {
226	35	date = (Date)value;
227	12	} else if (value instanceof Calendar) {
228	6	date = ((Calendar)value).getTime();
229	6	} else if (value instanceof Long) {
230	0	date = new Date(((Long)value).longValue());
231		}
232
233	47	String result = null;
234	47	if (useLocaleFormat && date != null) {
235	40	DateFormat format = null;
236	40	if (patterns != null && patterns.length > 0) {
237	39	format = getFormat(patterns[0]);
238		} else {
239	1	format = getFormat(locale, timeZone);
240		}
241	40	logFormat("Formatting", format);
242	40	result = format.format(date);
243	40	if (log().isDebugEnabled()) {
244	0	log().debug(" Converted to String using format '" + result + "'");
245		}
246	40	} else {
247	7	result = value.toString();
248	7	if (log().isDebugEnabled()) {
249	0	log().debug(" Converted to String using toString() '" + result + "'");
250		}
251		}
252	47	return result;
253		}
254
255		/**
256		* Convert the input object into a Date object of the
257		* specified type.
258		* <p>
259		* This method handles conversions between the following
260		* types:
261		* <ul>
262		* <li><code>java.util.Date</code></li>
263		* <li><code>java.util.Calendar</code></li>
264		* <li><code>java.sql.Date</code></li>
265		* <li><code>java.sql.Time</code></li>
266		* <li><code>java.sql.Timestamp</code></li>
267		* </ul>
268		*
269		* It also handles conversion from a <code>String</code> to
270		* any of the above types.
271		* <p>
272		*
273		* For <code>String</code> conversion, if the converter has been configured
274		* with one or more patterns (using <code>setPatterns()</code>), then
275		* the conversion is attempted with each of the specified patterns.
276		* Otherwise the default <code>DateFormat</code> for the default locale
277		* (and <i>style</i> if configured) will be used.
278		*
279		* @param targetType Data type to which this value should be converted.
280		* @param value The input value to be converted.
281		* @return The converted value.
282		* @throws Exception if conversion cannot be performed successfully
283		*/
284		protected Object convertToType(Class targetType, Object value) throws Exception {
285
286	227	Class sourceType = value.getClass();
287
288		// Handle java.sql.Timestamp
289	227	if (value instanceof java.sql.Timestamp) {
290
291		// ---------------------- JDK 1.3 Fix ----------------------
292		// N.B. Prior to JDK 1.4 the Timestamp's getTime() method
293		// didn't include the milliseconds. The following code
294		// ensures it works consistently accross JDK versions
295	8	java.sql.Timestamp timestamp = (java.sql.Timestamp)value;
296	8	long timeInMillis = ((timestamp.getTime() / 1000) * 1000);
297	8	timeInMillis += timestamp.getNanos() / 1000000;
298		// ---------------------- JDK 1.3 Fix ----------------------
299	8	return toDate(targetType, timeInMillis);
300		}
301
302		// Handle Date (includes java.sql.Date & java.sql.Time)
303	219	if (value instanceof Date) {
304	29	Date date = (Date)value;
305	29	return toDate(targetType, date.getTime());
306		}
307
308		// Handle Calendar
309	190	if (value instanceof Calendar) {
310	21	Calendar calendar = (Calendar)value;
311	21	return toDate(targetType, calendar.getTime().getTime());
312		}
313
314		// Handle Long
315	169	if (value instanceof Long) {
316	0	Long longObj = (Long)value;
317	0	return toDate(targetType, longObj.longValue());
318		}
319
320		// Convert all other types to String & handle
321	169	String stringValue = value.toString().trim();
322	169	if (stringValue.length() == 0) {
323	20	return handleMissing(targetType);
324		}
325
326		// Parse the Date/Time
327	149	if (useLocaleFormat) {
328	136	Calendar calendar = null;
329	136	if (patterns != null && patterns.length > 0) {
330	109	calendar = parse(sourceType, targetType, stringValue);
331		} else {
332	27	DateFormat format = getFormat(locale, timeZone);
333	27	calendar = parse(sourceType, targetType, stringValue, format);
334		}
335	40	if (Calendar.class.isAssignableFrom(targetType)) {
336	7	return calendar;
337		} else {
338	33	return toDate(targetType, calendar.getTime().getTime());
339		}
340		}
341
342		// Default String conversion
343	13	return toDate(targetType, stringValue);
344
345		}
346
347		/**
348		* Convert a long value to the specified Date type for this
349		* <i>Converter</i>.
350		* <p>
351		*
352		* This method handles conversion to the following types:
353		* <ul>
354		* <li><code>java.util.Date</code></li>
355		* <li><code>java.util.Calendar</code></li>
356		* <li><code>java.sql.Date</code></li>
357		* <li><code>java.sql.Time</code></li>
358		* <li><code>java.sql.Timestamp</code></li>
359		* </ul>
360		*
361		* @param type The Date type to convert to
362		* @param value The long value to convert.
363		* @return The converted date value.
364		*/
365		private Object toDate(Class type, long value) {
366
367		// java.util.Date
368	91	if (type.equals(Date.class)) {
369	23	return new Date(value);
370		}
371
372		// java.sql.Date
373	68	if (type.equals(java.sql.Date.class)) {
374	15	return new java.sql.Date(value);
375		}
376
377		// java.sql.Time
378	53	if (type.equals(java.sql.Time.class)) {
379	16	return new java.sql.Time(value);
380		}
381
382		// java.sql.Timestamp
383	37	if (type.equals(java.sql.Timestamp.class)) {
384	15	return new java.sql.Timestamp(value);
385		}
386
387		// java.util.Calendar
388	22	if (type.equals(Calendar.class)) {
389	17	Calendar calendar = null;
390	17	if (locale == null && timeZone == null) {
391	17	calendar = Calendar.getInstance();
392	0	} else if (locale == null) {
393	0	calendar = Calendar.getInstance(timeZone);
394	0	} else if (timeZone == null) {
395	0	calendar = Calendar.getInstance(locale);
396		} else {
397	0	calendar = Calendar.getInstance(timeZone, locale);
398		}
399	17	calendar.setTime(new Date(value));
400	17	calendar.setLenient(false);
401	17	return calendar;
402		}
403
404	5	String msg = toString(getClass()) + " cannot handle conversion to '"
405		+ toString(type) + "'";
406	5	if (log().isWarnEnabled()) {
407	5	log().warn(" " + msg);
408		}
409	5	throw new ConversionException(msg);
410		}
411
412		/**
413		* Default String to Date conversion.
414		* <p>
415		* This method handles conversion from a String to the following types:
416		* <ul>
417		* <li><code>java.sql.Date</code></li>
418		* <li><code>java.sql.Time</code></li>
419		* <li><code>java.sql.Timestamp</code></li>
420		* </ul>
421		* <p>
422		* <strong>N.B.</strong> No default String conversion
423		* mechanism is provided for <code>java.util.Date</code>
424		* and <code>java.util.Calendar</code> type.
425		*
426		* @param type The Number type to convert to
427		* @param value The String value to convert.
428		* @return The converted Number value.
429		*/
430		private Object toDate(Class type, String value) {
431		// java.sql.Date
432	13	if (type.equals(java.sql.Date.class)) {
433		try {
434	3	return java.sql.Date.valueOf(value);
435	1	} catch (IllegalArgumentException e) {
436	1	throw new ConversionException(
437		"String must be in JDBC format [yyyy-MM-dd] to create a java.sql.Date");
438		}
439		}
440
441		// java.sql.Time
442	10	if (type.equals(java.sql.Time.class)) {
443		try {
444	3	return java.sql.Time.valueOf(value);
445	1	} catch (IllegalArgumentException e) {
446	1	throw new ConversionException(
447		"String must be in JDBC format [HH:mm:ss] to create a java.sql.Time");
448		}
449		}
450
451		// java.sql.Timestamp
452	7	if (type.equals(java.sql.Timestamp.class)) {
453		try {
454	5	return java.sql.Timestamp.valueOf(value);
455	3	} catch (IllegalArgumentException e) {
456	3	throw new ConversionException(
457		"String must be in JDBC format [yyyy-MM-dd HH:mm:ss.fffffffff] " +
458		"to create a java.sql.Timestamp");
459		}
460		}
461
462	2	String msg = toString(getClass()) + " does not support default String to '"
463		+ toString(type) + "' conversion.";
464	2	if (log().isWarnEnabled()) {
465	2	log().warn(" " + msg);
466	2	log().warn(" (N.B. Re-configure Converter or use alternative implementation)");
467		}
468	2	throw new ConversionException(msg);
469		}
470
471		/**
472		* Return a <code>DateFormat<code> for the Locale.
473		* @param locale The Locale to create the Format with (may be null)
474		* @param timeZone The Time Zone create the Format with (may be null)
475		*
476		* @return A Date Format.
477		*/
478		protected DateFormat getFormat(Locale locale, TimeZone timeZone) {
479	16	DateFormat format = null;
480	16	if (locale == null) {
481	15	format = DateFormat.getDateInstance(DateFormat.SHORT);
482		} else {
483	1	format = DateFormat.getDateInstance(DateFormat.SHORT, locale);
484		}
485	16	if (timeZone != null) {
486	0	format.setTimeZone(timeZone);
487		}
488	16	return format;
489		}
490
491		/**
492		* Create a date format for the specified pattern.
493		*
494		* @param pattern The date pattern
495		* @return The DateFormat
496		*/
497		private DateFormat getFormat(String pattern) {
498	163	DateFormat format = new SimpleDateFormat(pattern);
499	163	if (timeZone != null) {
500	0	format.setTimeZone(timeZone);
501		}
502	163	return format;
503		}
504
505		/**
506		* Parse a String date value using the set of patterns.
507		*
508		* @param sourceType The type of the value being converted
509		* @param targetType The type to convert the value to.
510		* @param value The String date value.
511		*
512		* @return The converted Date object.
513		* @throws Exception if an error occurs parsing the date.
514		*/
515		private Calendar parse(Class sourceType, Class targetType, String value) throws Exception {
516	109	Exception firstEx = null;
517	199	for (int i = 0; i < patterns.length; i++) {
518		try {
519	124	DateFormat format = getFormat(patterns[i]);
520	124	Calendar calendar = parse(sourceType, targetType, value, format);
521	34	return calendar;
522	90	} catch (Exception ex) {
523	90	if (firstEx == null) {
524	80	firstEx = ex;
525		}
526		}
527		}
528	75	if (patterns.length > 1) {
529	10	throw new ConversionException("Error converting '" + toString(sourceType) + "' to '" + toString(targetType)
530		+ "' using patterns '" + displayPatterns + "'");
531		} else {
532	65	throw firstEx;
533		}
534		}
535
536		/**
537		* Parse a String into a <code>Calendar</code> object
538		* using the specified <code>DateFormat</code>.
539		*
540		* @param sourceType The type of the value being converted
541		* @param targetType The type to convert the value to
542		* @param value The String date value.
543		* @param format The DateFormat to parse the String value.
544		*
545		* @return The converted Calendar object.
546		* @throws ConversionException if the String cannot be converted.
547		*/
548		private Calendar parse(Class sourceType, Class targetType, String value, DateFormat format) {
549	151	logFormat("Parsing", format);
550	151	format.setLenient(false);
551	151	ParsePosition pos = new ParsePosition(0);
552	151	Date parsedDate = format.parse(value, pos); // ignore the result (use the Calendar)
553	151	if (pos.getErrorIndex() >= 0 \|\| pos.getIndex() != value.length() \|\| parsedDate == null) {
554	111	String msg = "Error converting '" + toString(sourceType) + "' to '" + toString(targetType) + "'";
555	111	if (format instanceof SimpleDateFormat) {
556	111	msg += " using pattern '" + ((SimpleDateFormat)format).toPattern() + "'";
557		}
558	111	if (log().isDebugEnabled()) {
559	0	log().debug(" " + msg);
560		}
561	111	throw new ConversionException(msg);
562		}
563	40	Calendar calendar = format.getCalendar();
564	40	return calendar;
565		}
566
567		/**
568		* Provide a String representation of this date/time converter.
569		*
570		* @return A String representation of this date/time converter
571		*/
572		public String toString() {
573	5	StringBuffer buffer = new StringBuffer();
574	5	buffer.append(toString(getClass()));
575	5	buffer.append("[UseDefault=");
576	5	buffer.append(isUseDefault());
577	5	buffer.append(", UseLocaleFormat=");
578	5	buffer.append(useLocaleFormat);
579	5	if (displayPatterns != null) {
580	0	buffer.append(", Patterns={");
581	0	buffer.append(displayPatterns);
582	0	buffer.append('}');
583		}
584	5	if (locale != null) {
585	5	buffer.append(", Locale=");
586	5	buffer.append(locale);
587		}
588	5	if (timeZone != null) {
589	0	buffer.append(", TimeZone=");
590	0	buffer.append(timeZone);
591		}
592	5	buffer.append(']');
593	5	return buffer.toString();
594		}
595
596		/**
597		* Log the <code>DateFormat<code> creation.
598		* @param action The action the format is being used for
599		* @param format The Date format
600		*/
601		private void logFormat(String action, DateFormat format) {
602	191	if (log().isDebugEnabled()) {
603	0	StringBuffer buffer = new StringBuffer(45);
604	0	buffer.append(" ");
605	0	buffer.append(action);
606	0	buffer.append(" with Format");
607	0	if (format instanceof SimpleDateFormat) {
608	0	buffer.append("[");
609	0	buffer.append(((SimpleDateFormat)format).toPattern());
610	0	buffer.append("]");
611		}
612	0	buffer.append(" for ");
613	0	if (locale == null) {
614	0	buffer.append("default locale");
615		} else {
616	0	buffer.append("locale[");
617	0	buffer.append(locale);
618	0	buffer.append("]");
619		}
620	0	if (timeZone != null) {
621	0	buffer.append(", TimeZone[");
622	0	buffer.append(timeZone);
623	0	buffer.append("]");
624		}
625	0	log().debug(buffer.toString());
626		}
627	191	}
628		}