001 /* ===========================================================
002 * JFreeChart : a free chart library for the Java(tm) platform
003 * ===========================================================
004 *
005 * (C) Copyright 2000-2008, by Object Refinery Limited and Contributors.
006 *
007 * Project Info: http://www.jfree.org/jfreechart/index.html
008 *
009 * This library is free software; you can redistribute it and/or modify it
010 * under the terms of the GNU Lesser General Public License as published by
011 * the Free Software Foundation; either version 2.1 of the License, or
012 * (at your option) any later version.
013 *
014 * This library is distributed in the hope that it will be useful, but
015 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017 * License for more details.
018 *
019 * You should have received a copy of the GNU Lesser General Public
020 * License along with this library; if not, write to the Free Software
021 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
022 * USA.
023 *
024 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
025 * in the United States and other countries.]
026 *
027 * ------------
028 * Quarter.java
029 * ------------
030 * (C) Copyright 2001-2008, by Object Refinery Limited.
031 *
032 * Original Author: David Gilbert (for Object Refinery Limited);
033 * Contributor(s): -;
034 *
035 * Changes
036 * -------
037 * 11-Oct-2001 : Version 1 (DG);
038 * 18-Dec-2001 : Changed order of parameters in constructor (DG);
039 * 19-Dec-2001 : Added a new constructor as suggested by Paul English (DG);
040 * 29-Jan-2002 : Added a new method parseQuarter(String) (DG);
041 * 14-Feb-2002 : Fixed bug in Quarter(Date) constructor (DG);
042 * 26-Feb-2002 : Changed getStart(), getMiddle() and getEnd() methods to
043 * evaluate with reference to a particular time zone (DG);
044 * 19-Mar-2002 : Changed API for TimePeriod classes (DG);
045 * 24-Jun-2002 : Removed main method (just test code) (DG);
046 * 10-Sep-2002 : Added getSerialIndex() method (DG);
047 * 07-Oct-2002 : Fixed errors reported by Checkstyle (DG);
048 * 10-Jan-2003 : Changed base class and method names (DG);
049 * 13-Mar-2003 : Moved to com.jrefinery.data.time package, and implemented
050 * Serializable (DG);
051 * 21-Oct-2003 : Added hashCode() method (DG);
052 * 10-Dec-2005 : Fixed argument checking bug (1377239) in constructor (DG);
053 * ------------- JFREECHART 1.0.x ---------------------------------------------
054 * 05-Oct-2006 : Updated API docs (DG);
055 * 06-Oct-2006 : Refactored to cache first and last millisecond values (DG);
056 * 16-Sep-2008 : Deprecated DEFAULT_TIME_ZONE (DG);
057 * 25-Nov-2008 : Added new constructor with Locale (DG);
058 *
059 */
060
061 package org.jfree.data.time;
062
063 import java.io.Serializable;
064 import java.util.Calendar;
065 import java.util.Date;
066 import java.util.Locale;
067 import java.util.TimeZone;
068
069 import org.jfree.date.MonthConstants;
070 import org.jfree.date.SerialDate;
071
072 /**
073 * Defines a quarter (in a given year). The range supported is Q1 1900 to
074 * Q4 9999. This class is immutable, which is a requirement for all
075 * {@link RegularTimePeriod} subclasses.
076 */
077 public class Quarter extends RegularTimePeriod implements Serializable {
078
079 /** For serialization. */
080 private static final long serialVersionUID = 3810061714380888671L;
081
082 /** Constant for quarter 1. */
083 public static final int FIRST_QUARTER = 1;
084
085 /** Constant for quarter 4. */
086 public static final int LAST_QUARTER = 4;
087
088 /** The first month in each quarter. */
089 public static final int[] FIRST_MONTH_IN_QUARTER = {
090 0, MonthConstants.JANUARY, MonthConstants.APRIL, MonthConstants.JULY,
091 MonthConstants.OCTOBER
092 };
093
094 /** The last month in each quarter. */
095 public static final int[] LAST_MONTH_IN_QUARTER = {
096 0, MonthConstants.MARCH, MonthConstants.JUNE, MonthConstants.SEPTEMBER,
097 MonthConstants.DECEMBER
098 };
099
100 /** The year in which the quarter falls. */
101 private short year;
102
103 /** The quarter (1-4). */
104 private byte quarter;
105
106 /** The first millisecond. */
107 private long firstMillisecond;
108
109 /** The last millisecond. */
110 private long lastMillisecond;
111
112 /**
113 * Constructs a new Quarter, based on the current system date/time.
114 */
115 public Quarter() {
116 this(new Date());
117 }
118
119 /**
120 * Constructs a new quarter.
121 *
122 * @param year the year (1900 to 9999).
123 * @param quarter the quarter (1 to 4).
124 */
125 public Quarter(int quarter, int year) {
126 if ((quarter < FIRST_QUARTER) || (quarter > LAST_QUARTER)) {
127 throw new IllegalArgumentException("Quarter outside valid range.");
128 }
129 this.year = (short) year;
130 this.quarter = (byte) quarter;
131 peg(Calendar.getInstance());
132 }
133
134 /**
135 * Constructs a new quarter.
136 *
137 * @param quarter the quarter (1 to 4).
138 * @param year the year (1900 to 9999).
139 */
140 public Quarter(int quarter, Year year) {
141 if ((quarter < FIRST_QUARTER) || (quarter > LAST_QUARTER)) {
142 throw new IllegalArgumentException("Quarter outside valid range.");
143 }
144 this.year = (short) year.getYear();
145 this.quarter = (byte) quarter;
146 peg(Calendar.getInstance());
147 }
148
149 /**
150 * Constructs a new instance, based on a date/time and the default time
151 * zone.
152 *
153 * @param time the date/time (<code>null</code> not permitted).
154 *
155 * @see #Quarter(Date, TimeZone)
156 */
157 public Quarter(Date time) {
158 this(time, TimeZone.getDefault());
159 }
160
161 /**
162 * Constructs a Quarter, based on a date/time and time zone.
163 *
164 * @param time the date/time.
165 * @param zone the zone (<code>null</code> not permitted).
166 *
167 * @deprecated Since 1.0.12, use {@link #Quarter(Date, TimeZone, Locale)}
168 * instead.
169 */
170 public Quarter(Date time, TimeZone zone) {
171 this(time, zone, Locale.getDefault());
172 }
173
174 /**
175 * Creates a new <code>Quarter</code> instance, using the specified
176 * zone and locale.
177 *
178 * @param time the current time.
179 * @param zone the time zone.
180 * @param locale the locale.
181 *
182 * @since 1.0.12
183 */
184 public Quarter(Date time, TimeZone zone, Locale locale) {
185 Calendar calendar = Calendar.getInstance(zone, locale);
186 calendar.setTime(time);
187 int month = calendar.get(Calendar.MONTH) + 1;
188 this.quarter = (byte) SerialDate.monthCodeToQuarter(month);
189 this.year = (short) calendar.get(Calendar.YEAR);
190 peg(calendar);
191 }
192
193 /**
194 * Returns the quarter.
195 *
196 * @return The quarter.
197 */
198 public int getQuarter() {
199 return this.quarter;
200 }
201
202 /**
203 * Returns the year.
204 *
205 * @return The year.
206 */
207 public Year getYear() {
208 return new Year(this.year);
209 }
210
211 /**
212 * Returns the year.
213 *
214 * @return The year.
215 *
216 * @since 1.0.3
217 */
218 public int getYearValue() {
219 return this.year;
220 }
221
222 /**
223 * Returns the first millisecond of the quarter. This will be determined
224 * relative to the time zone specified in the constructor, or in the
225 * calendar instance passed in the most recent call to the
226 * {@link #peg(Calendar)} method.
227 *
228 * @return The first millisecond of the quarter.
229 *
230 * @see #getLastMillisecond()
231 */
232 public long getFirstMillisecond() {
233 return this.firstMillisecond;
234 }
235
236 /**
237 * Returns the last millisecond of the quarter. This will be
238 * determined relative to the time zone specified in the constructor, or
239 * in the calendar instance passed in the most recent call to the
240 * {@link #peg(Calendar)} method.
241 *
242 * @return The last millisecond of the quarter.
243 *
244 * @see #getFirstMillisecond()
245 */
246 public long getLastMillisecond() {
247 return this.lastMillisecond;
248 }
249
250 /**
251 * Recalculates the start date/time and end date/time for this time period
252 * relative to the supplied calendar (which incorporates a time zone).
253 *
254 * @param calendar the calendar (<code>null</code> not permitted).
255 *
256 * @since 1.0.3
257 */
258 public void peg(Calendar calendar) {
259 this.firstMillisecond = getFirstMillisecond(calendar);
260 this.lastMillisecond = getLastMillisecond(calendar);
261 }
262
263 /**
264 * Returns the quarter preceding this one.
265 *
266 * @return The quarter preceding this one (or <code>null</code> if this is
267 * Q1 1900).
268 */
269 public RegularTimePeriod previous() {
270 Quarter result;
271 if (this.quarter > FIRST_QUARTER) {
272 result = new Quarter(this.quarter - 1, this.year);
273 }
274 else {
275 if (this.year > 1900) {
276 result = new Quarter(LAST_QUARTER, this.year - 1);
277 }
278 else {
279 result = null;
280 }
281 }
282 return result;
283 }
284
285 /**
286 * Returns the quarter following this one.
287 *
288 * @return The quarter following this one (or null if this is Q4 9999).
289 */
290 public RegularTimePeriod next() {
291 Quarter result;
292 if (this.quarter < LAST_QUARTER) {
293 result = new Quarter(this.quarter + 1, this.year);
294 }
295 else {
296 if (this.year < 9999) {
297 result = new Quarter(FIRST_QUARTER, this.year + 1);
298 }
299 else {
300 result = null;
301 }
302 }
303 return result;
304 }
305
306 /**
307 * Returns a serial index number for the quarter.
308 *
309 * @return The serial index number.
310 */
311 public long getSerialIndex() {
312 return this.year * 4L + this.quarter;
313 }
314
315 /**
316 * Tests the equality of this Quarter object to an arbitrary object.
317 * Returns <code>true</code> if the target is a Quarter instance
318 * representing the same quarter as this object. In all other cases,
319 * returns <code>false</code>.
320 *
321 * @param obj the object (<code>null</code> permitted).
322 *
323 * @return <code>true</code> if quarter and year of this and the object are
324 * the same.
325 */
326 public boolean equals(Object obj) {
327
328 if (obj != null) {
329 if (obj instanceof Quarter) {
330 Quarter target = (Quarter) obj;
331 return (this.quarter == target.getQuarter()
332 && (this.year == target.getYearValue()));
333 }
334 else {
335 return false;
336 }
337 }
338 else {
339 return false;
340 }
341
342 }
343
344 /**
345 * Returns a hash code for this object instance. The approach described by
346 * Joshua Bloch in "Effective Java" has been used here:
347 * <p>
348 * <code>http://developer.java.sun.com/developer/Books/effectivejava
349 * /Chapter3.pdf</code>
350 *
351 * @return A hash code.
352 */
353 public int hashCode() {
354 int result = 17;
355 result = 37 * result + this.quarter;
356 result = 37 * result + this.year;
357 return result;
358 }
359
360 /**
361 * Returns an integer indicating the order of this Quarter object relative
362 * to the specified object:
363 *
364 * negative == before, zero == same, positive == after.
365 *
366 * @param o1 the object to compare
367 *
368 * @return negative == before, zero == same, positive == after.
369 */
370 public int compareTo(Object o1) {
371
372 int result;
373
374 // CASE 1 : Comparing to another Quarter object
375 // --------------------------------------------
376 if (o1 instanceof Quarter) {
377 Quarter q = (Quarter) o1;
378 result = this.year - q.getYearValue();
379 if (result == 0) {
380 result = this.quarter - q.getQuarter();
381 }
382 }
383
384 // CASE 2 : Comparing to another TimePeriod object
385 // -----------------------------------------------
386 else if (o1 instanceof RegularTimePeriod) {
387 // more difficult case - evaluate later...
388 result = 0;
389 }
390
391 // CASE 3 : Comparing to a non-TimePeriod object
392 // ---------------------------------------------
393 else {
394 // consider time periods to be ordered after general objects
395 result = 1;
396 }
397
398 return result;
399
400 }
401
402 /**
403 * Returns a string representing the quarter (e.g. "Q1/2002").
404 *
405 * @return A string representing the quarter.
406 */
407 public String toString() {
408 return "Q" + this.quarter + "/" + this.year;
409 }
410
411 /**
412 * Returns the first millisecond in the Quarter, evaluated using the
413 * supplied calendar (which determines the time zone).
414 *
415 * @param calendar the calendar (<code>null</code> not permitted).
416 *
417 * @return The first millisecond in the Quarter.
418 *
419 * @throws NullPointerException if <code>calendar</code> is
420 * <code>null</code>.
421 */
422 public long getFirstMillisecond(Calendar calendar) {
423 int month = Quarter.FIRST_MONTH_IN_QUARTER[this.quarter];
424 calendar.set(this.year, month - 1, 1, 0, 0, 0);
425 calendar.set(Calendar.MILLISECOND, 0);
426 // in the following line, we'd rather call calendar.getTimeInMillis()
427 // to avoid object creation, but that isn't supported in Java 1.3.1
428 return calendar.getTime().getTime();
429 }
430
431 /**
432 * Returns the last millisecond of the Quarter, evaluated using the
433 * supplied calendar (which determines the time zone).
434 *
435 * @param calendar the calendar (<code>null</code> not permitted).
436 *
437 * @return The last millisecond of the Quarter.
438 *
439 * @throws NullPointerException if <code>calendar</code> is
440 * <code>null</code>.
441 */
442 public long getLastMillisecond(Calendar calendar) {
443 int month = Quarter.LAST_MONTH_IN_QUARTER[this.quarter];
444 int eom = SerialDate.lastDayOfMonth(month, this.year);
445 calendar.set(this.year, month - 1, eom, 23, 59, 59);
446 calendar.set(Calendar.MILLISECOND, 999);
447 // in the following line, we'd rather call calendar.getTimeInMillis()
448 // to avoid object creation, but that isn't supported in Java 1.3.1
449 return calendar.getTime().getTime();
450 }
451
452 /**
453 * Parses the string argument as a quarter.
454 * <P>
455 * This method should accept the following formats: "YYYY-QN" and "QN-YYYY",
456 * where the "-" can be a space, a forward-slash (/), comma or a dash (-).
457 * @param s A string representing the quarter.
458 *
459 * @return The quarter.
460 */
461 public static Quarter parseQuarter(String s) {
462
463 // find the Q and the integer following it (remove both from the
464 // string)...
465 int i = s.indexOf("Q");
466 if (i == -1) {
467 throw new TimePeriodFormatException("Missing Q.");
468 }
469
470 if (i == s.length() - 1) {
471 throw new TimePeriodFormatException("Q found at end of string.");
472 }
473
474 String qstr = s.substring(i + 1, i + 2);
475 int quarter = Integer.parseInt(qstr);
476 String remaining = s.substring(0, i) + s.substring(i + 2, s.length());
477
478 // replace any / , or - with a space
479 remaining = remaining.replace('/', ' ');
480 remaining = remaining.replace(',', ' ');
481 remaining = remaining.replace('-', ' ');
482
483 // parse the string...
484 Year year = Year.parseYear(remaining.trim());
485 Quarter result = new Quarter(quarter, year);
486 return result;
487
488 }
489
490 }