| Constructor: |
|---|
 public Week() {
this(new Date());
}
Creates a new time period for the week in which the current system
date/time falls. |
public Week(Date time) {
// defer argument checking...
this(time, RegularTimePeriod.DEFAULT_TIME_ZONE, Locale.getDefault());
} Creates a time period for the week in which the specified date/time
falls. Parameters:
time - the time (null not permitted).
|
public Week(int week,
int year) {
if ((week < FIRST_WEEK_IN_YEAR) && (week > LAST_WEEK_IN_YEAR)) {
throw new IllegalArgumentException(
"The 'week' argument must be in the range 1 - 53.");
}
this.week = (byte) week;
this.year = (short) year;
peg(Calendar.getInstance());
} Creates a time period representing the week in the specified year. Parameters:
week - the week (1 to 53).
year - the year (1900 to 9999).
|
public Week(int week,
Year year) {
if ((week < FIRST_WEEK_IN_YEAR) && (week > LAST_WEEK_IN_YEAR)) {
throw new IllegalArgumentException(
"The 'week' argument must be in the range 1 - 53.");
}
this.week = (byte) week;
this.year = (short) year.getYear();
peg(Calendar.getInstance());
} Creates a time period representing the week in the specified year. Parameters:
week - the week (1 to 53).
year - the year (1900 to 9999).
|
public Week(Date time,
TimeZone zone) {
// defer argument checking...
this(time, zone, Locale.getDefault());
} Creates a time period for the week in which the specified date/time
falls, calculated relative to the specified time zone. Parameters:
time - the date/time (null not permitted).
zone - the time zone (null not permitted).
|
public Week(Date time,
TimeZone zone,
Locale locale) {
if (time == null) {
throw new IllegalArgumentException("Null 'time' argument.");
}
if (zone == null) {
throw new IllegalArgumentException("Null 'zone' argument.");
}
if (locale == null) {
throw new IllegalArgumentException("Null 'locale' argument.");
}
Calendar calendar = Calendar.getInstance(zone, locale);
calendar.setTime(time);
// sometimes the last few days of the year are considered to fall in
// the *first* week of the following year. Refer to the Javadocs for
// GregorianCalendar.
int tempWeek = calendar.get(Calendar.WEEK_OF_YEAR);
if (tempWeek == 1
&& calendar.get(Calendar.MONTH) == Calendar.DECEMBER) {
this.week = 1;
this.year = (short) (calendar.get(Calendar.YEAR) + 1);
}
else {
this.week = (byte) Math.min(tempWeek, LAST_WEEK_IN_YEAR);
int yyyy = calendar.get(Calendar.YEAR);
// alternatively, sometimes the first few days of the year are
// considered to fall in the *last* week of the previous year...
if (calendar.get(Calendar.MONTH) == Calendar.JANUARY
&& this.week >= 52) {
yyyy--;
}
this.year = (short) yyyy;
}
peg(calendar);
} Creates a time period for the week in which the specified date/time
falls, calculated relative to the specified time zone. Parameters:
time - the date/time (null not permitted).
zone - the time zone (null not permitted).
locale - the locale (null not permitted).
- since:
1.0.7 -
|
| Method from org.jfree.data.time.Week Detail: |
|---|
public int compareTo(Object o1) {
int result;
// CASE 1 : Comparing to another Week object
// --------------------------------------------
if (o1 instanceof Week) {
Week w = (Week) o1;
result = this.year - w.getYear().getYear();
if (result == 0) {
result = this.week - w.getWeek();
}
}
// CASE 2 : Comparing to another TimePeriod object
// -----------------------------------------------
else if (o1 instanceof RegularTimePeriod) {
// more difficult case - evaluate later...
result = 0;
}
// CASE 3 : Comparing to a non-TimePeriod object
// ---------------------------------------------
else {
// consider time periods to be ordered after general objects
result = 1;
}
return result;
} Returns an integer indicating the order of this Week object relative to
the specified object:
negative == before, zero == same, positive == after. |
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof Week)) {
return false;
}
Week that = (Week) obj;
if (this.week != that.week) {
return false;
}
if (this.year != that.year) {
return false;
}
return true;
} Tests the equality of this Week object to an arbitrary object. Returns
true if the target is a Week instance representing the same week as this
object. In all other cases, returns false. |
public long getFirstMillisecond() {
return this.firstMillisecond;
} Returns the first millisecond of the week. This will be determined
relative to the time zone specified in the constructor, or in the
calendar instance passed in the most recent call to the
#peg(Calendar) method. |
public long getFirstMillisecond(Calendar calendar) {
Calendar c = (Calendar) calendar.clone();
c.clear();
c.set(Calendar.YEAR, this.year);
c.set(Calendar.WEEK_OF_YEAR, this.week);
c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());
c.set(Calendar.HOUR, 0);
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND, 0);
c.set(Calendar.MILLISECOND, 0);
//return c.getTimeInMillis(); // this won't work for JDK 1.3
return c.getTime().getTime();
} Returns the first millisecond of the week, evaluated using the supplied
calendar (which determines the time zone). |
public long getLastMillisecond() {
return this.lastMillisecond;
} Returns the last millisecond of the week. This will be
determined relative to the time zone specified in the constructor, or
in the calendar instance passed in the most recent call to the
#peg(Calendar) method. |
public long getLastMillisecond(Calendar calendar) {
Calendar c = (Calendar) calendar.clone();
c.clear();
c.set(Calendar.YEAR, this.year);
c.set(Calendar.WEEK_OF_YEAR, this.week + 1);
c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());
c.set(Calendar.HOUR, 0);
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND, 0);
c.set(Calendar.MILLISECOND, 0);
//return c.getTimeInMillis(); // this won't work for JDK 1.3
return c.getTime().getTime() - 1;
} Returns the last millisecond of the week, evaluated using the supplied
calendar (which determines the time zone). |
public long getSerialIndex() {
return this.year * 53L + this.week;
} Returns a serial index number for the week. |
public int getWeek() {
return this.week;
} |
public Year getYear() {
return new Year(this.year);
} Returns the year in which the week falls. |
public int getYearValue() {
return this.year;
} Returns the year in which the week falls, as an integer value. |
public int hashCode() {
int result = 17;
result = 37 * result + this.week;
result = 37 * result + this.year;
return result;
} |
public RegularTimePeriod next() {
Week result;
if (this.week < 52) {
result = new Week(this.week + 1, this.year);
}
else {
Calendar calendar = Calendar.getInstance();
calendar.set(this.year, Calendar.DECEMBER, 31);
int actualMaxWeek
= calendar.getActualMaximum(Calendar.WEEK_OF_YEAR);
if (this.week < actualMaxWeek) {
result = new Week(this.week + 1, this.year);
}
else {
if (this.year < 9999) {
result = new Week(FIRST_WEEK_IN_YEAR, this.year + 1);
}
else {
result = null;
}
}
}
return result;
} Returns the week following this one. This method will return
null for some upper limit on the range of weeks (currently
week 53, 9999). For week 52 of any year, the following week is always
week 53, but week 53 may not contain any days (you should check for
this). |
public static Week parseWeek(String s) {
Week result = null;
if (s != null) {
// trim whitespace from either end of the string
s = s.trim();
int i = Week.findSeparator(s);
if (i != -1) {
String s1 = s.substring(0, i).trim();
String s2 = s.substring(i + 1, s.length()).trim();
Year y = Week.evaluateAsYear(s1);
int w;
if (y != null) {
w = Week.stringToWeek(s2);
if (w == -1) {
throw new TimePeriodFormatException(
"Can't evaluate the week.");
}
result = new Week(w, y);
}
else {
y = Week.evaluateAsYear(s2);
if (y != null) {
w = Week.stringToWeek(s1);
if (w == -1) {
throw new TimePeriodFormatException(
"Can't evaluate the week.");
}
result = new Week(w, y);
}
else {
throw new TimePeriodFormatException(
"Can't evaluate the year.");
}
}
}
else {
throw new TimePeriodFormatException(
"Could not find separator.");
}
}
return result;
} Parses the string argument as a week.
This method is required to accept the format "YYYY-Wnn". It will also
accept "Wnn-YYYY". Anything else, at the moment, is a bonus. |
public void peg(Calendar calendar) {
this.firstMillisecond = getFirstMillisecond(calendar);
this.lastMillisecond = getLastMillisecond(calendar);
} Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone). |
public RegularTimePeriod previous() {
Week result;
if (this.week != FIRST_WEEK_IN_YEAR) {
result = new Week(this.week - 1, this.year);
}
else {
// we need to work out if the previous year has 52 or 53 weeks...
if (this.year > 1900) {
int yy = this.year - 1;
Calendar prevYearCalendar = Calendar.getInstance();
prevYearCalendar.set(yy, Calendar.DECEMBER, 31);
result = new Week(prevYearCalendar.getActualMaximum(
Calendar.WEEK_OF_YEAR), yy);
}
else {
result = null;
}
}
return result;
} Returns the week preceding this one. This method will return
null for some lower limit on the range of weeks (currently
week 1, 1900). For week 1 of any year, the previous week is always week
53, but week 53 may not contain any days (you should check for this). |
public String toString() {
return "Week " + this.week + ", " + this.year;
} Returns a string representing the week (e.g. "Week 9, 2002").
TODO: look at internationalisation. |
org.jfree.data.time.RegularTimePeriod
Save This Page