package tim.prune.data; import java.text.DateFormat; 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; /** * Class to hold a UTC-based timestamp, for example of a track point. * When the selected timezone changes, this timestamp will keep its * numerical value but the date and time will change accordingly. */ public class TimestampUtc extends Timestamp { private boolean _valid = false; private long _milliseconds = 0L; private String _text = null; 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|[\\+-]\\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; private static long SECS_SINCE_GARTRIP = 0L; private static long MSECS_SINCE_1970 = 0L; private static long MSECS_SINCE_1990 = 0L; private static long TWENTY_YEARS_IN_SECS = 0L; private static final long GARTRIP_OFFSET = 631065600L; /** Identifier for the parsing strategy to use */ private enum ParseType { NONE, ISO8601_FRACTIONAL, LONG, FIXED_FORMAT0, FIXED_FORMAT1, FIXED_FORMAT2, FIXED_FORMAT3, 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.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; // Date formats ALL_DATE_FORMATS = new DateFormat[] { 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); df.setTimeZone(gmtZone); } } /** * Constructor * @param inString String containing timestamp */ public TimestampUtc(String inString) { _valid = false; _text = null; if (inString != null && !inString.equals("")) { // Try each of the parse types in turn for (ParseType type : ALL_PARSE_TYPES) { if (parseString(inString, type)) { ALL_PARSE_TYPES[0] = type; _valid = true; _text = inString; return; } } } } /** * Try to parse the given string in the specified way * @param inString String to parse * @param inType parse type to use * @return true if successful */ private boolean parseString(String inString, ParseType inType) { if (inString == null || inString.equals("")) { return false; } switch (inType) { case NONE: return false; case LONG: // Try to parse into a long try { long rawValue = Long.parseLong(inString.trim()); _milliseconds = getMilliseconds(rawValue); return true; } catch (NumberFormatException nfe) {} break; case ISO8601_FRACTIONAL: final Matcher fmatcher = ISO8601_FRACTIONAL_PATTERN.matcher(inString); if (fmatcher.matches()) { try { _milliseconds = getMilliseconds(Integer.parseInt(fmatcher.group(1)), // year Integer.parseInt(fmatcher.group(2)), // month Integer.parseInt(fmatcher.group(3)), // day 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(8)); // timezone, if any return true; } catch (NumberFormatException nfe) {} } break; case FIXED_FORMAT0: return parseString(inString, ALL_DATE_FORMATS[0]); case FIXED_FORMAT1: return parseString(inString, ALL_DATE_FORMATS[1]); case FIXED_FORMAT2: return parseString(inString, ALL_DATE_FORMATS[2]); case FIXED_FORMAT3: return parseString(inString, ALL_DATE_FORMATS[3]); 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) { final Matcher matcher = GENERAL_TIMESTAMP_PATTERN.matcher(inString); if (matcher.matches()) { try { _milliseconds = getMilliseconds(Integer.parseInt(matcher.group(1)), Integer.parseInt(matcher.group(2)), Integer.parseInt(matcher.group(3)), Integer.parseInt(matcher.group(4)), Integer.parseInt(matcher.group(5)), Integer.parseInt(matcher.group(6)), null, null); // no fractions of a second and no timezone return true; } catch (NumberFormatException nfe2) {} // parse shouldn't fail if matcher matched } } return false; } return false; } /** * Try to parse the given string with the given date format * @param inString String to parse * @param inDateFormat Date format to use * @return true if successful */ private boolean parseString(String inString, DateFormat inDateFormat) { 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 { CALENDAR.setTime(date); _milliseconds = CALENDAR.getTimeInMillis(); return true; } return false; } /** * Constructor giving millis * @param inMillis milliseconds since 1970 */ public TimestampUtc(long inMillis) { _milliseconds = inMillis; _valid = true; } /** * Convert the given timestamp parameters into a number of milliseconds * @param inYear year * @param inMonth month, beginning with 1 * @param inDay day of month, beginning with 1 * @param inHour hour of day, 0-24 * @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, 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); cal.set(Calendar.HOUR_OF_DAY, inHour); cal.set(Calendar.MINUTE, inMinute); cal.set(Calendar.SECOND, inSecond); int millis = 0; if (inFraction != null) { try { int frac = Integer.parseInt(inFraction); final int fracLen = inFraction.length(); switch (fracLen) { case 1: millis = frac * 100; break; case 2: millis = frac * 10; break; case 3: millis = frac; break; } } catch (NumberFormatException nfe) {} // ignore errors, millis stay at 0 } cal.set(Calendar.MILLISECOND, millis); return cal.getTimeInMillis(); } /** * Convert the given long parameters into a number of milliseconds * @param inRawValue long value representing seconds / milliseconds * @return number of milliseconds */ private static long getMilliseconds(long inRawValue) { // check for each format possibility and pick nearest long diff1 = Math.abs(SECS_SINCE_1970 - inRawValue); long diff2 = Math.abs(MSECS_SINCE_1970 - inRawValue); long diff3 = Math.abs(MSECS_SINCE_1990 - inRawValue); long diff4 = Math.abs(SECS_SINCE_GARTRIP - inRawValue); // Start off with "seconds since 1970" format long smallestDiff = diff1; long millis = inRawValue * 1000; // Now check millis since 1970 if (diff2 < smallestDiff) { // milliseconds since 1970 millis = inRawValue; smallestDiff = diff2; } // Now millis since 1990 if (diff3 < smallestDiff) { // milliseconds since 1990 millis = inRawValue + TWENTY_YEARS_IN_SECS * 1000L; smallestDiff = diff3; } // Lastly, check gartrip offset if (diff4 < smallestDiff) { // seconds since gartrip offset millis = (inRawValue + GARTRIP_OFFSET) * 1000L; } return millis; } /** * @return true if timestamp is valid */ public boolean isValid() { return _valid; } /** * @return true if the timestamp has non-zero milliseconds */ protected boolean hasMilliseconds() { return isValid() && (_milliseconds % 1000L) > 0; } /** * @return the milliseconds according to the given timezone */ public long getMilliseconds(TimeZone inZone) { return _milliseconds; } /** * Add the given number of seconds offset * @param inOffset number of seconds to add/subtract */ public void addOffsetSeconds(long inOffset) { _milliseconds += (inOffset * 1000L); _text = null; } /** * @param inFormat format of timestamp * @param inTimezone timezone to use * @return Description of timestamp in required format */ public String getText(Format inFormat, TimeZone inTimezone) { // Use the cached text if possible if (isValid() && _text != null && inFormat == Format.ORIGINAL) { return _text; } // Nothing cached, so use the regular one return super.getText(inFormat, inTimezone); } /** * Utility method for formatting dates / times * @param inFormat formatter object * @param inTimezone timezone to use * @return formatted String */ protected String format(DateFormat inFormat, TimeZone inTimezone) { CALENDAR.setTimeZone(TimeZone.getTimeZone("GMT")); inFormat.setTimeZone(inTimezone == null ? TimeZone.getTimeZone("GMT") : inTimezone); CALENDAR.setTimeInMillis(_milliseconds); return inFormat.format(CALENDAR.getTime()); } /** * @return a Calendar object representing this timestamp */ public Calendar getCalendar(TimeZone inZone) { Calendar cal = Calendar.getInstance(); cal.setTimeZone(TimeZone.getTimeZone("GMT")); cal.setTimeInMillis(_milliseconds); return cal; } }