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 * Year.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 * 14-Nov-2001 : Override for toString() method (DG);
039 * 19-Dec-2001 : Added a new constructor as suggested by Paul English (DG);
040 * 29-Jan-2002 : Worked on parseYear() method (DG);
041 * 14-Feb-2002 : Fixed bug in Year(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 * 10-Sep-2002 : Added getSerialIndex() method (DG);
046 * 04-Oct-2002 : Fixed errors reported by Checkstyle (DG);
047 * 10-Jan-2003 : Changed base class and method names (DG);
048 * 05-Mar-2003 : Fixed bug in getFirstMillisecond() picked up in JUnit
049 *               tests (DG);
050 * 13-Mar-2003 : Moved to com.jrefinery.data.time package, and implemented
051 *               Serializable (DG);
052 * 21-Oct-2003 : Added hashCode() method (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 : Extended range of valid years, and deprecated
057 *               DEFAULT_TIME_ZONE (DG);
058 * 25-Nov-2008 : Added new constructor with Locale (DG);
059 *
060 */
061
062package org.jfree.data.time;
063
064import java.io.Serializable;
065import java.util.Calendar;
066import java.util.Date;
067import java.util.Locale;
068import java.util.TimeZone;
069
070/**
071 * Represents a year in the range -9999 to 9999.  This class is immutable,
072 * which is a requirement for all {@link RegularTimePeriod} subclasses.
073 */
074public class Year extends RegularTimePeriod implements Serializable {
075
076    /**
077     * The minimum year value.
078     *
079     * @since 1.0.11
080     */
081    public static final int MINIMUM_YEAR = -9999;
082
083    /**
084     * The maximum year value.
085     *
086     * @since 1.0.11
087     */
088    public static final int MAXIMUM_YEAR = 9999;
089
090    /** For serialization. */
091    private static final long serialVersionUID = -7659990929736074836L;
092
093    /** The year. */
094    private short year;
095
096    /** The first millisecond. */
097    private long firstMillisecond;
098
099    /** The last millisecond. */
100    private long lastMillisecond;
101
102    /**
103     * Creates a new <code>Year</code>, based on the current system date/time.
104     */
105    public Year() {
106        this(new Date());
107    }
108
109    /**
110     * Creates a time period representing a single year.
111     *
112     * @param year  the year.
113     */
114    public Year(int year) {
115        if ((year < Year.MINIMUM_YEAR) || (year > Year.MAXIMUM_YEAR)) {
116            throw new IllegalArgumentException(
117                "Year constructor: year (" + year + ") outside valid range.");
118        }
119        this.year = (short) year;
120        peg(Calendar.getInstance());
121    }
122
123    /**
124     * Creates a new <code>Year</code>, based on a particular instant in time,
125     * using the default time zone.
126     *
127     * @param time  the time (<code>null</code> not permitted).
128     *
129     * @see #Year(Date, TimeZone)
130     */
131    public Year(Date time) {
132        this(time, TimeZone.getDefault());
133    }
134
135    /**
136     * Constructs a year, based on a particular instant in time and a time zone.
137     *
138     * @param time  the time (<code>null</code> not permitted).
139     * @param zone  the time zone.
140     *
141     * @deprecated Since 1.0.12, use {@link #Year(Date, TimeZone, Locale)}
142     *     instead.
143     */
144    public Year(Date time, TimeZone zone) {
145        this(time, zone, Locale.getDefault());
146    }
147
148    /**
149     * Creates a new <code>Year</code> instance, for the specified time zone
150     * and locale.
151     *
152     * @param time  the current time (<code>null</code> not permitted).
153     * @param zone  the time zone.
154     * @param locale  the locale.
155     *
156     * @since 1.0.12
157     */
158    public Year(Date time, TimeZone zone, Locale locale) {
159        Calendar calendar = Calendar.getInstance(zone, locale);
160        calendar.setTime(time);
161        this.year = (short) calendar.get(Calendar.YEAR);
162        peg(calendar);
163    }
164
165    /**
166     * Returns the year.
167     *
168     * @return The year.
169     */
170    public int getYear() {
171        return this.year;
172    }
173
174    /**
175     * Returns the first millisecond of the year.  This will be determined
176     * relative to the time zone specified in the constructor, or in the
177     * calendar instance passed in the most recent call to the
178     * {@link #peg(Calendar)} method.
179     *
180     * @return The first millisecond of the year.
181     *
182     * @see #getLastMillisecond()
183     */
184    public long getFirstMillisecond() {
185        return this.firstMillisecond;
186    }
187
188    /**
189     * Returns the last millisecond of the year.  This will be
190     * determined relative to the time zone specified in the constructor, or
191     * in the calendar instance passed in the most recent call to the
192     * {@link #peg(Calendar)} method.
193     *
194     * @return The last millisecond of the year.
195     *
196     * @see #getFirstMillisecond()
197     */
198    public long getLastMillisecond() {
199        return this.lastMillisecond;
200    }
201
202    /**
203     * Recalculates the start date/time and end date/time for this time period
204     * relative to the supplied calendar (which incorporates a time zone).
205     *
206     * @param calendar  the calendar (<code>null</code> not permitted).
207     *
208     * @since 1.0.3
209     */
210    public void peg(Calendar calendar) {
211        this.firstMillisecond = getFirstMillisecond(calendar);
212        this.lastMillisecond = getLastMillisecond(calendar);
213    }
214
215    /**
216     * Returns the year preceding this one.
217     *
218     * @return The year preceding this one (or <code>null</code> if the
219     *         current year is -9999).
220     */
221    public RegularTimePeriod previous() {
222        if (this.year > Year.MINIMUM_YEAR) {
223            return new Year(this.year - 1);
224        }
225        else {
226            return null;
227        }
228    }
229
230    /**
231     * Returns the year following this one.
232     *
233     * @return The year following this one (or <code>null</code> if the current
234     *         year is 9999).
235     */
236    public RegularTimePeriod next() {
237        if (this.year < Year.MAXIMUM_YEAR) {
238            return new Year(this.year + 1);
239        }
240        else {
241            return null;
242        }
243    }
244
245    /**
246     * Returns a serial index number for the year.
247     * <P>
248     * The implementation simply returns the year number (e.g. 2002).
249     *
250     * @return The serial index number.
251     */
252    public long getSerialIndex() {
253        return this.year;
254    }
255
256    /**
257     * Returns the first millisecond of the year, evaluated using the supplied
258     * calendar (which determines the time zone).
259     *
260     * @param calendar  the calendar (<code>null</code> not permitted).
261     *
262     * @return The first millisecond of the year.
263     *
264     * @throws NullPointerException if <code>calendar</code> is
265     *     <code>null</code>.
266     */
267    public long getFirstMillisecond(Calendar calendar) {
268        calendar.set(this.year, Calendar.JANUARY, 1, 0, 0, 0);
269        calendar.set(Calendar.MILLISECOND, 0);
270        // in the following line, we'd rather call calendar.getTimeInMillis()
271        // to avoid object creation, but that isn't supported in Java 1.3.1
272        return calendar.getTime().getTime();
273    }
274
275    /**
276     * Returns the last millisecond of the year, evaluated using the supplied
277     * calendar (which determines the time zone).
278     *
279     * @param calendar  the calendar (<code>null</code> not permitted).
280     *
281     * @return The last millisecond of the year.
282     *
283     * @throws NullPointerException if <code>calendar</code> is
284     *     <code>null</code>.
285     */
286    public long getLastMillisecond(Calendar calendar) {
287        calendar.set(this.year, Calendar.DECEMBER, 31, 23, 59, 59);
288        calendar.set(Calendar.MILLISECOND, 999);
289        // in the following line, we'd rather call calendar.getTimeInMillis()
290        // to avoid object creation, but that isn't supported in Java 1.3.1
291        return calendar.getTime().getTime();
292    }
293
294    /**
295     * Tests the equality of this <code>Year</code> object to an arbitrary
296     * object.  Returns <code>true</code> if the target is a <code>Year</code>
297     * instance representing the same year as this object.  In all other cases,
298     * returns <code>false</code>.
299     *
300     * @param obj  the object (<code>null</code> permitted).
301     *
302     * @return <code>true</code> if the year of this and the object are the
303     *         same.
304     */
305    public boolean equals(Object obj) {
306        if (obj == this) {
307            return true;
308        }
309        if (!(obj instanceof Year)) {
310            return false;
311        }
312        Year that = (Year) obj;
313        return (this.year == that.year);
314    }
315
316    /**
317     * Returns a hash code for this object instance.  The approach described by
318     * Joshua Bloch in "Effective Java" has been used here:
319     * <p>
320     * <code>http://developer.java.sun.com/developer/Books/effectivejava
321     *     /Chapter3.pdf</code>
322     *
323     * @return A hash code.
324     */
325    public int hashCode() {
326        int result = 17;
327        int c = this.year;
328        result = 37 * result + c;
329        return result;
330    }
331
332    /**
333     * Returns an integer indicating the order of this <code>Year</code> object
334     * relative to the specified object:
335     *
336     * negative == before, zero == same, positive == after.
337     *
338     * @param o1  the object to compare.
339     *
340     * @return negative == before, zero == same, positive == after.
341     */
342    public int compareTo(Object o1) {
343
344        int result;
345
346        // CASE 1 : Comparing to another Year object
347        // -----------------------------------------
348        if (o1 instanceof Year) {
349            Year y = (Year) o1;
350            result = this.year - y.getYear();
351        }
352
353        // CASE 2 : Comparing to another TimePeriod object
354        // -----------------------------------------------
355        else if (o1 instanceof RegularTimePeriod) {
356            // more difficult case - evaluate later...
357            result = 0;
358        }
359
360        // CASE 3 : Comparing to a non-TimePeriod object
361        // ---------------------------------------------
362        else {
363            // consider time periods to be ordered after general objects
364            result = 1;
365        }
366
367        return result;
368
369    }
370
371    /**
372     * Returns a string representing the year..
373     *
374     * @return A string representing the year.
375     */
376    public String toString() {
377        return Integer.toString(this.year);
378    }
379
380    /**
381     * Parses the string argument as a year.
382     * <P>
383     * The string format is YYYY.
384     *
385     * @param s  a string representing the year.
386     *
387     * @return <code>null</code> if the string is not parseable, the year
388     *         otherwise.
389     */
390    public static Year parseYear(String s) {
391
392        // parse the string...
393        int y;
394        try {
395            y = Integer.parseInt(s.trim());
396        }
397        catch (NumberFormatException e) {
398            throw new TimePeriodFormatException("Cannot parse string.");
399        }
400
401        // create the year...
402        try {
403            return new Year(y);
404        }
405        catch (IllegalArgumentException e) {
406            throw new TimePeriodFormatException("Year outside valid range.");
407        }
408    }
409
410}