X-Git-Url: http://gitweb.fperrin.net/?a=blobdiff_plain;f=tim%2Fprune%2Fdata%2FTimestamp.java;h=d5e065d4371d197c177a09f514498f93f71b6109;hb=ff33ebba6b7c62834f6dae16ce33eb2c710b160e;hp=477a7227125a0a82a7a4fcd4a7c899d2352bc03a;hpb=4d5796d02a15808311c09448d79e6e7d1de9d636;p=GpsPrune.git diff --git a/tim/prune/data/Timestamp.java b/tim/prune/data/Timestamp.java index 477a722..d5e065d 100644 --- a/tim/prune/data/Timestamp.java +++ b/tim/prune/data/Timestamp.java @@ -1,10 +1,11 @@ package tim.prune.data; import java.text.DateFormat; -import java.text.ParseException; +import java.text.ParsePosition; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; +import java.util.TimeZone; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -17,16 +18,19 @@ public class Timestamp private boolean _valid = false; private long _milliseconds = 0L; private String _text = null; - private String _timeText = null; - private static final DateFormat DEFAULT_DATE_FORMAT = DateFormat.getDateTimeInstance(); + private static final DateFormat DEFAULT_DATETIME_FORMAT = DateFormat.getDateTimeInstance(); + private static final DateFormat DEFAULT_DATE_FORMAT = DateFormat.getDateInstance(); private static final DateFormat DEFAULT_TIME_FORMAT = DateFormat.getTimeInstance(); + private static boolean MillisAddedToTimeFormat = false; private static final DateFormat ISO_8601_FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'"); + private static final DateFormat ISO_8601_FORMAT_WITH_MILLIS = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); private static final DateFormat ISO_8601_FORMAT_NOZ = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); private static DateFormat[] ALL_DATE_FORMATS = null; private static Calendar CALENDAR = null; private static final Pattern ISO8601_FRACTIONAL_PATTERN - = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})\\.(\\d{1,3})Z?"); + = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})(?:[\\.,](\\d{1,3}))?(Z|[\\+-]\\d{2}(?::?\\d{2})?)?"); + // year month day T hour minute sec millisec Z or +/- hours : minutes private static final Pattern GENERAL_TIMESTAMP_PATTERN = Pattern.compile("(\\d{4})\\D(\\d{2})\\D(\\d{2})\\D(\\d{2})\\D(\\d{2})\\D(\\d{2})"); private static long SECS_SINCE_1970 = 0L; @@ -36,12 +40,13 @@ public class Timestamp private static long TWENTY_YEARS_IN_SECS = 0L; private static final long GARTRIP_OFFSET = 631065600L; - /** Specifies original timestamp format */ - public static final int FORMAT_ORIGINAL = 0; - /** Specifies locale-dependent timestamp format */ - public static final int FORMAT_LOCALE = 1; - /** Specifies ISO 8601 timestamp format */ - public static final int FORMAT_ISO_8601 = 2; + /** Possible formats for parsing and displaying timestamps */ + public enum Format + { + ORIGINAL, + LOCALE, + ISO8601 + } /** Identifier for the parsing strategy to use */ private enum ParseType @@ -56,33 +61,47 @@ public class Timestamp FIXED_FORMAT4, FIXED_FORMAT5, FIXED_FORMAT6, + FIXED_FORMAT7, + FIXED_FORMAT8, GENERAL_STRING } /** Array of parse types to loop through (first one is changed to last successful type) */ private static ParseType[] ALL_PARSE_TYPES = {ParseType.NONE, ParseType.ISO8601_FRACTIONAL, ParseType.LONG, ParseType.FIXED_FORMAT0, ParseType.FIXED_FORMAT1, ParseType.FIXED_FORMAT2, ParseType.FIXED_FORMAT3, - ParseType.FIXED_FORMAT4, ParseType.FIXED_FORMAT5, ParseType.FIXED_FORMAT6, ParseType.GENERAL_STRING}; + ParseType.FIXED_FORMAT4, ParseType.FIXED_FORMAT5, ParseType.FIXED_FORMAT6, ParseType.FIXED_FORMAT7, + ParseType.FIXED_FORMAT8, ParseType.GENERAL_STRING}; // Static block to initialise offsets static { CALENDAR = Calendar.getInstance(); + TimeZone gmtZone = TimeZone.getTimeZone("GMT"); + CALENDAR.setTimeZone(gmtZone); MSECS_SINCE_1970 = CALENDAR.getTimeInMillis(); SECS_SINCE_1970 = MSECS_SINCE_1970 / 1000L; SECS_SINCE_GARTRIP = SECS_SINCE_1970 - GARTRIP_OFFSET; CALENDAR.add(Calendar.YEAR, -20); MSECS_SINCE_1990 = CALENDAR.getTimeInMillis(); TWENTY_YEARS_IN_SECS = (MSECS_SINCE_1970 - MSECS_SINCE_1990) / 1000L; + // Set timezone for output + ISO_8601_FORMAT.setTimeZone(gmtZone); + ISO_8601_FORMAT_WITH_MILLIS.setTimeZone(gmtZone); + DEFAULT_DATETIME_FORMAT.setTimeZone(gmtZone); // Date formats ALL_DATE_FORMATS = new DateFormat[] { - DEFAULT_DATE_FORMAT, + DEFAULT_DATETIME_FORMAT, new SimpleDateFormat("EEE MMM dd HH:mm:ss yyyy"), new SimpleDateFormat("HH:mm:ss dd MMM yyyy"), new SimpleDateFormat("dd MMM yyyy HH:mm:ss"), + new SimpleDateFormat("dd-MMM-yyyy HH:mm:ss"), new SimpleDateFormat("yyyy MMM dd HH:mm:ss"), + new SimpleDateFormat("MMM dd, yyyy hh:mm:ss aa"), ISO_8601_FORMAT, ISO_8601_FORMAT_NOZ }; + for (DateFormat df : ALL_DATE_FORMATS) { + df.setLenient(false); + } } @@ -93,6 +112,7 @@ public class Timestamp public Timestamp(String inString) { _valid = false; + _text = null; if (inString != null && !inString.equals("")) { // Try each of the parse types in turn @@ -102,6 +122,7 @@ public class Timestamp { ALL_PARSE_TYPES[0] = type; _valid = true; + _text = inString; return; } } @@ -145,7 +166,8 @@ public class Timestamp Integer.parseInt(fmatcher.group(4)), // hour Integer.parseInt(fmatcher.group(5)), // minute Integer.parseInt(fmatcher.group(6)), // second - fmatcher.group(7)); // fractional seconds + fmatcher.group(7), // fractional seconds + fmatcher.group(8)); // timezone, if any return true; } catch (NumberFormatException nfe) {} @@ -159,6 +181,8 @@ public class Timestamp case FIXED_FORMAT4: return parseString(inString, ALL_DATE_FORMATS[4]); case FIXED_FORMAT5: return parseString(inString, ALL_DATE_FORMATS[5]); case FIXED_FORMAT6: return parseString(inString, ALL_DATE_FORMATS[6]); + case FIXED_FORMAT7: return parseString(inString, ALL_DATE_FORMATS[7]); + case FIXED_FORMAT8: return parseString(inString, ALL_DATE_FORMATS[8]); case GENERAL_STRING: if (inString.length() == 19) @@ -173,7 +197,7 @@ public class Timestamp Integer.parseInt(matcher.group(4)), Integer.parseInt(matcher.group(5)), Integer.parseInt(matcher.group(6)), - null); // no fractions of a second + null, null); // no fractions of a second and no timezone return true; } catch (NumberFormatException nfe2) {} // parse shouldn't fail if matcher matched @@ -193,14 +217,15 @@ public class Timestamp */ private boolean parseString(String inString, DateFormat inDateFormat) { - try + ParsePosition pPos = new ParsePosition(0); + Date date = inDateFormat.parse(inString, pPos); + if (date != null && inString.length() == pPos.getIndex()) // require use of _all_ the string, not just the beginning { - Date date = inDateFormat.parse(inString); CALENDAR.setTime(date); _milliseconds = CALENDAR.getTimeInMillis(); return true; } - catch (ParseException e) {} + return false; } @@ -216,7 +241,7 @@ public class Timestamp */ public Timestamp(int inYear, int inMonth, int inDay, int inHour, int inMinute, int inSecond) { - _milliseconds = getMilliseconds(inYear, inMonth, inDay, inHour, inMinute, inSecond, null); + _milliseconds = getMilliseconds(inYear, inMonth, inDay, inHour, inMinute, inSecond, null, null); _valid = true; } @@ -241,12 +266,22 @@ public class Timestamp * @param inMinute minute * @param inSecond seconds * @param inFraction fractions of a second + * @param inTimezone timezone, if any * @return number of milliseconds */ private static long getMilliseconds(int inYear, int inMonth, int inDay, - int inHour, int inMinute, int inSecond, String inFraction) + int inHour, int inMinute, int inSecond, String inFraction, String inTimezone) { Calendar cal = Calendar.getInstance(); + // Timezone, if any + if (inTimezone == null || inTimezone.equals("") || inTimezone.equals("Z")) { + // No timezone, use zulu + cal.setTimeZone(TimeZone.getTimeZone("GMT")); + } + else { + // Timezone specified, pass to calendar + cal.setTimeZone(TimeZone.getTimeZone("GMT" + inTimezone)); + } cal.set(Calendar.YEAR, inYear); cal.set(Calendar.MONTH, inMonth - 1); cal.set(Calendar.DAY_OF_MONTH, inDay); @@ -318,13 +353,20 @@ public class Timestamp return _valid; } + /** + * @return true if the timestamp has non-zero milliseconds + */ + public boolean hasMilliseconds() + { + return isValid() && (_milliseconds % 1000L) > 0; + } /** * @param inOther other Timestamp - * @return true if this one is at least a second after the other + * @return true if this one is at least a millisecond after the other */ public boolean isAfter(Timestamp inOther) { - return getSecondsSince(inOther) > 0L; + return getMillisecondsSince(inOther) > 0L; } /** @@ -349,11 +391,11 @@ public class Timestamp /** * @param inOther other timestamp to compare - * @return true if they're equal to the nearest second + * @return true if they're equal to the nearest millisecond */ public boolean isEqual(Timestamp inOther) { - return getSecondsSince(inOther) == 0L; + return inOther != null && _milliseconds == inOther._milliseconds; } /** @@ -362,7 +404,7 @@ public class Timestamp */ public boolean isBefore(Timestamp inOther) { - return getSecondsSince(inOther) < 0L; + return getMillisecondsSince(inOther) < 0L; } /** @@ -412,38 +454,61 @@ public class Timestamp */ public String getText() { - return getText(FORMAT_LOCALE); + return getText(Format.LOCALE); } /** * @param inFormat format of timestamp * @return Description of timestamp in required format */ - public String getText(int inFormat) + public String getText(Format inFormat) { if (!_valid) {return "";} - if (inFormat == FORMAT_ISO_8601) { - return format(ISO_8601_FORMAT); - } - if (_text == null) { - _text = (_valid?format(DEFAULT_DATE_FORMAT):""); + switch (inFormat) + { + case ORIGINAL: + if (_text != null) {return _text;} + // otherwise fallthrough to default + //$FALL-THROUGH$ + case LOCALE: + return format(DEFAULT_DATETIME_FORMAT); + case ISO8601: + return format(hasMilliseconds() ? ISO_8601_FORMAT_WITH_MILLIS : ISO_8601_FORMAT); } return _text; } + /** + * @return date part of timestamp in locale-specific format + */ + public String getDateText() + { + if (!_valid) return ""; + return format(DEFAULT_DATE_FORMAT); + } + /** * @return Description of time part of timestamp in locale-specific format */ public String getTimeText() { - if (_timeText == null) + if (!_valid) return ""; + // Maybe we should add milliseconds to this format? + if (hasMilliseconds() && !MillisAddedToTimeFormat) { - if (_valid) { - _timeText = format(DEFAULT_TIME_FORMAT); + try + { + SimpleDateFormat sdf = (SimpleDateFormat) DEFAULT_TIME_FORMAT; + String pattern = sdf.toPattern(); + if (pattern.indexOf("ss") > 0 && pattern.indexOf("SS") < 0) + { + sdf.applyPattern(pattern.replaceFirst("s+", "$0.SSS")); + MillisAddedToTimeFormat = true; + } } - else _timeText = ""; + catch (ClassCastException cce) {} } - return _timeText; + return format(DEFAULT_TIME_FORMAT); } /** @@ -453,6 +518,7 @@ public class Timestamp */ private String format(DateFormat inFormat) { + CALENDAR.setTimeZone(TimeZone.getTimeZone("GMT")); CALENDAR.setTimeInMillis(_milliseconds); return inFormat.format(CALENDAR.getTime()); } @@ -463,6 +529,7 @@ public class Timestamp public Calendar getCalendar() { Calendar cal = Calendar.getInstance(); + cal.setTimeZone(TimeZone.getTimeZone("GMT")); cal.setTimeInMillis(_milliseconds); return cal; }