implements java.io.Serializable, Cloneable, Comparable<Date>

{

private static final BaseCalendar gcal =

CalendarSystem.getGregorianCalendar();

private static BaseCalendar jcal;

private transient long fastTime;

/*

private transient BaseCalendar.Date cdate;

// Initialized just before the value is used. See parse().

private static int defaultCenturyStart;

/* use serialVersionUID from modified java.util.Date for

@java.io.Serial

private static final long serialVersionUID = 7523967970034938905L;

/**

public Date() {

this(System.currentTimeMillis());

}

/**

public Date(long date) {

fastTime = date;

}

/**

@Deprecated

public Date(int year, int month, int date) {

this(year, month, date, 0, 0, 0);

}

/**

@Deprecated

public Date(int year, int month, int date, int hrs, int min) {

this(year, month, date, hrs, min, 0);

}

/**

@Deprecated

public Date(int year, int month, int date, int hrs, int min, int sec) {

int y = year + 1900;

// month is 0-based. So we have to normalize month to support Long.MAX_VALUE.

if (month >= 12) {

y += month / 12;

month %= 12;

} else if (month < 0) {

y += CalendarUtils.floorDivide(month, 12);

month = CalendarUtils.mod(month, 12);

}

BaseCalendar cal = getCalendarSystem(y);

cdate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.getDefaultRef());

cdate.setNormalizedDate(y, month + 1, date).setTimeOfDay(hrs, min, sec, 0);

getTimeImpl();

cdate = null;

}

/**

@Deprecated

public Date(String s) {

this(parse(s));

}

/**

public Object clone() {

Date d = null;

try {

d = (Date)super.clone();

if (cdate != null) {

d.cdate = (BaseCalendar.Date) cdate.clone();

}

} catch (CloneNotSupportedException e) {} // Won't happen

return d;

}

/**

@Deprecated

public static long UTC(int year, int month, int date,

int hrs, int min, int sec) {

int y = year + 1900;

// month is 0-based. So we have to normalize month to support Long.MAX_VALUE.

if (month >= 12) {

y += month / 12;

month %= 12;

} else if (month < 0) {

y += CalendarUtils.floorDivide(month, 12);

month = CalendarUtils.mod(month, 12);

}

int m = month + 1;

BaseCalendar cal = getCalendarSystem(y);

BaseCalendar.Date udate = (BaseCalendar.Date) cal.newCalendarDate(null);

udate.setNormalizedDate(y, m, date).setTimeOfDay(hrs, min, sec, 0);

// Use a Date instance to perform normalization. Its fastTime

// is the UTC value after the normalization.

Date d = new Date(0);

d.normalize(udate);

return d.fastTime;

}

/**

@Deprecated

public static long parse(String s) {

int year = Integer.MIN_VALUE;

int mon = -1;

int mday = -1;

int hour = -1;

int min = -1;

int sec = -1;

int millis = -1;

int c = -1;

int i = 0;

int n = -1;

int wst = -1;

int tzoffset = -1;

int prevc = 0;

syntax:

{

if (s == null)

break syntax;

int limit = s.length();

while (i < limit) {

c = s.charAt(i);

i++;

if (c <= ' ' || c == ',')

continue;

if (c == '(') { // skip comments

int depth = 1;

while (i < limit) {

c = s.charAt(i);

i++;

if (c == '(') depth++;

else if (c == ')')

if (--depth <= 0)

break;

}

continue;

}

if ('0' <= c && c <= '9') {

n = c - '0';

while (i < limit && '0' <= (c = s.charAt(i)) && c <= '9') {

n = n * 10 + c - '0';

i++;

}

if (prevc == '+' || prevc == '-' && year != Integer.MIN_VALUE) {

// timezone offset

if (n < 24)

n = n * 60; // EG. "GMT-3"

else

n = n % 100 + n / 100 * 60; // eg "GMT-0430"

if (prevc == '+') // plus means east of GMT

n = -n;

if (tzoffset != 0 && tzoffset != -1)

break syntax;

tzoffset = n;

} else if (n >= 70)

if (year != Integer.MIN_VALUE)

break syntax;

else if (c <= ' ' || c == ',' || c == '/' || i >= limit)

// year = n < 1900 ? n : n - 1900;

year = n;

else

break syntax;

else if (c == ':')

if (hour < 0)

hour = (byte) n;

else if (min < 0)

min = (byte) n;

else

break syntax;

else if (c == '/')

if (mon < 0)

mon = (byte) (n - 1);

else if (mday < 0)

mday = (byte) n;

else

break syntax;

else if (i < limit && c != ',' && c > ' ' && c != '-')

break syntax;

else if (hour >= 0 && min < 0)

min = (byte) n;

else if (min >= 0 && sec < 0)

sec = (byte) n;

else if (mday < 0)

mday = (byte) n;

// Handle two-digit years < 70 (70-99 handled above).

else if (year == Integer.MIN_VALUE && mon >= 0 && mday >= 0)

year = n;

else

break syntax;

prevc = 0;

} else if (c == '/' || c == ':' || c == '+' || c == '-')

prevc = c;

else {

int st = i - 1;

while (i < limit) {

c = s.charAt(i);

if (!('A' <= c && c <= 'Z' || 'a' <= c && c <= 'z'))

break;

i++;

}

if (i <= st + 1)

break syntax;

int k;

for (k = wtb.length; --k >= 0;)

if (wtb[k].regionMatches(true, 0, s, st, i - st)) {

int action = ttb[k];

if (action != 0) {

if (action == 1) { // pm

if (hour > 12 || hour < 1)

break syntax;

else if (hour < 12)

hour += 12;

} else if (action == 14) { // am

if (hour > 12 || hour < 1)

break syntax;

else if (hour == 12)

hour = 0;

} else if (action <= 13) { // month!

if (mon < 0)

mon = (byte) (action - 2);

else

break syntax;

} else {

tzoffset = action - 10000;

}

}

break;

}

if (k < 0)

break syntax;

prevc = 0;

}

}

if (year == Integer.MIN_VALUE || mon < 0 || mday < 0)

break syntax;

// Parse 2-digit years within the correct default century.

if (year < 100) {

synchronized (Date.class) {

if (defaultCenturyStart == 0) {

defaultCenturyStart = gcal.getCalendarDate().getYear() - 80;

}

}

year += (defaultCenturyStart / 100) * 100;

if (year < defaultCenturyStart) year += 100;

}

if (sec < 0)

sec = 0;

if (min < 0)

min = 0;

if (hour < 0)

hour = 0;

BaseCalendar cal = getCalendarSystem(year);

if (tzoffset == -1) { // no time zone specified, have to use local

BaseCalendar.Date ldate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.getDefaultRef());

ldate.setDate(year, mon + 1, mday);

ldate.setTimeOfDay(hour, min, sec, 0);

return cal.getTime(ldate);

}

BaseCalendar.Date udate = (BaseCalendar.Date) cal.newCalendarDate(null); // no time zone

udate.setDate(year, mon + 1, mday);

udate.setTimeOfDay(hour, min, sec, 0);

return cal.getTime(udate) + tzoffset * (60 * 1000);

}

// syntax error

throw new IllegalArgumentException();

}

private static final String wtb[] = {

"am", "pm",

"monday", "tuesday", "wednesday", "thursday", "friday",

"saturday", "sunday",

"january", "february", "march", "april", "may", "june",

"july", "august", "september", "october", "november", "december",

"gmt", "ut", "utc", "est", "edt", "cst", "cdt",

"mst", "mdt", "pst", "pdt"

};

private static final int ttb[] = {

14, 1, 0, 0, 0, 0, 0, 0, 0,

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,

10000 + 0, 10000 + 0, 10000 + 0, // GMT/UT/UTC

10000 + 5 * 60, 10000 + 4 * 60, // EST/EDT

10000 + 6 * 60, 10000 + 5 * 60, // CST/CDT

10000 + 7 * 60, 10000 + 6 * 60, // MST/MDT

10000 + 8 * 60, 10000 + 7 * 60 // PST/PDT

};

/**

@Deprecated

public int getYear() {

return normalize().getYear() - 1900;

}

/**

@Deprecated

public void setYear(int year) {

getCalendarDate().setNormalizedYear(year + 1900);

}

/**

@Deprecated

public int getMonth() {

return normalize().getMonth() - 1; // adjust 1-based to 0-based

}

/**

@Deprecated

public void setMonth(int month) {

int y = 0;

if (month >= 12) {

y = month / 12;

month %= 12;

} else if (month < 0) {

y = CalendarUtils.floorDivide(month, 12);

month = CalendarUtils.mod(month, 12);

}

BaseCalendar.Date d = getCalendarDate();

if (y != 0) {

d.setNormalizedYear(d.getNormalizedYear() + y);

}

d.setMonth(month + 1); // adjust 0-based to 1-based month numbering

}

/**

@Deprecated

public int getDate() {

return normalize().getDayOfMonth();

}

/**

@Deprecated

public void setDate(int date) {

getCalendarDate().setDayOfMonth(date);

}

/**

@Deprecated

public int getDay() {

return normalize().getDayOfWeek() - BaseCalendar.SUNDAY;

}

/**

@Deprecated

public int getHours() {

return normalize().getHours();

}

/**

@Deprecated

public void setHours(int hours) {

getCalendarDate().setHours(hours);

}

/**

@Deprecated

public int getMinutes() {

return normalize().getMinutes();

}

/**

@Deprecated

public void setMinutes(int minutes) {

getCalendarDate().setMinutes(minutes);

}

/**

@Deprecated

public int getSeconds() {

return normalize().getSeconds();

}

/**

@Deprecated

public void setSeconds(int seconds) {

getCalendarDate().setSeconds(seconds);

}

/**

public long getTime() {

return getTimeImpl();

}

private final long getTimeImpl() {

if (cdate != null && !cdate.isNormalized()) {

normalize();

}

return fastTime;

}

/**

public void setTime(long time) {

fastTime = time;

cdate = null;

}

/**

public boolean before(Date when) {

return getMillisOf(this) < getMillisOf(when);

}

/**

public boolean after(Date when) {

return getMillisOf(this) > getMillisOf(when);

}

/**

public boolean equals(Object obj) {

return obj instanceof Date && getTime() == ((Date) obj).getTime();

}

/**

static final long getMillisOf(Date date) {

if (date.getClass() != Date.class) {

return date.getTime();

}

if (date.cdate == null || date.cdate.isNormalized()) {

return date.fastTime;

}

BaseCalendar.Date d = (BaseCalendar.Date) date.cdate.clone();

return gcal.getTime(d);

}

/**

@Override

public int compareTo(Date anotherDate) {

return Long.compare(getMillisOf(this), getMillisOf(anotherDate));

}

/**

public int hashCode() {

long ht = this.getTime();

return (int) ht ^ (int) (ht >> 32);

}

/**