Class DateUtil


  • public abstract class DateUtil
    extends Object
    Utility class supplying static methods. Date serialization is based on the algorithms published by Peter Baum (http://www.capecod.net/~pbaum). All date handling is done according to the W3C Schema specification, which uses a proleptic Gregorian calendar with no year 0. Note that this differs from the Java date handling, which uses a discontinuous Gregorian calendar.
    Author:
    Dennis M. Sosnoski
    • Constructor Detail

      • DateUtil

        public DateUtil()
    • Method Detail

      • parseInt

        public static int parseInt​(String text)
                            throws IllegalArgumentException
        Parse integer value from text. Integer values are parsed with optional leading sign flag, followed by any number of digits.
        Parameters:
        text - text to be parsed
        Returns:
        converted integer value
        Throws:
        IllegalArgumentException - on parse error
      • serializeInt

        public static String serializeInt​(int value)
        Serialize int value to text.
        Parameters:
        value - int value to be serialized
        Returns:
        text representation of value
      • parseLong

        public static long parseLong​(String text)
                              throws IllegalArgumentException
        Parse long value from text. Long values are parsed with optional leading sign flag, followed by any number of digits.
        Parameters:
        text - text to be parsed
        Returns:
        converted long value
        Throws:
        IllegalArgumentException - on parse error
      • serializeLong

        public static String serializeLong​(long value)
        Serialize long value to text.
        Parameters:
        value - long value to be serialized
        Returns:
        text representation of value
      • parseShort

        public static short parseShort​(String text)
                                throws IllegalArgumentException
        Parse short value from text. Short values are parsed with optional leading sign flag, followed by any number of digits.
        Parameters:
        text - text to be parsed
        Returns:
        converted short value
        Throws:
        IllegalArgumentException - on parse error
      • serializeShort

        public static String serializeShort​(short value)
        Serialize short value to text.
        Parameters:
        value - short value to be serialized
        Returns:
        text representation of value
      • parseByte

        public static byte parseByte​(String text)
                              throws IllegalArgumentException
        Parse byte value from text. Byte values are parsed with optional leading sign flag, followed by any number of digits.
        Parameters:
        text - text to be parsed
        Returns:
        converted byte value
        Throws:
        IllegalArgumentException - on parse error
      • serializeByte

        public static String serializeByte​(byte value)
        Serialize byte value to text.
        Parameters:
        value - byte value to be serialized
        Returns:
        text representation of value
      • parseBoolean

        public static boolean parseBoolean​(String text)
                                    throws IllegalArgumentException
        Parse boolean value from text. Boolean values are parsed as either text "true" and "false", or "1" and "0" numeric equivalents.
        Parameters:
        text - text to be parsed
        Returns:
        converted boolean value
        Throws:
        IllegalArgumentException - on parse error
      • serializeBoolean

        public static String serializeBoolean​(boolean value)
        Serialize boolean value to text. This serializes the value using the text representation as "true" or "false".
        Parameters:
        value - boolean value to be serialized
        Returns:
        text representation of value
      • parseChar

        public static char parseChar​(String text)
                              throws IllegalArgumentException
        Parse char value from text as unsigned 16-bit integer. Char values are parsed with optional leading sign flag, followed by any number of digits.
        Parameters:
        text - text to be parsed
        Returns:
        converted char value
        Throws:
        IllegalArgumentException - on parse error
      • serializeChar

        public static String serializeChar​(char value)
        Serialize char value to text as unsigned 16-bit integer.
        Parameters:
        value - char value to be serialized
        Returns:
        text representation of value
      • parseCharString

        public static char parseCharString​(String text)
                                    throws IllegalArgumentException
        Parse char value from text as character value. This requires that the string must be of length one.
        Parameters:
        text - text to be parsed
        Returns:
        converted char value
        Throws:
        IllegalArgumentException - on parse error
      • deserializeCharString

        public static char deserializeCharString​(String text)
                                          throws IllegalArgumentException
        Deserialize char value from text as character value. This requires that the string must be null or of length one.
        Parameters:
        text - text to be parsed (may be null)
        Returns:
        converted char value
        Throws:
        IllegalArgumentException - on parse error
      • serializeCharString

        public static String serializeCharString​(char value)
        Serialize char value to text as string of length one.
        Parameters:
        value - char value to be serialized
        Returns:
        text representation of value
      • parseFloat

        public static float parseFloat​(String text)
                                throws IllegalArgumentException
        Parse float value from text. This uses the W3C XML Schema format for floats, with the exception that it will accept "+NaN" and "-NaN" as valid formats. This is not in strict compliance with the specification, but is included for interoperability with other Java XML processing.
        Parameters:
        text - text to be parsed
        Returns:
        converted float value
        Throws:
        IllegalArgumentException - on parse error
      • serializeFloat

        public static String serializeFloat​(float value)
        Serialize float value to text.
        Parameters:
        value - float value to be serialized
        Returns:
        text representation of value
      • parseDouble

        public static double parseDouble​(String text)
                                  throws IllegalArgumentException
        Parse double value from text. This uses the W3C XML Schema format for doubles, with the exception that it will accept "+NaN" and "-NaN" as valid formats. This is not in strict compliance with the specification, but is included for interoperability with other Java XML processing.
        Parameters:
        text - text to be parsed
        Returns:
        converted double value
        Throws:
        IllegalArgumentException - on parse error
      • serializeDouble

        public static String serializeDouble​(double value)
        Serialize double value to text.
        Parameters:
        value - double value to be serialized
        Returns:
        text representation of value
      • parseYear

        public static long parseYear​(String text)
                              throws IllegalArgumentException
        Convert gYear text to Java date. Date values are expected to be in W3C XML Schema standard format as CCYY, with optional leading sign.
        Parameters:
        text - text to be parsed
        Returns:
        start of year date as millisecond value from 1 C.E.
        Throws:
        IllegalArgumentException - on parse error
      • parseYearMonth

        public static long parseYearMonth​(String text)
                                   throws IllegalArgumentException
        Convert gYearMonth text to Java date. Date values are expected to be in W3C XML Schema standard format as CCYY-MM, with optional leading sign.
        Parameters:
        text - text to be parsed
        Returns:
        start of month in year date as millisecond value
        Throws:
        IllegalArgumentException - on parse error
      • parseDate

        public static long parseDate​(String text)
                              throws IllegalArgumentException
        Convert date text to Java date. Date values are expected to be in W3C XML Schema standard format as CCYY-MM-DD, with optional leading sign and trailing time zone (though the time zone is ignored in this case).
        Parameters:
        text - text to be parsed
        Returns:
        start of day in month and year date as millisecond value
        Throws:
        IllegalArgumentException - on parse error
      • deserializeDate

        public static Date deserializeDate​(String text)
                                    throws IllegalArgumentException
        Deserialize date from text. Date values are expected to match W3C XML Schema standard format as CCYY-MM-DD, with optional leading minus sign if necessary. This method follows standard JiBX deserializer usage requirements by accepting a null input.
        Parameters:
        text - text to be parsed (may be null)
        Returns:
        converted date, or null if passed null input
        Throws:
        IllegalArgumentException - on parse error
      • deserializeSqlDate

        public static Date deserializeSqlDate​(String text)
                                       throws IllegalArgumentException
        Deserialize SQL date from text. Date values are expected to match W3C XML Schema standard format as CCYY-MM-DD, with optional leading minus sign if necessary. This method follows standard JiBX deserializer usage requirements by accepting a null input.
        Parameters:
        text - text to be parsed (may be null)
        Returns:
        converted date, or null if passed null input
        Throws:
        IllegalArgumentException - on parse error
      • parseTime

        public static long parseTime​(String text,
                                     int start,
                                     int length)
                              throws IllegalArgumentException
        Parse general time value from text. Time values are expected to be in W3C XML Schema standard format as hh:mm:ss.fff, with optional leading sign and trailing time zone.
        Parameters:
        text - text to be parsed
        start - offset of first character of time value
        length - number of characters in time value
        Returns:
        converted time as millisecond value
        Throws:
        IllegalArgumentException - on parse error
      • parseDateTime

        public static long parseDateTime​(String text)
                                  throws IllegalArgumentException
        Parse general dateTime value from text. Date values are expected to be in W3C XML Schema standard format as CCYY-MM-DDThh:mm:ss.fff, with optional leading sign and trailing time zone.
        Parameters:
        text - text to be parsed
        Returns:
        converted date as millisecond value
        Throws:
        IllegalArgumentException - on parse error
      • deserializeDateTime

        public static Date deserializeDateTime​(String text)
                                        throws IllegalArgumentException
        Deserialize date from general dateTime text. Date values are expected to match W3C XML Schema standard format as CCYY-MM-DDThh:mm:ss, with optional leading minus sign and trailing seconds decimal, as necessary. This method follows standard JiBX deserializer usage requirements by accepting a null input.
        Parameters:
        text - text to be parsed (may be null)
        Returns:
        converted date, or null if passed null input
        Throws:
        IllegalArgumentException - on parse error
      • deserializeTimestamp

        public static Timestamp deserializeTimestamp​(String text)
                                              throws IllegalArgumentException
        Deserialize timestamp from general dateTime text. Timestamp values are represented in the same way as regular dates, but allow more precision in the fractional second value (down to nanoseconds). This method follows standard JiBX deserializer usage requirements by accepting a null input.
        Parameters:
        text - text to be parsed (may be null)
        Returns:
        converted timestamp, or null if passed null input
        Throws:
        IllegalArgumentException - on parse error
      • deserializeSqlTime

        public static Time deserializeSqlTime​(String text)
                                       throws IllegalArgumentException
        Deserialize time from text. Time values obey the rules of the time portion of a dataTime value. This method follows standard JiBX deserializer usage requirements by accepting a null input.
        Parameters:
        text - text to be parsed (may be null)
        Returns:
        converted time, or null if passed null input
        Throws:
        IllegalArgumentException - on parse error
      • formatYearNumber

        protected static void formatYearNumber​(long year,
                                               StringBuffer buff)
        Format year number consistent with W3C XML Schema definitions, using a minimum of four digits padded with zeros if necessary. A leading minus sign is included for years prior to 1 C.E.
        Parameters:
        year - number to be formatted
        buff - text formatting buffer
      • formatTwoDigits

        protected static void formatTwoDigits​(int value,
                                              StringBuffer buff)
        Format a positive number as two digits. This uses an optional leading zero digit for values less than ten.
        Parameters:
        value - number to be formatted (0 to 99)
        buff - text formatting buffer
      • formatYear

        protected static void formatYear​(long value,
                                         StringBuffer buff)
        Format time in milliseconds to year number. The resulting year number format is consistent with W3C XML Schema definitions, using a minimum of four digits padded with zeros if necessary. A leading minus sign is included for years prior to 1 C.E.
        Parameters:
        value - time in milliseconds to be converted (from 1 C.E.)
        buff - text formatting buffer
      • formatYearMonth

        protected static long formatYearMonth​(long value,
                                              StringBuffer buff)
        Format time in milliseconds to year number and month number. The resulting year number format is consistent with W3C XML Schema definitions, using a minimum of four digits for the year and exactly two digits for the month.
        Parameters:
        value - time in milliseconds to be converted (from 1 C.E.)
        buff - text formatting buffer
        Returns:
        number of milliseconds into month
      • formatYearMonthDay

        protected static int formatYearMonthDay​(long value,
                                                StringBuffer buff)
        Format time in milliseconds to year number, month number, and day number. The resulting year number format is consistent with W3C XML Schema definitions, using a minimum of four digits for the year and exactly two digits each for the month and day.
        Parameters:
        value - time in milliseconds to be converted (from 1 C.E.)
        buff - text formatting buffer
        Returns:
        number of milliseconds into day
      • serializeYear

        public static String serializeYear​(long time)
                                    throws IllegalArgumentException
        Serialize time to general gYear text. Date values are formatted in W3C XML Schema standard format as CCYY, with optional leading sign included if necessary.
        Parameters:
        time - time to be converted, as milliseconds from January 1, 1970
        Returns:
        converted gYear text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeYear

        public static String serializeYear​(Date date)
                                    throws IllegalArgumentException
        Serialize date to general gYear text. Date values are formatted in W3C XML Schema standard format as CCYY, with optional leading sign included if necessary.
        Parameters:
        date - date to be converted
        Returns:
        converted gYear text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeYearMonth

        public static String serializeYearMonth​(long time)
                                         throws IllegalArgumentException
        Serialize time to general gYearMonth text. Date values are formatted in W3C XML Schema standard format as CCYY-MM, with optional leading sign included if necessary.
        Parameters:
        time - time to be converted, as milliseconds from January 1, 1970
        Returns:
        converted gYearMonth text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeYearMonth

        public static String serializeYearMonth​(Date date)
                                         throws IllegalArgumentException
        Serialize date to general gYearMonth text. Date values are formatted in W3C XML Schema standard format as CCYY-MM, with optional leading sign included if necessary.
        Parameters:
        date - date to be converted
        Returns:
        converted gYearMonth text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeDate

        public static String serializeDate​(long time)
                                    throws IllegalArgumentException
        Serialize time to general date text. Date values are formatted in W3C XML Schema standard format as CCYY-MM-DD, with optional leading sign included if necessary.
        Parameters:
        time - time to be converted, as milliseconds from January 1, 1970
        Returns:
        converted date text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeDate

        public static String serializeDate​(Date date)
                                    throws IllegalArgumentException
        Serialize date to general date text. Date values are formatted in W3C XML Schema standard format as CCYY-MM-DD, with optional leading sign included if necessary.
        Parameters:
        date - date to be converted
        Returns:
        converted date text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeSqlDate

        public static String serializeSqlDate​(Date date)
                                       throws IllegalArgumentException
        Serialize SQL date to general date text. Date values are formatted in W3C XML Schema standard format as CCYY-MM-DD, with optional leading sign included if necessary.
        Parameters:
        date - date to be converted
        Returns:
        converted date text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeTime

        public static void serializeTime​(int time,
                                         StringBuffer buff)
                                  throws IllegalArgumentException
        Serialize time to general time text in buffer. Time values are formatted in W3C XML Schema standard format as hh:mm:ss, with optional trailing seconds decimal, as necessary. This form uses a supplied buffer to support flexible use, including with dateTime combination values.
        Parameters:
        time - time to be converted, as milliseconds in day
        buff - buffer for appending time text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeDateTime

        public static String serializeDateTime​(long time,
                                               boolean zone)
                                        throws IllegalArgumentException
        Serialize time to general dateTime text. Date values are formatted in W3C XML Schema standard format as CCYY-MM-DDThh:mm:ss, with optional leading sign and trailing seconds decimal, as necessary.
        Parameters:
        time - time to be converted, as milliseconds from January 1, 1970
        zone - flag for trailing 'Z' to be appended to indicate UTC
        Returns:
        converted dateTime text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeDateTime

        public static String serializeDateTime​(long time)
                                        throws IllegalArgumentException
        Serialize time to general dateTime text. This method is provided for backward compatibility. It generates the dateTime text without the trailing 'Z' to indicate UTC.
        Parameters:
        time - time to be converted, as milliseconds from January 1, 1970
        Returns:
        converted dateTime text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeDateTime

        public static String serializeDateTime​(Date date)
                                        throws IllegalArgumentException
        Serialize date to general dateTime text. Date values are formatted in W3C XML Schema standard format as CCYY-MM-DDThh:mm:ss, with optional leading sign and trailing seconds decimal, as necessary.
        Parameters:
        date - date to be converted
        Returns:
        converted dateTime text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeTimestamp

        public static String serializeTimestamp​(Timestamp stamp)
                                         throws IllegalArgumentException
        Serialize timestamp to general dateTime text. Timestamp values are represented in the same way as regular dates, but allow more precision in the fractional second value (down to nanoseconds).
        Parameters:
        stamp - timestamp to be converted
        Returns:
        converted dateTime text
        Throws:
        IllegalArgumentException - on conversion error
      • serializeSqlTime

        public static String serializeSqlTime​(Time time)
                                       throws IllegalArgumentException
        Serialize time to standard text. Time values are formatted in W3C XML Schema standard format as hh:mm:ss, with optional trailing seconds decimal, as necessary. The standard conversion does not append a time zone indication.
        Parameters:
        time - time to be converted
        Returns:
        converted time text
        Throws:
        IllegalArgumentException - on conversion error
      • isEqual

        public static boolean isEqual​(Object a,
                                      Object b)
        General object comparison method. Don't know why Sun hasn't seen fit to include this somewhere, but at least it's easy to write (over and over again).
        Parameters:
        a - first object to be compared
        b - second object to be compared
        Returns:
        true if both objects are null, or if a.equals(b) ; false otherwise
      • enumValue

        public static int enumValue​(String target,
                                    String[] enums,
                                    int[] vals)
                             throws IllegalArgumentException
        Find text value in enumeration. This first does a binary search through an array of allowed text matches. If a separate array of corresponding values is supplied, the value at the matched position is returned; otherwise the match index is returned directly.
        Parameters:
        target - text to be found in enumeration
        enums - ordered array of texts included in enumeration
        vals - array of values to be returned for corresponding text match positions (position returned directly if this is null)
        Returns:
        enumeration value for target text
        Throws:
        IllegalArgumentException - if target text not found in enumeration
      • parseBase64

        public static byte[] parseBase64​(String text)
                                  throws IllegalArgumentException
        Parse base64 data from text. This converts the base64 data into a byte array of the appopriate length. In keeping with the recommendations,
        Parameters:
        text - text to be parsed (may include extra characters)
        Returns:
        byte array of data
        Throws:
        IllegalArgumentException - if invalid character in base64 representation
      • deserializeBase64

        public static byte[] deserializeBase64​(String text)
                                        throws IllegalArgumentException
        Parse base64 data from text. This converts the base64 data into a byte array of the appopriate length. In keeping with the recommendations,
        Parameters:
        text - text to be parsed (may be null, or include extra characters)
        Returns:
        byte array of data
        Throws:
        IllegalArgumentException - if invalid character in base64 representation
      • encodeChunk

        public static void encodeChunk​(int base,
                                       byte[] byts,
                                       StringBuffer buff)
        Encode a chunk of data to base64 encoding. Converts the next three bytes of data into four characters of text representation, using padding at the end of less than three bytes of data remain.
        Parameters:
        base - starting offset within byte array
        byts - byte data array
        buff - buffer for encoded text
      • serializeBase64

        public static String serializeBase64​(byte[] byts)
        Serialize byte array to base64 text. In keeping with the specification, this adds a line break every 76 characters in the encoded representation.
        Parameters:
        byts - byte data array
        Returns:
        base64 encoded text
      • arrayListFactory

        public static List arrayListFactory()
        Factory method to create a java.util.ArrayList as the implementation of a java.util.List.
        Returns:
        new java.util.ArrayList