package timeflow.data.time;
|
|
import java.util.*;
|
import java.text.*;
|
|
public class TimeUnit {
|
|
public static final TimeUnit YEAR=new TimeUnit("Years", Calendar.YEAR, 365*24*60*60*1000L, "yyyy", "yyyy");
|
public static final TimeUnit MONTH=new TimeUnit("Months", Calendar.MONTH, 30*24*60*60*1000L, "MMM", "MMM yyyy");
|
public static final TimeUnit WEEK=new TimeUnit("Weeks", Calendar.WEEK_OF_YEAR, 7*24*60*60*1000L, "d", "MMM d yyyy");
|
public static final TimeUnit DAY=new TimeUnit("Days", Calendar.DAY_OF_MONTH, 24*60*60*1000L, "d", "MMM d yyyy");
|
public static final TimeUnit DAY_OF_WEEK=new TimeUnit("Days", Calendar.DAY_OF_WEEK, 24*60*60*1000L, "d", "MMM d yyyy");
|
public static final TimeUnit HOUR=new TimeUnit("Hours", Calendar.HOUR_OF_DAY, 60*60*1000L, "kk:mm", "MMM d yyyy kk:mm");
|
public static final TimeUnit MINUTE=new TimeUnit("Minutes", Calendar.MINUTE, 60*1000L, ":mm", "MMM d yyyy kk:mm");
|
public static final TimeUnit SECOND=new TimeUnit("Seconds", Calendar.SECOND, 1000L, ":ss", "MMM d yyyy kk:mm:ss");
|
public static final TimeUnit DECADE=multipleYears(10);
|
public static final TimeUnit CENTURY=multipleYears(100);
|
|
private static final double DAY_SIZE=24*60*60*1000L;
|
|
private int quantity;
|
private long roughSize;
|
private SimpleDateFormat format, fullFormat;
|
private String name;
|
private int calendarCode;
|
|
private TimeUnit()
|
{
|
}
|
|
private TimeUnit(String name, int calendarCode, long roughSize, String formatPattern, String fullFormatPattern)
|
{
|
this.name=name;
|
this.calendarCode=calendarCode;
|
this.roughSize=roughSize;
|
format=new SimpleDateFormat(formatPattern);
|
fullFormat=new SimpleDateFormat(fullFormatPattern);
|
quantity=1;
|
}
|
|
public String toString()
|
{
|
return "[TimeUnit: "+name+"]";
|
}
|
|
public static TimeUnit multipleYears(int numYears)
|
{
|
TimeUnit t=new TimeUnit();
|
t.name=numYears+" Years";
|
t.calendarCode=Calendar.YEAR;
|
t.roughSize=YEAR.roughSize*numYears;
|
t.format=YEAR.format;
|
t.fullFormat=YEAR.fullFormat;
|
t.quantity=numYears;
|
return t;
|
}
|
|
public static TimeUnit multipleWeeks(int num)
|
{
|
TimeUnit t=new TimeUnit();
|
t.name=num+" Weeks";
|
t.calendarCode=Calendar.WEEK_OF_YEAR;
|
t.roughSize=WEEK.roughSize*num;
|
t.format=WEEK.format;
|
t.fullFormat=WEEK.fullFormat;
|
t.quantity=num;
|
return t;
|
}
|
|
public TimeUnit times(int quantity)
|
{
|
TimeUnit t=new TimeUnit();
|
t.name=quantity+" "+this.name;
|
t.calendarCode=this.calendarCode;
|
t.roughSize=this.roughSize*quantity;
|
t.format=this.format;
|
t.fullFormat=this.fullFormat;
|
t.quantity=quantity;
|
return t;
|
|
}
|
|
|
public int numUnitsIn(TimeUnit u)
|
{
|
return (int)Math.round(u.getRoughSize()/(double)getRoughSize());
|
}
|
|
public boolean isDayOrLess()
|
{
|
return roughSize <= 24*60*60*1000L;
|
}
|
|
public RoughTime roundDown(long timestamp)
|
{
|
return round(timestamp, false);
|
}
|
|
public RoughTime roundUp(long timestamp)
|
{
|
return round(timestamp, true);
|
}
|
|
private static final int[] calendarUnits={Calendar.SECOND, Calendar.MINUTE, Calendar.HOUR_OF_DAY, Calendar.DAY_OF_MONTH, Calendar.MONTH, Calendar.YEAR};
|
public RoughTime round(long timestamp, boolean up)
|
{
|
Calendar c=TimeUtils.cal(timestamp);
|
|
if (calendarCode==Calendar.WEEK_OF_YEAR )
|
{
|
c.set(Calendar.DAY_OF_WEEK, c.getMinimum(Calendar.DAY_OF_WEEK));
|
}
|
else
|
{
|
|
// set to minimum all fields of finer granularity.
|
int roundingCode=calendarCode;
|
if (calendarCode==Calendar.WEEK_OF_YEAR || calendarCode==Calendar.DAY_OF_WEEK)
|
roundingCode=Calendar.DAY_OF_MONTH;
|
for (int i=0; i<calendarUnits.length; i++)
|
{
|
if (calendarUnits[i]==roundingCode)
|
break;
|
if (i==calendarUnits.length-1)
|
throw new IllegalArgumentException("Unsupported Calendar Unit: "+calendarCode);
|
c.set(calendarUnits[i], c.getMinimum(calendarUnits[i]));
|
}
|
if (quantity>1)
|
{
|
c.set(calendarCode, quantity*(c.get(calendarCode)/quantity));
|
}
|
}
|
|
// if rounding up, then add a unit at current granularity.
|
if (up)
|
c.add(calendarCode, quantity);
|
|
return new RoughTime(c.getTimeInMillis(), this);
|
}
|
|
public int get(long timestamp)
|
{
|
Calendar c= TimeUtils.cal(timestamp);
|
int n=c.get(calendarCode);
|
return quantity==1 ? n : n%quantity;
|
}
|
|
public void addTo(RoughTime r)
|
{
|
addTo(r,1);
|
}
|
|
public void addTo(RoughTime r, int times)
|
{
|
Calendar c=TimeUtils.cal(r.getTime());
|
c.add(calendarCode, quantity*times);
|
r.setTime(c.getTimeInMillis());
|
}
|
|
// Finding the difference between two dates, in a given unit of time,
|
// is much subtler than you'd think! And annoyingly, the Calendar class does not do
|
// this for you, even though it actually "knows" how to do so since it
|
// can add fields.
|
//
|
// The most vexing problem is dealing with daylight savings time,
|
// which means that one day a year has 23 hours and one day has 25 hours.
|
// We also have to handle the fact that months and years aren't constant lengths.
|
//
|
// Rather than write all this ourselves, in this code we
|
// use the Calendar class to do the heavy lifting.
|
public long difference(long x, long y)
|
{
|
// If this is not one of the hard cases,
|
// just divide the timespan by the length of time unit.
|
// Note that we're not worrying about hours and daylight savings time.
|
if (calendarCode!=Calendar.YEAR && calendarCode!=Calendar.MONTH &&
|
calendarCode!=Calendar.DAY_OF_MONTH && calendarCode!=Calendar.DAY_OF_WEEK &&
|
calendarCode!=Calendar.WEEK_OF_YEAR)
|
{
|
return (x-y)/roughSize;
|
}
|
|
Calendar c1=TimeUtils.cal(x), c2=TimeUtils.cal(y);
|
int diff=0;
|
switch (calendarCode)
|
{
|
case Calendar.YEAR:
|
return (c1.get(Calendar.YEAR)-c2.get(Calendar.YEAR))/quantity;
|
|
case Calendar.MONTH:
|
diff= 12*(c1.get(Calendar.YEAR)-c2.get(Calendar.YEAR))+
|
c1.get(Calendar.MONTH)-c2.get(Calendar.MONTH);
|
return diff/quantity;
|
|
case Calendar.DAY_OF_MONTH:
|
case Calendar.DAY_OF_WEEK:
|
case Calendar.DAY_OF_YEAR:
|
case Calendar.WEEK_OF_MONTH:
|
case Calendar.WEEK_OF_YEAR:
|
// This is ugly, but believe me, it beats the alternative methods :-)
|
// We use the Calendar class's knowledge of daylight savings time.
|
// and also the fact that if we calculate this naively, then we aren't going
|
// to be off by more than one in either direction.
|
int naive=(int)Math.round((x-y)/(double)roughSize);
|
c2.add(calendarCode, naive*quantity);
|
if (c1.get(calendarCode)==c2.get(calendarCode))
|
return naive/quantity;
|
c2.add(calendarCode, quantity);
|
if (c1.get(calendarCode)==c2.get(calendarCode))
|
return naive/quantity+1;
|
return naive/quantity-1;
|
}
|
throw new IllegalArgumentException("Unexpected calendar code: "+calendarCode);
|
}
|
|
public long approxNumInRange(long start, long end)
|
{
|
return 1+(end-start)/roughSize;
|
}
|
|
public long getRoughSize() {
|
return roughSize;
|
}
|
|
public String format(Date date)
|
{
|
return format.format(date);
|
}
|
|
public String formatFull(Date date)
|
{
|
return fullFormat.format(date);
|
}
|
|
public String formatFull(long timestamp)
|
{
|
return fullFormat.format(new Date(timestamp));
|
}
|
|
public String getName() {
|
return name;
|
}
|
}
|
