DateTimeConverters

/*******************************************************************************
 * 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.convert;

import java.sql.Time;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;

/** Date/time <code>Converter</code> classes. */
public class DateTimeConverters implements ConverterLoader {

    /**
     * Calendar format string: <code>EEE MMM dd HH:mm:ss.SSS z yyyy</code>.
     */
    public static final String CALENDAR_FORMAT = "EEE MMM dd HH:mm:ss.SSS z yyyy";
    /**
     * JDBC DATE format string: <code>yyyy-MM-dd</code>.
     */
    public static final String JDBC_DATE_FORMAT = "yyyy-MM-dd";
    /**
     * JDBC TIME format string: <code>HH:mm:ss</code>.
     */
    public static final String JDBC_TIME_FORMAT = "HH:mm:ss";

    /**
     * Returns an initialized DateFormat object.
     *
     * @param tz
     * @return DateFormat object
     */
    protected static DateFormat toDateFormat(TimeZone tz) {
        DateFormat df = new SimpleDateFormat(JDBC_DATE_FORMAT);
        df.setTimeZone(tz);
        return df;
    }

    /**
     * Returns an initialized DateFormat object.
     *
     * @param dateTimeFormat
     *            optional format string
     * @param tz
     * @param locale
     *            can be null if dateTimeFormat is not null
     * @return DateFormat object
     */
    protected static DateFormat toDateTimeFormat(String dateTimeFormat, TimeZone tz, Locale locale) {
        DateFormat df = null;
        if (Util.isEmpty(dateTimeFormat)) {
            df = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM, locale);
        } else {
            df = new SimpleDateFormat(dateTimeFormat);
        }
        df.setTimeZone(tz);
        return df;
    }

    /**
     * Returns an initialized DateFormat object.
     *
     * @param tz
     * @return DateFormat object
     */
    protected static DateFormat toTimeFormat(TimeZone tz) {
        DateFormat df = new SimpleDateFormat(JDBC_TIME_FORMAT);
        df.setTimeZone(tz);
        return df;
    }

    public void loadConverters() {
        Converters.loadContainedConverters(DateTimeConverters.class);
        Converters.registerConverter(new GenericDateToLong<java.util.Date>(java.util.Date.class));
        Converters.registerConverter(new GenericDateToLong<java.sql.Date>(java.sql.Date.class));
        Converters.registerConverter(new GenericDateToLong<java.sql.Time>(java.sql.Time.class));
        Converters.registerConverter(new GenericDateToLong<java.sql.Timestamp>(java.sql.Timestamp.class));
        Converters.registerConverter(new GenericSingletonToList<java.util.Calendar>(java.util.Calendar.class));
        Converters.registerConverter(new GenericSingletonToList<java.util.Date>(java.util.Date.class));
        Converters.registerConverter(new GenericSingletonToList<java.util.TimeZone>(java.util.TimeZone.class));
        Converters.registerConverter(new GenericSingletonToList<java.sql.Date>(java.sql.Date.class));
        Converters.registerConverter(new GenericSingletonToList<java.sql.Time>(java.sql.Time.class));
        Converters.registerConverter(new GenericSingletonToList<java.sql.Timestamp>(java.sql.Timestamp.class));
        Converters.registerConverter(new GenericSingletonToSet<java.util.Calendar>(java.util.Calendar.class));
        Converters.registerConverter(new GenericSingletonToSet<java.util.Date>(java.util.Date.class));
        Converters.registerConverter(new GenericSingletonToSet<java.util.TimeZone>(java.util.TimeZone.class));
        Converters.registerConverter(new GenericSingletonToSet<java.sql.Date>(java.sql.Date.class));
        Converters.registerConverter(new GenericSingletonToSet<java.sql.Time>(java.sql.Time.class));
        Converters.registerConverter(new GenericSingletonToSet<java.sql.Timestamp>(java.sql.Timestamp.class));
    }

    /**
     * An object that converts a <code>Calendar</code> to a <code>Date</code>.
     */
    public static class CalendarToDate extends AbstractConverter<Calendar, Date> {
        public CalendarToDate() {
            super(Calendar.class, Date.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return Util.instanceOf(sourceClass, this.getSourceClass()) && Date.class.equals(targetClass);
        }

        public Date convert(Calendar obj) throws ConversionException {
            return obj.getTime();
        }
    }

    /**
     * An object that converts a <code>Calendar</code> to a <code>Long</code>.
     */
    public static class CalendarToLong extends AbstractConverter<Calendar, Long> {
        public CalendarToLong() {
            super(Calendar.class, Long.class);
        }

        /**
         * Returns the millisecond value of <code>obj</code>.
         */
        public Long convert(Calendar obj) throws ConversionException {
            return obj.getTimeInMillis();
        }
    }

    /**
     * An object that converts a <code>Calendar</code> to a <code>String</code>.
     */
    public static class CalendarToString extends AbstractLocalizedConverter<Calendar, String> {
        public CalendarToString() {
            super(Calendar.class, String.class);
        }

        /**
         * Converts <code>obj</code> to a <code>String</code> formatted as
         * {@link DateTimeConverters#CALENDAR_FORMAT}. The returned string is
         * referenced to the default time zone.
         */
        public String convert(Calendar obj) throws ConversionException {
            DateFormat df = new SimpleDateFormat(CALENDAR_FORMAT);
            df.setCalendar(obj);
            return df.format(obj.getTime());
        }

        /**
         * Converts <code>obj</code> to a <code>String</code> using the supplied
         * locale, time zone, and format string. If <code>formatString</code> is
         * <code>null</code>, the string is formatted as
         * {@link DateTimeConverters#CALENDAR_FORMAT}.
         */
        public String convert(Calendar obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            DateFormat df = toDateTimeFormat(formatString == null ? CALENDAR_FORMAT : formatString, timeZone, locale);
            df.setCalendar(obj);
            return df.format(obj.getTime());
        }
    }

    /**
     * An object that converts a <code>Calendar</code> to a <code>Timestamp</code>.
     */
    public static class CalendarToTimestamp extends AbstractConverter<Calendar, Timestamp> {
        public CalendarToTimestamp() {
            super(Calendar.class, Timestamp.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return Util.instanceOf(sourceClass, this.getSourceClass()) && Timestamp.class.equals(targetClass);
        }

        public Timestamp convert(Calendar obj) throws ConversionException {
            return new Timestamp(obj.getTimeInMillis());
        }
    }


    /**
     * An object that converts a <code>Date</code> to a <code>Calendar</code>.
     */
    public static class DateToCalendar extends GenericLocalizedConverter<Date, Calendar> {
        public DateToCalendar() {
            super(Date.class, Calendar.class);
        }

        public Calendar convert(Date obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            Calendar cal = Calendar.getInstance(timeZone, locale);
            cal.setTime(obj);
            return cal;
        }
    }

    /**
     * An object that converts a <code>java.util.Date</code> to a
     * <code>java.sql.Date</code>.
     */
    public static class DateToSqlDate extends AbstractConverter<Date, java.sql.Date> {
        public DateToSqlDate() {
            super(Date.class, java.sql.Date.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return (java.util.Date.class.equals(sourceClass) || java.sql.Timestamp.class.equals(sourceClass)) && java.sql.Date.class.equals(targetClass);
        }

        /**
         * Returns <code>obj</code> converted to a <code>java.sql.Date</code>.
         */
        @SuppressWarnings("deprecation")
        public java.sql.Date convert(Date obj) throws ConversionException {
            Calendar cal = Calendar.getInstance();
            cal.setTimeInMillis(obj.getTime());
            return new java.sql.Date(cal.get(Calendar.YEAR) - 1900, cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH));
        }
    }

    /**
     * An object that converts a <code>java.util.Date</code> to a
     * <code>java.sql.Time</code>.
     */
    public static class DateToSqlTime extends AbstractConverter<java.util.Date, java.sql.Time> {
        public DateToSqlTime() {
            super(Date.class, java.sql.Time.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return sourceClass == this.getSourceClass() && targetClass == this.getTargetClass();
        }

        @SuppressWarnings("deprecation")
        public java.sql.Time convert(Date obj) throws ConversionException {
            Calendar cal = Calendar.getInstance();
            cal.setTimeInMillis(obj.getTime());
            return new java.sql.Time(cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE), cal.get(Calendar.SECOND));
        }
    }

    /**
     * An object that converts a <code>java.util.Date</code> to a
     * <code>String</code>.
     */
    public static class DateToString extends AbstractLocalizedConverter<Date, String> {
        public DateToString() {
            super(Date.class, String.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return Date.class.equals(sourceClass) && String.class.equals(targetClass);
        }

        /**
         * Converts <code>obj</code> to a <code>String</code> formatted as
         * {@link DateTimeConverters#CALENDAR_FORMAT}. The returned string is
         * referenced to the default time zone.
         */
        public String convert(Date obj) throws ConversionException {
            DateFormat df = new SimpleDateFormat(CALENDAR_FORMAT);
            return df.format(obj);
        }

        /**
         * Converts <code>obj</code> to a <code>String</code> using the supplied
         * locale, time zone, and format string. If <code>formatString</code> is
         * <code>null</code>, the string is formatted as
         * {@link DateTimeConverters#CALENDAR_FORMAT}.
         */
        public String convert(Date obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            DateFormat df = toDateTimeFormat(formatString == null ? CALENDAR_FORMAT : formatString, timeZone, locale);
            return df.format(obj);
        }
    }

    /**
     * An object that converts a <code>java.util.Date</code> to a
     * <code>java.sql.Timestamp</code>.
     */
    public static class DateToTimestamp extends AbstractConverter<Date, java.sql.Timestamp> {
        public DateToTimestamp() {
            super(Date.class, java.sql.Timestamp.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return (java.util.Date.class.equals(sourceClass) || java.sql.Timestamp.class.equals(sourceClass)) && java.sql.Timestamp.class.equals(targetClass);
        }

        /**
         * Returns <code>obj</code> converted to a <code>java.sql.Timestamp</code>.
         */
        public java.sql.Timestamp convert(Date obj) throws ConversionException {
            return new java.sql.Timestamp(obj.getTime());
        }
    }

    /**
     * An object that converts a <code>java.util.Date</code> (and its subclasses) to a
     * <code>Long</code>.
     */
    public static class GenericDateToLong<S extends Date> extends AbstractConverter<S, Long> {
        public GenericDateToLong(Class<S> source) {
            super(source, Long.class);
        }

        /**
         * Returns the millisecond value of <code>obj</code>.
         */
        public Long convert(S obj) throws ConversionException {
            return obj.getTime();
        }
    }

    public static abstract class GenericLocalizedConverter<S, T> extends AbstractLocalizedConverter<S, T> {
        protected GenericLocalizedConverter(Class<S> sourceClass, Class<T> targetClass) {
            super(sourceClass, targetClass);
        }

        public T convert(S obj) throws ConversionException {
            return convert(obj, Locale.getDefault(), TimeZone.getDefault(), null);
        }

        public T convert(S obj, Locale locale, TimeZone timeZone) throws ConversionException {
            return convert(obj, locale, timeZone, null);
        }
    }

    /**
     * An object that converts a <code>Long</code> to a
     * <code>Calendar</code>.
     */
    public static class LongToCalendar extends AbstractLocalizedConverter<Long, Calendar> {
        public LongToCalendar() {
            super(Long.class, Calendar.class);
        }

        /**
         * Returns <code>obj</code> converted to a <code>Calendar</code>,
         * initialized with the default locale and time zone.
         */
        public Calendar convert(Long obj) throws ConversionException {
            Calendar cal = Calendar.getInstance();
            cal.setTimeInMillis(obj);
            return cal;
        }

        /**
         * Returns <code>obj</code> converted to a <code>Calendar</code>,
         * initialized with the specified locale and time zone. The
         * <code>formatString</code> parameter is ignored.
         */
        public Calendar convert(Long obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            Calendar cal = Calendar.getInstance(timeZone, locale);
            cal.setTimeInMillis(obj);
            return cal;
        }
    }

    /**
     * An object that converts a <code>Long</code> to a
     * <code>java.util.Date</code>.
     */
    public static class LongToDate extends AbstractConverter<Long, Date> {
        public LongToDate() {
            super(Long.class, Date.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return Long.class.equals(sourceClass) && Date.class.equals(targetClass);
        }

        /**
         * Returns <code>obj</code> converted to a <code>java.util.Date</code>.
         */
        public Date convert(Long obj) throws ConversionException {
            return new Date(obj.longValue());
        }
    }

    /**
     * An object that converts a <code>Long</code> to a
     * <code>java.sql.Date</code>.
     */
    public static class LongToSqlDate extends AbstractConverter<Long, java.sql.Date> {
        public LongToSqlDate() {
            super(Long.class, java.sql.Date.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return Long.class.equals(sourceClass) && java.sql.Date.class.equals(targetClass);
        }

        /**
         * Returns <code>obj</code> converted to a <code>java.sql.Date</code>.
         */
        public java.sql.Date convert(Long obj) throws ConversionException {
            return new java.sql.Date(obj.longValue());
        }
    }

    /**
     * An object that converts a <code>Long</code> to a
     * <code>java.sql.Time</code>.
     */
    public static class LongToSqlTime extends AbstractConverter<Long, java.sql.Time> {
        public LongToSqlTime() {
            super(Long.class, java.sql.Time.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return Long.class.equals(sourceClass) && java.sql.Time.class.equals(targetClass);
        }

        /**
         * Returns <code>obj</code> converted to a <code>java.sql.Time</code>.
         */
        public java.sql.Time convert(Long obj) throws ConversionException {
            return new java.sql.Time(obj.longValue());
        }
    }

    /**
     * An object that converts a <code>Long</code> to a
     * <code>java.sql.Timestamp</code>.
     */
    public static class LongToTimestamp extends AbstractConverter<Long, java.sql.Timestamp> {
        public LongToTimestamp() {
            super(Long.class, java.sql.Timestamp.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return Long.class.equals(sourceClass) && java.sql.Timestamp.class.equals(targetClass);
        }

        /**
         * Returns <code>obj</code> converted to a <code>java.sql.Timestamp</code>.
         */
        public java.sql.Timestamp convert(Long obj) throws ConversionException {
            return new java.sql.Timestamp(obj.longValue());
        }
    }

    /**
     * An object that converts a <code>java.sql.Date</code> to a
     * <code>java.util.Date</code>.
     */
    public static class SqlDateToDate extends AbstractConverter<java.sql.Date, Date> {
        public SqlDateToDate() {
            super(java.sql.Date.class, Date.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return java.sql.Date.class.equals(sourceClass) && java.util.Date.class.equals(targetClass);
        }

        /**
         * Returns <code>obj</code> converted to a <code>java.util.Date</code>.
         */
        public Date convert(java.sql.Date obj) throws ConversionException {
            return new Date(obj.getTime());
        }
    }

    /**
     * An object that converts a <code>java.sql.Date</code> to a
     * <code>String</code>.
     */
    public static class SqlDateToString extends AbstractLocalizedConverter<java.sql.Date, String> {
        public SqlDateToString() {
            super(java.sql.Date.class, String.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return java.sql.Date.class.equals(sourceClass) && String.class.equals(targetClass);
        }

        public String convert(java.sql.Date obj) throws ConversionException {
            return obj.toString();
        }

        /**
         * Converts <code>obj</code> to a <code>String</code> using the supplied
         * time zone. The <code>formatString</code> parameter is
         * ignored. The returned string is formatted as
         * {@link DateTimeConverters#JDBC_DATE_FORMAT}.
         */
        public String convert(java.sql.Date obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            DateFormat df = toDateFormat(timeZone);
            return df.format(obj);
        }
    }

    /**
     * An object that converts a <code>java.sql.Date</code> to a
     * <code>java.sql.Timestamp</code>.
     */
    public static class SqlDateToTimestamp extends AbstractConverter<java.sql.Date, java.sql.Timestamp> {
        public SqlDateToTimestamp() {
            super(java.sql.Date.class, java.sql.Timestamp.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return java.sql.Date.class.equals(sourceClass) && java.sql.Timestamp.class.equals(targetClass);
        }

        /**
         * Returns <code>obj</code> converted to a <code>java.sql.Timestamp</code>.
         */
        public java.sql.Timestamp convert(java.sql.Date obj) throws ConversionException {
            return new java.sql.Timestamp(obj.getTime());
        }
    }

    /**
     * An object that converts a <code>java.sql.Time</code> to a
     * <code>String</code>.
     */
    public static class SqlTimeToString extends AbstractLocalizedConverter<java.sql.Time, String> {
        public SqlTimeToString() {
            super(java.sql.Time.class, String.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return java.sql.Time.class.equals(sourceClass) && String.class.equals(targetClass);
        }

        public String convert(java.sql.Time obj) throws ConversionException {
            return obj.toString();
        }

        /**
         * Converts <code>obj</code> to a <code>String</code> using the supplied
         * time zone. The <code>formatString</code> parameter is
         * ignored. The returned string is formatted as
         * {@link DateTimeConverters#JDBC_TIME_FORMAT}.
         */
        public String convert(java.sql.Time obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            DateFormat df = toTimeFormat(timeZone);
            return df.format(obj);
        }
    }

    /**
     * An object that converts a <code>String</code> to a
     * <code>java.util.Calendar</code>.
     */
    public static class StringToCalendar extends AbstractLocalizedConverter<String, Calendar> {
        public StringToCalendar() {
            super(String.class, Calendar.class);
        }

        /**
         * Converts <code>obj</code> to a <code>java.util.Calendar</code> initialized to
         * the default locale and time zone. The string must be formatted as
         * {@link DateTimeConverters#CALENDAR_FORMAT}.
         */
        public Calendar convert(String obj) throws ConversionException {
            try {
                DateFormat df = new SimpleDateFormat(CALENDAR_FORMAT);
                Calendar cal = Calendar.getInstance();
                cal.setTime(df.parse(obj));
                return cal;
            } catch (ParseException e) {
                throw new ConversionException(e);
            }
        }

        /**
         * Converts <code>obj</code> to a <code>java.util.Calendar</code> initialized to
         * the supplied locale and time zone. If <code>formatString</code> is
         * <code>null</code>, the string is formatted as
         * {@link DateTimeConverters#CALENDAR_FORMAT}.
         */
        public Calendar convert(String obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            DateFormat df = toDateTimeFormat(formatString == null ? CALENDAR_FORMAT : formatString, timeZone, locale);
            try {
                Date date = df.parse(obj);
                Calendar cal = Calendar.getInstance(timeZone, locale);
                cal.setTimeInMillis(date.getTime());
                return cal;
            } catch (ParseException e) {
                throw new ConversionException(e);
            }
        }
    }

    /**
     * An object that converts a <code>String</code> to a
     * <code>java.util.Date</code>.
     */
    public static class StringToDate extends AbstractLocalizedConverter<String, Date> {
        public StringToDate() {
            super(String.class, Date.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return String.class.equals(sourceClass) && Date.class.equals(targetClass);
        }

        /**
         * Converts <code>obj</code> to a <code>java.util.Date</code>.
         * The string must be formatted as
         * {@link DateTimeConverters#CALENDAR_FORMAT}.
         */
        public Date convert(String obj) throws ConversionException {
            try {
                DateFormat df = new SimpleDateFormat(CALENDAR_FORMAT);
                return df.parse(obj);
            } catch (ParseException e) {
                throw new ConversionException(e);
            }
        }

        /**
         * Converts <code>obj</code> to a <code>java.util.Date</code>. If
         * <code>formatString</code> is <code>null</code>, the string is formatted as
         * {@link DateTimeConverters#CALENDAR_FORMAT}.
         */
        public Date convert(String obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            DateFormat df = toDateTimeFormat(formatString == null ? CALENDAR_FORMAT : formatString, timeZone, locale);
            try {
                return df.parse(obj);
            } catch (ParseException e) {
                throw new ConversionException(e);
            }
        }
    }

    /**
     * An object that converts a <code>String</code> to a
     * <code>java.sql.Date</code>.
     */
    public static class StringToSqlDate extends AbstractLocalizedConverter<String, java.sql.Date> {
        public StringToSqlDate() {
            super(String.class, java.sql.Date.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return String.class.equals(sourceClass) && java.sql.Date.class.equals(targetClass);
        }

        public java.sql.Date convert(String obj) throws ConversionException {
            return java.sql.Date.valueOf(obj);
        }

        /**
         * Converts <code>obj</code> to a <code>java.sql.Date</code> using the supplied
         * time zone. The <code>locale</code> and <code>formatString</code> parameters are
         * ignored. The string must be formatted as
         * {@link DateTimeConverters#JDBC_DATE_FORMAT}.
         */
        public java.sql.Date convert(String obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            DateFormat df = toDateFormat(timeZone);
            try {
                return new java.sql.Date(df.parse(obj).getTime());
            } catch (ParseException e) {
                throw new ConversionException(e);
            }
        }
    }

    /**
     * An object that converts a <code>String</code> to a
     * <code>java.sql.Time</code>.
     */
    public static class StringToSqlTime extends AbstractLocalizedConverter<String, java.sql.Time> {
        public StringToSqlTime() {
            super(String.class, java.sql.Time.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return String.class.equals(sourceClass) && java.sql.Time.class.equals(targetClass);
        }

        public java.sql.Time convert(String obj) throws ConversionException {
            return java.sql.Time.valueOf(obj);
        }

        /**
         * Converts <code>obj</code> to a <code>java.sql.Time</code> using the supplied
         * time zone. The <code>locale</code> and <code>formatString</code> parameters are
         * ignored. The string must be formatted as
         * {@link DateTimeConverters#JDBC_TIME_FORMAT}.
         */
        public Time convert(String obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            DateFormat df = toTimeFormat(timeZone);
            try {
                return new java.sql.Time(df.parse(obj).getTime());
            } catch (ParseException e) {
                throw new ConversionException(e);
            }
        }
    }

    /**
     * An object that converts a <code>String</code> to a
     * <code>java.sql.Timestamp</code>.
     */
    public static class StringToTimestamp extends AbstractLocalizedConverter<String, java.sql.Timestamp> {
        public StringToTimestamp() {
            super(String.class, java.sql.Timestamp.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return String.class.equals(sourceClass) && java.sql.Timestamp.class.equals(targetClass);
        }

        public Timestamp convert(String obj) throws ConversionException {
            return java.sql.Timestamp.valueOf(obj);
        }

        /**
         * Converts <code>obj</code> to a <code>java.sql.Timestamp</code>.
         * <p>Note that the string representation is referenced to the <code>timeZone</code>
         * argument, not UTC. The <code>Timestamp</code> that is returned is adjusted to UTC.
         * This behavior is intended to accommodate user-entered timestamps, where users are
         * accustomed to using their own time zone.</p>
         * </p>
         */
        public java.sql.Timestamp convert(String obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            try {
                // The String is referenced to the time zone represented by the timeZone
                // argument, but the parsing code assumes a reference to UTC. So, we need
                // to "adjust" the parsed Timestamp's value.
                Timestamp parsedStamp = Timestamp.valueOf(obj);
                Calendar cal = Calendar.getInstance(timeZone, locale);
                cal.setTime(parsedStamp);
                cal.add(Calendar.MILLISECOND, 0 - timeZone.getOffset(parsedStamp.getTime()));
                Timestamp result = new Timestamp(cal.getTimeInMillis());
                result.setNanos(parsedStamp.getNanos());
                return result;
            } catch (Exception e) {
                throw new ConversionException(e);
            }
        }
    }

    /**
     * An object that converts a <code>String</code> ID to a
     * <code>java.util.TimeZone</code>.
     */
    public static class StringToTimeZone extends AbstractConverter<String, TimeZone> {
        public StringToTimeZone() {
            super(String.class, TimeZone.class);
        }

        public TimeZone convert(String obj) throws ConversionException {
            return TimeZone.getTimeZone(obj);
        }
    }

    /**
     * An object that converts a <code>java.sql.Timestamp</code> to a
     * <code>java.util.Date</code>.
     */
    public static class TimestampToDate extends AbstractConverter<java.sql.Timestamp, Date> {
        public TimestampToDate() {
            super(java.sql.Timestamp.class, Date.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return java.sql.Timestamp.class.equals(sourceClass) && java.util.Date.class.equals(targetClass);
        }

        public Date convert(java.sql.Timestamp obj) throws ConversionException {
            return new Timestamp(obj.getTime());
        }
    }

    /**
     * An object that converts a <code>java.sql.Timestamp</code> to a
     * <code>java.sql.Date</code>.
     */
    public static class TimestampToSqlDate extends AbstractConverter<java.sql.Timestamp, java.sql.Date> {
        public TimestampToSqlDate() {
            super(java.sql.Timestamp.class, java.sql.Date.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return java.sql.Timestamp.class.equals(sourceClass) && java.sql.Date.class.equals(targetClass);
        }

        public java.sql.Date convert(java.sql.Timestamp obj) throws ConversionException {
            return new java.sql.Date(obj.getTime());
        }
    }

    /**
     * An object that converts a <code>java.sql.Timestamp</code> to a
     * <code>java.sql.Time</code>.
     */
    public static class TimestampToSqlTime extends AbstractConverter<java.sql.Timestamp, java.sql.Time> {
        public TimestampToSqlTime() {
            super(java.sql.Timestamp.class, java.sql.Time.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return java.sql.Timestamp.class.equals(sourceClass) && java.sql.Time.class.equals(targetClass);
        }

        public java.sql.Time convert(java.sql.Timestamp obj) throws ConversionException {
            return new java.sql.Time(obj.getTime());
        }
    }

    /**
     * An object that converts a <code>java.sql.Timestamp</code> to a
     * <code>String</code>.
     */
    public static class TimestampToString extends AbstractLocalizedConverter<java.sql.Timestamp, String> {
        public TimestampToString() {
            super(java.sql.Timestamp.class, String.class);
        }

        @Override
        public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
            return java.sql.Timestamp.class.equals(sourceClass) && String.class.equals(targetClass);
        }

        public String convert(java.sql.Timestamp obj) throws ConversionException {
            return obj.toString();
        }

        /**
         * Converts <code>obj</code> to a <code>String</code> using the supplied
         * time zone.
         * <p>Note that the string representation is referenced to the <code>timeZone</code>
         * argument, not UTC. The <code>Timestamp</code> is adjusted to the specified
         * time zone before conversion. This behavior is intended to accommodate user interfaces,
         * where users are accustomed to viewing timestamps in their own time zone.</p>
         * </p>
         */
        public String convert(Timestamp obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            try {
                // The Timestamp is referenced to UTC, but the String result needs to be
                // referenced to the time zone represented by the timeZone argument.
                // So, we need to "adjust" the Timestamp's value before conversion.
                Calendar cal = Calendar.getInstance(timeZone, locale);
                cal.setTime(obj);
                cal.add(Calendar.MILLISECOND, timeZone.getOffset(obj.getTime()));
                Timestamp result = new Timestamp(cal.getTimeInMillis());
                result.setNanos(obj.getNanos());
                return result.toString();
            } catch (Exception e) {
                throw new ConversionException(e);
            }
        }
    }

    /**
     * An object that converts a <code>java.util.TimeZone</code> to a
     * <code>String</code> ID.
     */
    public static class TimeZoneToString extends AbstractConverter<TimeZone, String> {
        public TimeZoneToString() {
            super(TimeZone.class, String.class);
        }

        public String convert(TimeZone obj) throws ConversionException {
            return obj.getID();
        }
    }
}