private Locale currentLocale = Locale.getDefault();

private java.util.TimeZone timeZone = Calendar.getInstance().getTimeZone();

private java.util.Date currDate;

public static final String INTERVAL_MILLISECONDS = "S";

public static final String INTERVAL_SECONDS = "s";

public static final String INTERVAL_MINUTES = "m";

public static final String INTERVAL_HOURS = "h";

public static final String INTERVAL_DAYS = "d";

public static final String INTERVAL_WEEKS = "w";

public static final String INTERVAL_MONTHS = "m";

public static final String INTERVAL_YEARS = "y";

private static final HashMap<String, String> timezones = new HashMap<>();

private static final String[] SupportedFormats = new String[] {

"EEE, d MMM yyyy HH:mm:ss z", // Mon, 7 Jun 1976 13:02:09 EST

"EEE, dd MMM yyyy HH:mm:ss z", // Mon, 07 Jun 1976 13:02:09 EST

"EEE, dd MMM yyyy HH:mm:ss", // Mon, 07 Jun 1976 13:02:09

"EEE MMM dd HH:mm:ss z yyyy", // Mon Jun 07 13:02:09 EST 1976

"EEE MMM d HH:mm:ss z yyyy", // Mon Jun 7 13:02:09 EST 1976

"EEE MMM dd HH:mm:ss yyyy", // Mon Jun 07 13:02:09 1976

"EEE MMM d HH:mm:ss yyyy", // Mon Jun 7 13:02:09 1976

"EEE MMM dd yyyy HH:mm:ss z", //"Mon Jun 07 2013 00:00:00 GMT-0500 (Eastern Standard Time)"

"yyyy-MM-dd HH:mm:ss.SSS Z", // 1976-06-07 13:02:36.000 America/New_York

"yyyy-MM-dd HH:mm:ss.SSSZ", // 1976-06-07 01:02:09.000-0500

"yyyy-MM-dd HH:mm:ss.SSS", // 1976-06-07 01:02:09.000

"yyyy-MM-dd HH:mm:ss Z", // 1976-06-07 13:02:36 America/New_York

"yyyy-MM-dd HH:mm:ssZ", // 1976-06-07 13:02:36-0500

"yyyy-MM-dd HH:mm:ss", // 1976-06-07 01:02:09

"yyyy:MM:dd HH:mm:ss", // 1976:06:07 01:02:09 (exif metadata)

"yyyy-MM-dd-HH:mm:ss.SSS", // 1976-06-07-01:02:09.000

"yyyy-MM-dd-HH:mm:ss", // 1976-06-07-01:02:09

//"yyyy-MM-ddTHH:mm:ss.SSS", // 1976-06-07T01:02:09.000

//"yyyy-MM-ddTHH:mm:ss", // 1976-06-07T01:02:09

"dd-MMM-yyyy h:mm:ss a", // 07-Jun-1976 1:02:09 PM

"dd-MMM-yy h:mm:ss a", // 07-Jun-76 1:02:09 PM

//"d-MMM-yy h:mm:ss a", // 7-Jun-76 1:02:09 PM

"yyyy-MM-dd HH:mm Z", // 1976-06-07 13:02 America/New_York"

"yyyy-MM-dd HH:mmZ", // 1976-06-07T13:02-0500

"yyyy-MM-dd HH:mm", // 1976-06-07T13:02

"yyyy-MM-dd", // 1976-06-07

"dd-MMM-yy", // 07-Jun-76

//"d-MMM-yy", // 7-Jun-76

"dd-MMM-yyyy", // 07-Jun-1976

"MMMMMM d, yyyy", // June 7, 1976

"M/d/yy h:mm:ss a", // 6/7/1976 1:02:09 PM

"M/d/yy h:mm a", // 6/7/1976 1:02 PM

"MM/dd/yy HH:mm:ss Z", // 06/07/1976 13:02:09 America/New_York

"MM/dd/yy HH:mm:ss", // 06/07/1976 13:02:09

"MM/dd/yy HH:mm Z", // 06/07/1976 13:02 America/New_York

"MM/dd/yy HH:mm", // 06/07/1976 13:02

"MM/dd/yyyy HH:mm:ss Z", // 06/07/1976 13:02:09 America/New_York

"MM/dd/yyyy HH:mm:ss", // 06/07/1976 13:02:09

"MM/dd/yyyy HH:mm Z", // 06/07/1976 13:02 America/New_York

"MM/dd/yyyy HH:mm", // 06/07/1976 13:02

"M/d/yy", // 6/7/76

"MM/dd/yyyy", // 06/07/1976

"M/d/yyyy", // 6/7/1976

"yyyyMMddHHmmssSSS", // 19760607130200000

"yyyyMMddHHmmss", // 19760607130200

"yyyyMMdd" // 19760607

};

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using the current time

public Date(){

currDate = new java.util.Date();

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a java.util.Date

public Date(java.util.Date date){

if (date==null) throw new IllegalArgumentException("Date is null.");

currDate = date;

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a java.util.Calendar

public Date(Calendar calendar){

if (calendar==null) throw new IllegalArgumentException("Calendar is null.");

currDate = calendar.getTime();

timeZone = calendar.getTimeZone();

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a java.time.LocalDate

public Date(java.time.LocalDate date){

if (date==null) throw new IllegalArgumentException("Date is null.");

Calendar cal = Calendar.getInstance();

cal.set(Calendar.YEAR, date.getYear());

cal.set(Calendar.MONTH, date.getMonthValue()-1);

cal.set(Calendar.DAY_OF_MONTH, date.getDayOfMonth());

cal.set(Calendar.HOUR_OF_DAY, 0);

cal.set(Calendar.MINUTE, 0);

cal.set(Calendar.SECOND, 0);

cal.set(Calendar.MILLISECOND, 0);

currDate = cal.getTime();

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a timestamp (in milliseconds)

public Date(long milliseconds){

Calendar cal = Calendar.getInstance();

cal.setTimeInMillis(milliseconds);

currDate = cal.getTime();

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a String representation of a

public Date(String date) throws ParseException {

try{

//Loop through all known date formats and try to convert the string to a date

for (String format : SupportedFormats){

if (format.endsWith("Z")){

//Special Case: Java fails to parse the "T" in strings like

//"1976-06-07T01:02:09.000" and "1976-06-07T13:02-0500"

int idx = date.indexOf("T");

if (idx==10 && format.startsWith("yyyy-MM-dd HH:mm")){

date = date.substring(0, idx) + " " + date.substring(idx+1);

}

if (date.endsWith("Z") && date.length()==format.length()){

//If the date literally ends with the letter "Z", then the

//date is probably referencing "Zulu" timezone (i.e. UTC).

//Example: "1976-06-07 00:00:00Z". Java doesn't understand

//what the "Z" timezone is so we'll replace the "Z" with

//"UTC".

date = date.substring(0, date.length()-1) + "UTC";

}

else{

//Check if the timezone offset is specified in "+/-HH:mm"

//format (e.g. "2018-01-17T01:00:35+07:00"). If so, update

//the timezone offset by removing the colon.

if (date.length()>=format.length()){

int len = format.length()-1;

String tz = date.substring(len);

if (tz.length()==6){

String a = tz.substring(0,1);

if ((a.equals("-") || a.equals("+")) && tz.indexOf(":")==3){

tz = tz.replace(":", "");

date = date.substring(0, len) + tz;

}

}

}

}

}

try{

currDate = parseDate(date, format);

return;

}

catch(ParseException e){

}

}

}

catch(Exception e){

}

//If we're still here, throw an exception

throw new ParseException("Failed to parse date: " + date, 0);

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of date using a date string. The format string is

public Date(String date, String format) throws ParseException {

currDate = parseDate(date, format);

}

//**************************************************************************

//** setDate

//**************************************************************************

/** Used to update the current date using a date string. The format parameter

public javaxt.utils.Date setDate(String date, String format) throws ParseException {

currDate = parseDate(date, format);

return this;

}

//**************************************************************************

//** setDate

//**************************************************************************

/** Used to update the current date using a predefined java.util.Date

public javaxt.utils.Date setDate(java.util.Date date){

currDate = date;

return this;

}

//**************************************************************************

//** setLocale

//**************************************************************************

/** Used to update the current local

public javaxt.utils.Date setLocale(Locale locale){

this.currentLocale = locale;

return this;

}

//**************************************************************************

//** getLocale

//**************************************************************************

/** Returns the current local

public Locale getLocale(){

return currentLocale;

}

//**************************************************************************

//** parseDate

//**************************************************************************

/** Attempts to convert a String to a Date via the user-supplied Format

private java.util.Date parseDate(String date, String format) throws ParseException {

if (date!=null){

date = date.trim();

if (date.length()==0) date = null;

}

if (date==null) throw new ParseException("Date is null.", 0);

SimpleDateFormat formatter = new SimpleDateFormat(format, currentLocale);

if (timeZone!=null) formatter.setTimeZone(timeZone);

try{

java.util.Date d = formatter.parse(date);

timeZone = formatter.getTimeZone();

return d;

}

catch(java.text.ParseException e){

//Parse the error. If it's a time zone issue, try to resolve it.

int zIndex = format.toUpperCase().indexOf("Z");

if (zIndex>0){

int errorOffset = e.getErrorOffset();

String tz = null;

if (errorOffset < format.length()){

//Check if the parser choked on the timezone format

String ch = format.substring(errorOffset, errorOffset+1);

if (ch.equalsIgnoreCase("Z") && date.length()>errorOffset){

tz = date.substring(errorOffset);

date = date.substring(0, errorOffset-1);

format = format.substring(0, errorOffset-1);

}

}

else if (errorOffset>format.length()){

//Special Case: "Fri Jan 04 2013 00:00:00 GMT-0500 (Eastern Standard Time)"

tz = date.substring(zIndex);

date = date.substring(0, zIndex-1);

format = format.substring(0, zIndex-1);

}

if (tz!=null){

try{

java.util.TimeZone zone = getTimeZone(tz);

if (zone!=null){

timeZone = zone;

formatter = new SimpleDateFormat(format, currentLocale);

formatter.setTimeZone(timeZone);

return formatter.parse(date);

}

}

catch(Exception ex){

}

}

}

throw e;

}

}

//**************************************************************************

//** setTimeZone

//**************************************************************************

/** Used to set the current time zone. The time zone is used when comparing

public javaxt.utils.Date setTimeZone(String timeZone, boolean preserveTimeStamp){

return setTimeZone(getTimeZone(timeZone), preserveTimeStamp);

}

//**************************************************************************

//** setTimeZone

//**************************************************************************

/** Used to set the current time zone. The time zone is used when comparing

public javaxt.utils.Date setTimeZone(java.util.TimeZone timeZone, boolean preserveTimeStamp){

if (timeZone==null) return this;

if (preserveTimeStamp){

Calendar cal = Calendar.getInstance(timeZone, currentLocale);

cal.set(Calendar.YEAR, this.getYear());

cal.set(Calendar.MONTH, this.getMonth()-1);

cal.set(Calendar.DAY_OF_MONTH, this.getDay());

cal.set(Calendar.HOUR_OF_DAY, this.getHour());

cal.set(Calendar.MINUTE, this.getMinute());

cal.set(Calendar.SECOND, this.getSecond());

cal.set(Calendar.MILLISECOND, this.getMilliSecond());

currDate = cal.getTime();

}

//Do this last! Otherwise the getHour(), getMinute(), etc will be off...

this.timeZone = timeZone;

return this;

}

//**************************************************************************

//** setTimeZone

//**************************************************************************

/** Used to set the current time zone. The time zone is used when comparing

public javaxt.utils.Date setTimeZone(String timeZone){

return setTimeZone(timeZone, false);

}

//**************************************************************************

//** setTimeZone

//**************************************************************************

/** Used to set the current time zone. The time zone is used when comparing

public javaxt.utils.Date setTimeZone(java.util.TimeZone timeZone){

return setTimeZone(timeZone, false);

}

//**************************************************************************

//** getTimeZone

//**************************************************************************

/** Returns the current time zone. The time zone is used when comparing

public java.util.TimeZone getTimeZone(){

return timeZone;

}

public int hashCode(){

return currDate.hashCode();

}

//**************************************************************************

//** toString

//**************************************************************************

/** Returns the current date as a String in the following format:

public String toString(){

return toString("EEE MMM dd HH:mm:ss z yyyy");

}

//**************************************************************************

//** toString

//**************************************************************************

/** Used to format the current date into a string.

public String toString(String format){

SimpleDateFormat currFormatter = new SimpleDateFormat(format, currentLocale);

currFormatter.setTimeZone(timeZone==null ? Calendar.getInstance().getTimeZone() : timeZone);

return currFormatter.format(currDate);

}

//**************************************************************************

//** toString

//**************************************************************************

/** Used to format the current date into a string in a given timezone.

public String toString(String format, String timeZone){

return this.toString(format, getTimeZone(timeZone));

}

//**************************************************************************

//** format

//**************************************************************************

/** Used to format the current date into a string.

public String toString(String format, java.util.TimeZone timeZone){

SimpleDateFormat currFormatter =

new SimpleDateFormat(format, currentLocale);

if (timeZone!=null) currFormatter.setTimeZone(timeZone);

return currFormatter.format(currDate);

}

//**************************************************************************

//** format

//**************************************************************************

/** Used to format the current date into a string. Same as toString(format).

public String format(String format){

return toString(format);

}

//**************************************************************************

//** toISOString

//**************************************************************************

/** Returns the date in ISO 8601 format (e.g. "2013-01-04T05:00:00.000Z").

public String toISOString(){

return toString("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", "UTC");

}

//**************************************************************************

//** toLong

//**************************************************************************

/** Returns a long integer used to represent the Date in the following

public long toLong(){

Date d = this.clone();

d.setTimeZone("UTC");

return Long.parseLong(d.toString("yyyyMMddHHmmssSSS"));

}

//**************************************************************************

//** clone

//**************************************************************************

/** Creates a copy of this object. Any modifications to the clone, will not

public Date clone(){

return new Date(getCalendar());

}

//**************************************************************************

//** equals

//**************************************************************************

/** Used to compare dates and determine whether they are equal.

public boolean equals(Object obj){

if (obj==null) return false;

if (obj instanceof javaxt.utils.Date){

return ((javaxt.utils.Date) obj).getDate().equals(currDate);

}

else if (obj instanceof java.util.Date){

return ((java.util.Date) obj).equals(currDate);

}

else if (obj instanceof String){

try{

return new javaxt.utils.Date((String) obj).equals(currDate);

}

catch(ParseException e){}

}

return false;

}

//**************************************************************************

//** FormatDate

//**************************************************************************

private String FormatDate(java.util.Date date, String OutputFormat){

SimpleDateFormat formatter =

new SimpleDateFormat(OutputFormat, currentLocale);

if (timeZone != null) formatter.setTimeZone(timeZone);

return formatter.format(date);

}

//**************************************************************************

//** compareTo

//**************************************************************************

/** Used to compare dates. Returns the number of intervals between two dates.

public long compareTo(javaxt.utils.Date date, String units){

return diff(currDate, date.getDate(), units);

}

//**************************************************************************

//** compareTo

//**************************************************************************

/** Used to compare dates. Returns the number of intervals between two dates

public long compareTo(java.util.Date date, String units){

return diff(currDate, date, units);

}

//**************************************************************************

//** diff

//**************************************************************************

/** Used to compare dates. Returns a long value representing the difference

private long diff(java.util.Date date1, java.util.Date date2, String interval){

LocalDate s = new Date(date2).getLocalDate();

LocalDate e = new Date(date1).getLocalDate();

double div = 1;

if (interval.equals("S") || interval.toLowerCase().startsWith("sec")){

div = 1000L;

//return ChronoUnit.SECONDS.between(s, e);

}

if (interval.equals("m") || interval.toLowerCase().startsWith("min")){

div = 60L * 1000L;

//return ChronoUnit.MINUTES.between(s, e);

}

if (interval.equals("H") || interval.toLowerCase().startsWith("h")){

div = 60L * 60L * 1000L;

//return ChronoUnit.HOURS.between(s, e);

}

if (interval.equals("d") || interval.toLowerCase().startsWith("d")){

div = 24L * 60L * 60L * 1000L;

//return ChronoUnit.DAYS.between(s, e);

}

if (interval.equals("w") || interval.toLowerCase().startsWith("w")){

div = 7L * 24L * 60L * 60L * 1000L;

//return ChronoUnit.WEEKS.between(s, e);

}

if (interval.equals("M") || interval.toLowerCase().startsWith("mon")){

//div = 30L * 24L * 60L * 60L * 1000L;

return ChronoUnit.MONTHS.between(s, e);

}

if (interval.equals("y") || interval.toLowerCase().startsWith("y")){

//div = 365L * 24L * 60L * 60L * 1000L;

return ChronoUnit.YEARS.between(s, e);

}

long d1 = date1.getTime();

long d2 = date2.getTime();

int i2 = (int)Math.abs((d1 - d2) / div);

if (date2.after(date1)){

i2 = -i2;

}

return i2;

}

//**************************************************************************

//** getMonthsBetween

//**************************************************************************

/** Returns fractional month difference between two dates. This method will

public static double getMonthsBetween(javaxt.utils.Date start, javaxt.utils.Date end) {

return getMonthsBetween(start.getLocalDate(), end.getLocalDate());

}

private static double getMonthsBetween(LocalDate start, LocalDate end) {

//Check if the start date is after the end date. Swap dates as needed

boolean negate = false;

if (start.isAfter(end)){

negate = true;

LocalDate t = start;

start = end;

end = t;

}

//Check if start/end dates fall on the last of the month

boolean startIsLastDayInMonth = start.getDayOfMonth() == start.lengthOfMonth();

boolean endIsLastDayInMonth = end.getDayOfMonth() == end.lengthOfMonth();

//Calulate months between the 2 dates using Java's built-in ChronoUnit

//Note that the ChronoUnit "rounds down" the interval between the dates.

long m = ChronoUnit.MONTHS.between(start, end);

//When the 2 dates fall on the same day in the month, and the dates aren't

//on the last day of the month, simply return the value returned by the

//ChronoUnit class

int startDay = start.getDayOfMonth();

int endDay = end.getDayOfMonth();

if (startDay==endDay){

if (startIsLastDayInMonth && !endIsLastDayInMonth ||

!startIsLastDayInMonth && endIsLastDayInMonth){

//Example: 2024-11-28 2025-02-28

}

else{

return m;

}

}

//If we're still here, compute fractions

double fraction = 0.0;

if (m==0 && start.getMonthValue()==end.getMonthValue()){

//Simply compare the days of the month

fraction = (end.getDayOfMonth()-(start.getDayOfMonth()-1))/(double)end.lengthOfMonth();

}

else{

//Create new end date using the original end date. Adjust the day

//of the month to match the start date. The new date will be either

//before or after the original end date.

int maxDays = LocalDate.of(end.getYear(), end.getMonthValue(), 1).lengthOfMonth();

LocalDate e2 = LocalDate.of(end.getYear(), end.getMonthValue(), Math.min(start.getDayOfMonth(), maxDays));

if (start.getDayOfMonth()>maxDays){

//Create new date a few days after the end of the month

LocalDate d = e2.plusDays(start.getDayOfMonth()-maxDays);

//Calculate months between the start date and the new date

m = ChronoUnit.MONTHS.between(start, d);

//Calculate fraction

if (startIsLastDayInMonth && endIsLastDayInMonth){}

else{

if (!startIsLastDayInMonth){

fraction = -((start.lengthOfMonth()-start.getDayOfMonth())/(double)start.lengthOfMonth());

}

else{

fraction = -(1-((end.getDayOfMonth())/(double)maxDays));

}

}

}

else{

//Calculate months between the start date and the new end date

m = ChronoUnit.MONTHS.between(start, e2);

//Calculate fraction

if (e2.isAfter(end)){

//subtract from e2

int n = e2.getDayOfMonth()-end.getDayOfMonth();

double f = (double)n/(double)end.lengthOfMonth();

if (m==0){

fraction = 1-f;

}

else{

fraction = -f;

}

}

else if (e2.isBefore(end)){

//add from e2

int x = start.getDayOfMonth()==1 ? 1 : 0;

fraction = (end.getDayOfMonth()-(start.getDayOfMonth()-x))/(double)end.lengthOfMonth();

}

}

}

//Add months and fractions

double diff = fraction+(double)m;

//When the 2 dates fall on the the last day of the month, round up

if ((startIsLastDayInMonth && endIsLastDayInMonth) && (start.getMonthValue()>end.getMonthValue())){

diff = Math.round(diff);

}

//Return diff

return negate ? -diff : diff;

}

private static LocalDate addOrSubtractMonths(long amount, LocalDate d){

if (amount==0) return d;

if (d.getDayOfMonth() == d.lengthOfMonth()){

d = d.withDayOfMonth(1);

if (amount>0){

d = d.plusMonths(amount);

}

else{

d = d.minusMonths(-amount);

}

d = d.withDayOfMonth(d.lengthOfMonth());

}

else{

if (amount>0){

d = d.plusMonths(amount);

}

else{

d = d.minusMonths(-amount);

}

}

return d;

}

//**************************************************************************

//** isBefore

//**************************************************************************

/** Returns true if a given date is before the current date

public boolean isBefore(String date) throws ParseException {

return isBefore(new javaxt.utils.Date(date));

}

//**************************************************************************

//** isBefore

//**************************************************************************

/** Returns true if a given date is before the current date

public boolean isBefore(javaxt.utils.Date Date){

if (Date==null) return false;

return currDate.before(Date.getDate());

}

//**************************************************************************

//** isAfter

//**************************************************************************

/** Returns true if a given date is after the current date

public boolean isAfter(String date) throws ParseException {

return isAfter(new javaxt.utils.Date(date));

}

//**************************************************************************

//** isAfter

//**************************************************************************

/** Returns true if a given date is after the current date

public boolean isAfter(javaxt.utils.Date Date){

if (Date==null) return false;

return currDate.after(Date.getDate());

}

//**************************************************************************

//** add

//**************************************************************************

/** Used to update the current date by adding to (or subtracting from) the

public javaxt.utils.Date add(int amount, String units){

Calendar cal = getCalendar();

int div = 0;

if (units.equals("S") || units.toLowerCase().startsWith("ms") || units.toLowerCase().startsWith("mil")){

div = cal.MILLISECOND;

}

else if (units.equals("s") || units.toLowerCase().startsWith("sec")){

div = cal.SECOND;

}

else if(units.equals("m") || units.toLowerCase().startsWith("min")){

div = cal.MINUTE;

}

else if (units.equals("H") || units.toLowerCase().startsWith("h")){

div = cal.HOUR_OF_DAY;

}

else if (units.toLowerCase().startsWith("d")){

div = cal.DAY_OF_YEAR;

}

else if (units.toLowerCase().startsWith("w")){

div = cal.WEEK_OF_YEAR;

}

else if (units.equals("M") || units.toLowerCase().startsWith("mon")){

div = cal.MONTH;

}

else if (units.toLowerCase().startsWith("y")){

div = cal.YEAR;

}

cal.add(div, amount);

currDate = cal.getTime();

return this;

}

//**************************************************************************

//** subtract

//**************************************************************************

/** Used to update the current date by subtracting from the current date.