Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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;
}
}
