SimpleDateFormat.java [plain text]
package java.text;
import java.util.Calendar;
import java.util.Date;
import java.util.Enumeration;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;
import java.util.SimpleTimeZone;
import java.util.Vector;
import java.io.ObjectInputStream;
import java.io.IOException;
public class SimpleDateFormat extends DateFormat
{
private class FieldSizePair
{
public int field;
public int size;
public FieldSizePair(int f, int s) {
field = f;
size = s;
}
}
private transient Vector tokens;
private DateFormatSymbols formatData; private Date defaultCenturyStart;
private transient int defaultCentury;
private String pattern;
private int serialVersionOnStream = 1; private static final long serialVersionUID = 4774881970558875024L;
private static final String standardChars = "GyMdkHmsSEDFwWahKz";
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException
{
stream.defaultReadObject();
if (serialVersionOnStream < 1)
{
computeCenturyStart ();
serialVersionOnStream = 1;
}
else
set2DigitYearStart(defaultCenturyStart);
tokens = new Vector();
compileFormat(pattern);
}
private void compileFormat(String pattern)
{
char thisChar;
int pos;
int field;
FieldSizePair current = null;
for (int i=0; i<pattern.length(); i++) {
thisChar = pattern.charAt(i);
field = formatData.getLocalPatternChars().indexOf(thisChar);
if (field == -1) {
current = null;
if (Character.isLetter(thisChar)) {
tokens.addElement(new FieldSizePair(-1,0));
} else if (thisChar == '\'') {
pos = pattern.indexOf('\'',i+1);
if (pos == -1) {
tokens.addElement(new FieldSizePair(-1,0));
}
if ((pos+1 < pattern.length()) && (pattern.charAt(pos+1) == '\'')) {
tokens.addElement(pattern.substring(i+1,pos+1));
} else {
tokens.addElement(pattern.substring(i+1,pos));
}
i = pos;
} else {
tokens.addElement(new Character(thisChar));
}
} else {
if ((current != null) && (field == current.field)) {
current.size++;
} else {
current = new FieldSizePair(field,1);
tokens.addElement(current);
}
}
}
}
public String toString()
{
StringBuffer output = new StringBuffer();
Enumeration e = tokens.elements();
while (e.hasMoreElements()) {
output.append(e.nextElement().toString());
}
return output.toString();
}
public SimpleDateFormat()
{
super();
Locale locale = Locale.getDefault();
calendar = new GregorianCalendar(locale);
computeCenturyStart();
tokens = new Vector();
formatData = new DateFormatSymbols(locale);
pattern = (formatData.dateFormats[DEFAULT] + ' '
+ formatData.timeFormats[DEFAULT]);
compileFormat(pattern);
numberFormat = NumberFormat.getInstance(locale);
numberFormat.setGroupingUsed (false);
}
public SimpleDateFormat(String pattern)
{
this(pattern, Locale.getDefault());
}
public SimpleDateFormat(String pattern, Locale locale)
{
super();
calendar = new GregorianCalendar(locale);
computeCenturyStart();
tokens = new Vector();
formatData = new DateFormatSymbols(locale);
compileFormat(pattern);
this.pattern = pattern;
numberFormat = NumberFormat.getInstance(locale);
numberFormat.setGroupingUsed (false);
}
public SimpleDateFormat(String pattern, DateFormatSymbols formatData)
{
super();
calendar = new GregorianCalendar();
computeCenturyStart ();
tokens = new Vector();
this.formatData = formatData;
compileFormat(pattern);
this.pattern = pattern;
numberFormat = NumberFormat.getInstance();
numberFormat.setGroupingUsed (false);
}
public String toPattern()
{
return pattern;
}
public String toLocalizedPattern()
{
String localChars = formatData.getLocalPatternChars();
return applyLocalizedPattern (pattern, standardChars, localChars);
}
public void applyPattern(String pattern)
{
tokens = new Vector();
compileFormat(pattern);
this.pattern = pattern;
}
public void applyLocalizedPattern(String pattern)
{
String localChars = formatData.getLocalPatternChars();
pattern = applyLocalizedPattern (pattern, localChars, standardChars);
applyPattern(pattern);
}
private String applyLocalizedPattern(String pattern,
String oldChars, String newChars)
{
int len = pattern.length();
StringBuffer buf = new StringBuffer(len);
boolean quoted = false;
for (int i = 0; i < len; i++)
{
char ch = pattern.charAt(i);
if (ch == '\'')
quoted = ! quoted;
if (! quoted)
{
int j = oldChars.indexOf(ch);
if (j >= 0)
ch = newChars.charAt(j);
}
buf.append(ch);
}
return buf.toString();
}
public Date get2DigitYearStart()
{
return defaultCenturyStart;
}
public void set2DigitYearStart(Date date)
{
defaultCenturyStart = date;
calendar.clear();
calendar.setTime(date);
int year = calendar.get(Calendar.YEAR);
defaultCentury = year - (year % 100);
}
public DateFormatSymbols getDateFormatSymbols()
{
return formatData;
}
public void setDateFormatSymbols(DateFormatSymbols formatData)
{
this.formatData = formatData;
}
public boolean equals(Object o)
{
if (o == null)
return false;
if (!super.equals(o))
return false;
if (!(o instanceof SimpleDateFormat))
return false;
SimpleDateFormat sdf = (SimpleDateFormat)o;
if (!toPattern().equals(sdf.toPattern()))
return false;
if (!get2DigitYearStart().equals(sdf.get2DigitYearStart()))
return false;
if (!getDateFormatSymbols().equals(sdf.getDateFormatSymbols()))
return false;
return true;
}
public StringBuffer format(Date date, StringBuffer buffer, FieldPosition pos)
{
String temp;
calendar.setTime(date);
Enumeration e = tokens.elements();
while (e.hasMoreElements()) {
Object o = e.nextElement();
if (o instanceof FieldSizePair) {
FieldSizePair p = (FieldSizePair) o;
int beginIndex = buffer.length();
switch (p.field) {
case ERA_FIELD:
buffer.append(formatData.eras[calendar.get(Calendar.ERA)]);
break;
case YEAR_FIELD:
temp = String.valueOf(calendar.get(Calendar.YEAR));
if (p.size < 4)
buffer.append(temp.substring(temp.length()-2));
else
buffer.append(temp);
break;
case MONTH_FIELD:
if (p.size < 3)
withLeadingZeros(calendar.get(Calendar.MONTH)+1,p.size,buffer);
else if (p.size < 4)
buffer.append(formatData.shortMonths[calendar.get(Calendar.MONTH)]);
else
buffer.append(formatData.months[calendar.get(Calendar.MONTH)]);
break;
case DATE_FIELD:
withLeadingZeros(calendar.get(Calendar.DATE),p.size,buffer);
break;
case HOUR_OF_DAY1_FIELD: withLeadingZeros(((calendar.get(Calendar.HOUR_OF_DAY)+23)%24)+1,p.size,buffer);
break;
case HOUR_OF_DAY0_FIELD: withLeadingZeros(calendar.get(Calendar.HOUR_OF_DAY),p.size,buffer);
break;
case MINUTE_FIELD:
withLeadingZeros(calendar.get(Calendar.MINUTE),p.size,buffer);
break;
case SECOND_FIELD:
withLeadingZeros(calendar.get(Calendar.SECOND),p.size,buffer);
break;
case MILLISECOND_FIELD:
withLeadingZeros(calendar.get(Calendar.MILLISECOND),p.size,buffer);
break;
case DAY_OF_WEEK_FIELD:
if (p.size < 4)
buffer.append(formatData.shortWeekdays[calendar.get(Calendar.DAY_OF_WEEK)]);
else
buffer.append(formatData.weekdays[calendar.get(Calendar.DAY_OF_WEEK)]);
break;
case DAY_OF_YEAR_FIELD:
withLeadingZeros(calendar.get(Calendar.DAY_OF_YEAR),p.size,buffer);
break;
case DAY_OF_WEEK_IN_MONTH_FIELD:
withLeadingZeros(calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH),p.size,buffer);
break;
case WEEK_OF_YEAR_FIELD:
withLeadingZeros(calendar.get(Calendar.WEEK_OF_YEAR),p.size,buffer);
break;
case WEEK_OF_MONTH_FIELD:
withLeadingZeros(calendar.get(Calendar.WEEK_OF_MONTH),p.size,buffer);
break;
case AM_PM_FIELD:
buffer.append(formatData.ampms[calendar.get(Calendar.AM_PM)]);
break;
case HOUR1_FIELD: withLeadingZeros(((calendar.get(Calendar.HOUR)+11)%12)+1,p.size,buffer);
break;
case HOUR0_FIELD: withLeadingZeros(calendar.get(Calendar.HOUR),p.size,buffer);
break;
case TIMEZONE_FIELD:
TimeZone zone = calendar.getTimeZone();
boolean isDST = calendar.get(Calendar.DST_OFFSET) != 0;
String zoneID = zone.getDisplayName(isDST, p.size > 3 ? TimeZone.LONG : TimeZone.SHORT);
buffer.append(zoneID);
break;
default:
throw new IllegalArgumentException("Illegal pattern character");
}
if (pos != null && p.field == pos.getField())
{
pos.setBeginIndex(beginIndex);
pos.setEndIndex(buffer.length());
}
} else {
buffer.append(o.toString());
}
}
return buffer;
}
private void withLeadingZeros(int value, int length, StringBuffer buffer)
{
String valStr = String.valueOf(value);
for (length -= valStr.length(); length > 0; length--)
buffer.append('0');
buffer.append(valStr);
}
private final boolean expect (String source, ParsePosition pos, char ch)
{
int x = pos.getIndex();
boolean r = x < source.length() && source.charAt(x) == ch;
if (r)
pos.setIndex(x + 1);
else
pos.setErrorIndex(x);
return r;
}
public Date parse (String dateStr, ParsePosition pos)
{
int fmt_index = 0;
int fmt_max = pattern.length();
calendar.clear();
boolean saw_timezone = false;
int quote_start = -1;
boolean is2DigitYear = false;
for (; fmt_index < fmt_max; ++fmt_index)
{
char ch = pattern.charAt(fmt_index);
if (ch == '\'')
{
int index = pos.getIndex();
if (fmt_index < fmt_max - 1
&& pattern.charAt(fmt_index + 1) == '\'')
{
if (! expect (dateStr, pos, ch))
return null;
++fmt_index;
}
else
quote_start = quote_start < 0 ? fmt_index : -1;
continue;
}
if (quote_start != -1
|| ((ch < 'a' || ch > 'z')
&& (ch < 'A' || ch > 'Z')))
{
if (! expect (dateStr, pos, ch))
return null;
continue;
}
int first = fmt_index;
while (++fmt_index < fmt_max && pattern.charAt(fmt_index) == ch)
;
int fmt_count = fmt_index - first;
--fmt_index;
int calendar_field;
boolean is_numeric = true;
String[] match = null;
int offset = 0;
boolean maybe2DigitYear = false;
switch (ch)
{
case 'd':
calendar_field = Calendar.DATE;
break;
case 'D':
calendar_field = Calendar.DAY_OF_YEAR;
break;
case 'F':
calendar_field = Calendar.DAY_OF_WEEK_IN_MONTH;
break;
case 'E':
is_numeric = false;
offset = 1;
calendar_field = Calendar.DAY_OF_WEEK;
match = (fmt_count <= 3
? formatData.getShortWeekdays()
: formatData.getWeekdays());
break;
case 'w':
calendar_field = Calendar.WEEK_OF_YEAR;
break;
case 'W':
calendar_field = Calendar.WEEK_OF_MONTH;
break;
case 'M':
calendar_field = Calendar.MONTH;
if (fmt_count <= 2)
offset = -1;
else
{
is_numeric = false;
match = (fmt_count <= 3
? formatData.getShortMonths()
: formatData.getMonths());
}
break;
case 'y':
calendar_field = Calendar.YEAR;
if (fmt_count <= 2)
maybe2DigitYear = true;
break;
case 'K':
calendar_field = Calendar.HOUR;
break;
case 'h':
calendar_field = Calendar.HOUR;
break;
case 'H':
calendar_field = Calendar.HOUR_OF_DAY;
break;
case 'k':
calendar_field = Calendar.HOUR_OF_DAY;
break;
case 'm':
calendar_field = Calendar.MINUTE;
break;
case 's':
calendar_field = Calendar.SECOND;
break;
case 'S':
calendar_field = Calendar.MILLISECOND;
break;
case 'a':
is_numeric = false;
calendar_field = Calendar.AM_PM;
match = formatData.getAmPmStrings();
break;
case 'z':
is_numeric = false;
calendar_field = Calendar.DST_OFFSET;
String[][] zoneStrings = formatData.getZoneStrings();
int zoneCount = zoneStrings.length;
int index = pos.getIndex();
boolean found_zone = false;
for (int j = 0; j < zoneCount; j++)
{
String[] strings = zoneStrings[j];
int k;
for (k = 1; k < strings.length; ++k)
{
if (dateStr.startsWith(strings[k], index))
break;
}
if (k != strings.length)
{
found_zone = true;
saw_timezone = true;
TimeZone tz = TimeZone.getTimeZone (strings[0]);
calendar.setTimeZone (tz);
calendar.set (Calendar.ZONE_OFFSET, tz.getRawOffset ());
offset = 0;
if (k > 2 && tz instanceof SimpleTimeZone)
{
SimpleTimeZone stz = (SimpleTimeZone) tz;
offset = stz.getDSTSavings ();
}
pos.setIndex(index + strings[k].length());
break;
}
}
if (! found_zone)
{
pos.setErrorIndex(pos.getIndex());
return null;
}
break;
default:
pos.setErrorIndex(pos.getIndex());
return null;
}
int value;
int index = -1;
if (is_numeric)
{
numberFormat.setMinimumIntegerDigits(fmt_count);
if (maybe2DigitYear)
index = pos.getIndex();
Number n = numberFormat.parse(dateStr, pos);
if (pos == null || ! (n instanceof Long))
return null;
value = n.intValue() + offset;
}
else if (match != null)
{
index = pos.getIndex();
int i;
for (i = offset; i < match.length; ++i)
{
if (dateStr.startsWith(match[i], index))
break;
}
if (i == match.length)
{
pos.setErrorIndex(index);
return null;
}
pos.setIndex(index + match[i].length());
value = i;
}
else
value = offset;
if (maybe2DigitYear)
{
int digit_count = pos.getIndex() - index;
if (digit_count == 2)
is2DigitYear = true;
}
calendar.set(calendar_field, value);
}
if (is2DigitYear)
{
int year = defaultCentury + calendar.get(Calendar.YEAR);
calendar.set(Calendar.YEAR, year);
if (calendar.getTime().compareTo(defaultCenturyStart) < 0)
calendar.set(Calendar.YEAR, year + 100);
}
try
{
if (! saw_timezone)
{
calendar.clear (Calendar.DST_OFFSET);
calendar.clear (Calendar.ZONE_OFFSET);
}
return calendar.getTime();
}
catch (IllegalArgumentException x)
{
pos.setErrorIndex(pos.getIndex());
return null;
}
}
private void computeCenturyStart()
{
int year = calendar.get(Calendar.YEAR);
calendar.set(Calendar.YEAR, year - 80);
set2DigitYearStart(calendar.getTime());
}
}