--- /dev/null
+/*
+ * 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.log4j.pattern;
+
+import java.text.DateFormat;
+import java.text.FieldPosition;
+import java.text.NumberFormat;
+import java.text.ParsePosition;
+import java.util.Date;
+import java.util.TimeZone;
+
+
+/**
+ * CachedDateFormat optimizes the performance of a wrapped
+ * DateFormat. The implementation is not thread-safe.
+ * If the millisecond pattern is not recognized,
+ * the class will only use the cache if the
+ * same value is requested.
+ *
+ */
+public final class CachedDateFormat extends DateFormat {
+ /**
+ * Serialization version.
+ */
+ private static final long serialVersionUID = 1;
+ /**
+ * Constant used to represent that there was no change
+ * observed when changing the millisecond count.
+ */
+ public static final int NO_MILLISECONDS = -2;
+
+ /**
+ * Supported digit set. If the wrapped DateFormat uses
+ * a different unit set, the millisecond pattern
+ * will not be recognized and duplicate requests
+ * will use the cache.
+ */
+ private static final String DIGITS = "0123456789";
+
+ /**
+ * Constant used to represent that there was an
+ * observed change, but was an expected change.
+ */
+ public static final int UNRECOGNIZED_MILLISECONDS = -1;
+
+ /**
+ * First magic number used to detect the millisecond position.
+ */
+ private static final int MAGIC1 = 654;
+
+ /**
+ * Expected representation of first magic number.
+ */
+ private static final String MAGICSTRING1 = "654";
+
+ /**
+ * Second magic number used to detect the millisecond position.
+ */
+ private static final int MAGIC2 = 987;
+
+ /**
+ * Expected representation of second magic number.
+ */
+ private static final String MAGICSTRING2 = "987";
+
+ /**
+ * Expected representation of 0 milliseconds.
+ */
+ private static final String ZERO_STRING = "000";
+
+ /**
+ * Wrapped formatter.
+ */
+ private final DateFormat formatter;
+
+ /**
+ * Index of initial digit of millisecond pattern or
+ * UNRECOGNIZED_MILLISECONDS or NO_MILLISECONDS.
+ */
+ private int millisecondStart;
+
+ /**
+ * Integral second preceding the previous convered Date.
+ */
+ private long slotBegin;
+
+ /**
+ * Cache of previous conversion.
+ */
+ private StringBuffer cache = new StringBuffer(50);
+
+ /**
+ * Maximum validity period for the cache.
+ * Typically 1, use cache for duplicate requests only, or
+ * 1000, use cache for requests within the same integral second.
+ */
+ private final int expiration;
+
+ /**
+ * Date requested in previous conversion.
+ */
+ private long previousTime;
+
+ /**
+ * Scratch date object used to minimize date object creation.
+ */
+ private final Date tmpDate = new Date(0);
+
+ /**
+ * Creates a new CachedDateFormat object.
+ * @param dateFormat Date format, may not be null.
+ * @param expiration maximum cached range in milliseconds.
+ * If the dateFormat is known to be incompatible with the
+ * caching algorithm, use a value of 0 to totally disable
+ * caching or 1 to only use cache for duplicate requests.
+ */
+ public CachedDateFormat(final DateFormat dateFormat, final int expiration) {
+ if (dateFormat == null) {
+ throw new IllegalArgumentException("dateFormat cannot be null");
+ }
+
+ if (expiration < 0) {
+ throw new IllegalArgumentException("expiration must be non-negative");
+ }
+
+ formatter = dateFormat;
+ this.expiration = expiration;
+ millisecondStart = 0;
+
+ //
+ // set the previousTime so the cache will be invalid
+ // for the next request.
+ previousTime = Long.MIN_VALUE;
+ slotBegin = Long.MIN_VALUE;
+ }
+
+ /**
+ * Finds start of millisecond field in formatted time.
+ * @param time long time, must be integral number of seconds
+ * @param formatted String corresponding formatted string
+ * @param formatter DateFormat date format
+ * @return int position in string of first digit of milliseconds,
+ * -1 indicates no millisecond field, -2 indicates unrecognized
+ * field (likely RelativeTimeDateFormat)
+ */
+ public static int findMillisecondStart(
+ final long time, final String formatted, final DateFormat formatter) {
+ long slotBegin = (time / 1000) * 1000;
+
+ if (slotBegin > time) {
+ slotBegin -= 1000;
+ }
+
+ int millis = (int) (time - slotBegin);
+
+ int magic = MAGIC1;
+ String magicString = MAGICSTRING1;
+
+ if (millis == MAGIC1) {
+ magic = MAGIC2;
+ magicString = MAGICSTRING2;
+ }
+
+ String plusMagic = formatter.format(new Date(slotBegin + magic));
+
+ /**
+ * If the string lengths differ then
+ * we can't use the cache except for duplicate requests.
+ */
+ if (plusMagic.length() != formatted.length()) {
+ return UNRECOGNIZED_MILLISECONDS;
+ } else {
+ // find first difference between values
+ for (int i = 0; i < formatted.length(); i++) {
+ if (formatted.charAt(i) != plusMagic.charAt(i)) {
+ //
+ // determine the expected digits for the base time
+ StringBuffer formattedMillis = new StringBuffer("ABC");
+ millisecondFormat(millis, formattedMillis, 0);
+
+ String plusZero = formatter.format(new Date(slotBegin));
+
+ // If the next 3 characters match the magic
+ // string and the expected string
+ if (
+ (plusZero.length() == formatted.length())
+ && magicString.regionMatches(
+ 0, plusMagic, i, magicString.length())
+ && formattedMillis.toString().regionMatches(
+ 0, formatted, i, magicString.length())
+ && ZERO_STRING.regionMatches(
+ 0, plusZero, i, ZERO_STRING.length())) {
+ return i;
+ } else {
+ return UNRECOGNIZED_MILLISECONDS;
+ }
+ }
+ }
+ }
+
+ return NO_MILLISECONDS;
+ }
+
+ /**
+ * Formats a Date into a date/time string.
+ *
+ * @param date the date to format.
+ * @param sbuf the string buffer to write to.
+ * @param fieldPosition remains untouched.
+ * @return the formatted time string.
+ */
+ public StringBuffer format(
+ Date date, StringBuffer sbuf, FieldPosition fieldPosition) {
+ format(date.getTime(), sbuf);
+
+ return sbuf;
+ }
+
+ /**
+ * Formats a millisecond count into a date/time string.
+ *
+ * @param now Number of milliseconds after midnight 1 Jan 1970 GMT.
+ * @param buf the string buffer to write to.
+ * @return the formatted time string.
+ */
+ public StringBuffer format(long now, StringBuffer buf) {
+ //
+ // If the current requested time is identical to the previously
+ // requested time, then append the cache contents.
+ //
+ if (now == previousTime) {
+ buf.append(cache);
+
+ return buf;
+ }
+
+ //
+ // If millisecond pattern was not unrecognized
+ // (that is if it was found or milliseconds did not appear)
+ //
+ if (millisecondStart != UNRECOGNIZED_MILLISECONDS &&
+ // Check if the cache is still valid.
+ // If the requested time is within the same integral second
+ // as the last request and a shorter expiration was not requested.
+ (now < (slotBegin + expiration)) && (now >= slotBegin)
+ && (now < (slotBegin + 1000L))) {
+ //
+ // if there was a millisecond field then update it
+ //
+ if (millisecondStart >= 0) {
+ millisecondFormat((int) (now - slotBegin), cache, millisecondStart);
+ }
+
+ //
+ // update the previously requested time
+ // (the slot begin should be unchanged)
+ previousTime = now;
+ buf.append(cache);
+
+ return buf;
+ }
+
+ //
+ // could not use previous value.
+ // Call underlying formatter to format date.
+ cache.setLength(0);
+ tmpDate.setTime(now);
+ cache.append(formatter.format(tmpDate));
+ buf.append(cache);
+ previousTime = now;
+ slotBegin = (previousTime / 1000) * 1000;
+
+ if (slotBegin > previousTime) {
+ slotBegin -= 1000;
+ }
+
+ //
+ // if the milliseconds field was previous found
+ // then reevaluate in case it moved.
+ //
+ if (millisecondStart >= 0) {
+ millisecondStart =
+ findMillisecondStart(now, cache.toString(), formatter);
+ }
+
+ return buf;
+ }
+
+ /**
+ * Formats a count of milliseconds (0-999) into a numeric representation.
+ * @param millis Millisecond coun between 0 and 999.
+ * @param buf String buffer, may not be null.
+ * @param offset Starting position in buffer, the length of the
+ * buffer must be at least offset + 3.
+ */
+ private static void millisecondFormat(
+ final int millis, final StringBuffer buf, final int offset) {
+ buf.setCharAt(offset, DIGITS.charAt(millis / 100));
+ buf.setCharAt(offset + 1, DIGITS.charAt((millis / 10) % 10));
+ buf.setCharAt(offset + 2, DIGITS.charAt(millis % 10));
+ }
+
+ /**
+ * Set timezone.
+ *
+ * Setting the timezone using getCalendar().setTimeZone()
+ * will likely cause caching to misbehave.
+ * @param timeZone TimeZone new timezone
+ */
+ public void setTimeZone(final TimeZone timeZone) {
+ formatter.setTimeZone(timeZone);
+ previousTime = Long.MIN_VALUE;
+ slotBegin = Long.MIN_VALUE;
+ }
+
+ /**
+ * This method is delegated to the formatter which most
+ * likely returns null.
+ * @param s string representation of date.
+ * @param pos field position, unused.
+ * @return parsed date, likely null.
+ */
+ public Date parse(String s, ParsePosition pos) {
+ return formatter.parse(s, pos);
+ }
+
+ /**
+ * Gets number formatter.
+ *
+ * @return NumberFormat number formatter
+ */
+ public NumberFormat getNumberFormat() {
+ return formatter.getNumberFormat();
+ }
+
+ /**
+ * Gets maximum cache validity for the specified SimpleDateTime
+ * conversion pattern.
+ * @param pattern conversion pattern, may not be null.
+ * @return Duration in milliseconds from an integral second
+ * that the cache will return consistent results.
+ */
+ public static int getMaximumCacheValidity(final String pattern) {
+ //
+ // If there are more "S" in the pattern than just one "SSS" then
+ // (for example, "HH:mm:ss,SSS SSS"), then set the expiration to
+ // one millisecond which should only perform duplicate request caching.
+ //
+ int firstS = pattern.indexOf('S');
+
+ if ((firstS >= 0) && (firstS != pattern.lastIndexOf("SSS"))) {
+ return 1;
+ }
+
+ return 1000;
+ }
+}
git://source.jalview.org / jalview.git / blobdiff