View Javadoc
   /*
    * ==================================================================== The
    * Apache Software License, Version 1.1
    * 
    * Copyright (c) 2003 Digital Clash LLC. All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met: 1.
    * Redistributions of source code must retain the above copyright notice, this
   * list of conditions and the following disclaimer. 2. Redistributions in
   * binary form must reproduce the above copyright notice, this list of
   * conditions and the following disclaimer in the documentation and/or other
   * materials provided with the distribution. 3. The end-user documentation
   * included with the redistribution, if any, must include the following
   * acknowledgment: "This product includes software developed by the ChronicJ
   * team (http://www.chronicj.org/)." Alternately, this acknowledgment may
   * appear in the software itself, if and wherever such third-party
   * acknowledgments normally appear. 4. The names "ChronicJ" and "Digital Clash"
   * not be used to endorse or promote products derived from this software
   * without prior written permission. For written permission, please contact
   * info@digitalclash.com. 5. Products derived from this software may not be
   * called "ChronicJ", "Digital Clash", nor may "ChronicJ" or "Digital Clash"
   * appear in their name, without prior written permission of Digital Clash LLC.
   * 
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
   * APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   * ==================================================================== This
   * product includes software developed by the by the Apache Software Foundation
   * (http://www.apache.org/).
   * ====================================================================
   */
  package org.chronicj;
  
  import java.text.SimpleDateFormat;
  
  import java.util.Calendar;
  import java.util.Date;
  import java.util.GregorianCalendar;
  
  /***
   * <p>
   * Based directly on the <a href="http://martinfowler.com/ap2/timePoint.html">
   * Time Point</a> pattern described by Martin Fowler. This class wraps the
   * standard {@link java.util.GregorianCalendar GregorianCalendar}in order to
   * to simplify date precision. Also, some convenience constructors and methods
   * are provided.
   * </p>
   * 
   * <p>
   * Since things will break if a non- <code>GregorianCalendar</code> is
   * supplied, declarations explicitly deal with the concrete class instead of
   * working with the abstract supertype {@link java.util.Calendar Calendar}.
   * </p>
   * 
   * @author <a href="mlipper@US-ABP.com">Matthew Lipper</a>
   */
  public class TimePoint implements Comparable
  {
  	/*** Default precision is {@link DatePrecision#MINUTE}. */
  	private static final DatePrecision DEFAULT_PRECISION = DatePrecision.MINUTE;
  	private static final SimpleDateFormat sdf =
  		new SimpleDateFormat("EEE, d MMM yyyy h:mm:ss.S a Z");
  	private DatePrecision datePrecision;
  	private GregorianCalendar base;
  
  	/***
  	 * Convenience constructor allowing the more natural 1-based-index for
  	 * specifying month. Timezone is ignored.
  	 * 
  	 * @param year
  	 *                    the year
  	 * @param month
  	 *                    the month using 1 to 12, where 1 == January and 12 ==
  	 *                    DECEMBER. NOTE: java.util.Calendar is zero based, this is <b>
  	 *                    not</b>.
  	 * @param day
  	 *                    the day of the month using 1 to 31
  	 */
  	public TimePoint(int year, int month, int day)
  	{
  		validate(year, DatePrecision.YEAR);
  		validate(month, DatePrecision.MONTH);
  		validate(day, DatePrecision.DATE);
  
  		initializeToPrecision(
  			new GregorianCalendar(year, month - 1, day),
  			DatePrecision.DATE);
  	}
  
  	/***
  	 * Convenience constructor allowing the more natural 1-based-index for
 	 * specifying month. Timezone is ignored.
 	 * 
 	 * @param year
 	 *                    the year
 	 * @param month
 	 *                    the month using 1 to 12, where 1 == January and 12 ==
 	 *                    DECEMBER. NOTE: java.util.Calendar is zero based, this is <b>
 	 *                    not</b>.
 	 */
 	public TimePoint(int year, int month)
 	{
 		validate(year, DatePrecision.YEAR);
 		validate(month, DatePrecision.MONTH);
 
 		//The date will be reset :-)
 		initializeToPrecision(
 			new GregorianCalendar(year, month - 1, 1),
 			DatePrecision.MONTH);
 	}
 
 	/***
 	 * Convenience constructor allowing the more natural 1-based-index for
 	 * specifying month. Timezone is ignored.
 	 * 
 	 * @param year
 	 *                    the year
 	 * @param month
 	 *                    the month using 1 to 12, where 1 == January and 12 ==
 	 *                    DECEMBER. NOTE: java.util.Calendar is zero based, this is
 	 *                    not.
 	 * @param day
 	 *                    the day of the month using 1 to 31
 	 * @param hour
 	 *                    the hour of the day using 0 to 24
 	 */
 	public TimePoint(int year, int month, int day, int hour)
 	{
 		validate(year, DatePrecision.YEAR);
 		validate(month, DatePrecision.MONTH);
 		validate(day, DatePrecision.DATE);
 		validate(hour, DatePrecision.HOUR_OF_DAY);
 
 		initializeToPrecision(
 			new GregorianCalendar(year, month - 1, day, hour, 0),
 			DatePrecision.HOUR_OF_DAY);
 	}
 
 	/***
 	 * Convenience constructor allowing the more natural 1-based-index for
 	 * specifying month. Timezone is ignored.
 	 * 
 	 * @param year
 	 *                    the year
 	 * @param month
 	 *                    the month using 1 to 12, where 1 == January and 12 ==
 	 *                    DECEMBER. NOTE: java.util.Calendar is zero based, this is
 	 *                    not.
 	 * @param day
 	 *                    the day of the month using 1 to 31
 	 * @param hour
 	 *                    the hour of the day using 0 to 24
 	 * @param minute
 	 *                    the minute of the hour using 0 to 60
 	 */
 	public TimePoint(int year, int month, int day, int hour, int minute)
 	{
 		validate(year, DatePrecision.YEAR);
 		validate(month, DatePrecision.MONTH);
 		validate(day, DatePrecision.DATE);
 		validate(hour, DatePrecision.HOUR_OF_DAY);
 		validate(minute, DatePrecision.MINUTE);
 
 		initializeToPrecision(
 			new GregorianCalendar(year, month - 1, day, hour, minute),
 			DatePrecision.MINUTE);
 	}
 
 	/***
 	 * Delegates call to {@link TimePoint#TimePoint(GregorianCalendar,
 	 * DatePrecision)} using constant {@link TimePoint#DEFAULT_PRECISION}.
 	 * 
 	 * @param arg
 	 *                    the GregorianCalendar which will be set using
 	 *                    TimePoint#DEFAULT_PRECISION.
 	 */
 	public TimePoint(GregorianCalendar arg)
 	{
 		//delegate constructor
 		this(arg, DEFAULT_PRECISION);
 	}
 
 	/***
 	 * Creates a TimePoint using default DatePrecision.
 	 * 
 	 * @param aDate
 	 *                    the Date which will be set using {@link
 	 *                    TimePoint#DEFAULT_PRECISION}.
 	 */
 	public TimePoint(Date aDate)
 	{
 		this(aDate, DEFAULT_PRECISION);
 	}
 
 	/***
 	 * Creates a TimePoint using the specified DatePrecision.
 	 * 
 	 * @param aDate
 	 *                    the Date to be set
 	 * @param precision
 	 *                    the DatePrecision to use
 	 * 
 	 * @throws NullPointerException
 	 *                    if supplied Date is null
 	 */
 	public TimePoint(Date aDate, DatePrecision precision)
 	{
 		if (aDate == null)
 		{
 			throw new NullPointerException("Date argument cannot be null.");
 		}
 
 		GregorianCalendar aCalendar = new GregorianCalendar();
 		aCalendar.setTime(aDate);
 		initializeToPrecision(aCalendar, precision);
 	}
 
 	/***
 	 * Creates a TimePoint using specified DatePrecision. Timezone information
 	 * is assumed set or not set by the caller. <br/>NOTE: ATM,
 	 * GregorianCalendar argument obeys pass by value semantics.
 	 * 
 	 * @param arg
 	 *                    the GregorianCalendar with the requested date value
 	 * @param precision
 	 *                    the DatePrecision to use
 	 */
 	public TimePoint(GregorianCalendar arg, DatePrecision precision)
 	{
 		this(arg.getTime(), precision);
 	}
 
 	/***
 	 * Getter method for the wrapped GregorianCalendar.
 	 * 
 	 * @return the wrapped GregorianCalendar
 	 */
 	public GregorianCalendar getCalendar()
 	{
 		return base;
 	}
 
 	/***
 	 * Getter method for DatePrecision field.
 	 * 
 	 * @return DatePrecision of this TimePoint
 	 */
 	public DatePrecision getDatePrecision()
 	{
 		return datePrecision;
 	}
 
 	/***
 	 * Getter for day of the month.
 	 * 
 	 * @return int day of the month
 	 */
 	public int getDayOfMonth()
 	{
 		return base.get(Calendar.DAY_OF_MONTH);
 	}
 
 	/***
 	 * Getter for day of the week.
 	 * 
 	 * @return int day of the week.
 	 */
 	public int getDayOfWeek()
 	{
 		return base.get(Calendar.DAY_OF_WEEK);
 	}
 
 	/***
 	 * Getter for hour of the day (24hr).
 	 * 
 	 * @return int hour of the day
 	 */
 	public int getHourOfDay()
 	{
 		return base.get(Calendar.HOUR_OF_DAY);
 	}
 
 	/***
 	 * Getter for milliseconds.
 	 * 
 	 * @return int milliseconds
 	 */
 	public int getMilliSeconds()
 	{
 		return base.get(Calendar.MILLISECOND);
 	}
 
 	/***
 	 * Getter for minutes.
 	 * 
 	 * @return int minutes
 	 */
 	public int getMinute()
 	{
 		return base.get(Calendar.MINUTE);
 	}
 
 	/***
 	 * Getter for month (<b>not</b> zero-indexed). Values will be between 1
 	 * and 12 for {@link GregorianCalendar}s.
 	 * 
 	 * @return int month
 	 */
 	public int getMonth()
 	{
 		return base.get(Calendar.MONTH) + 1;
 	}
 
 	/***
 	 * Getter for seconds.
 	 * 
 	 * @return int seconds
 	 */
 	public int getSeconds()
 	{
 		return base.get(Calendar.SECOND);
 	}
 
 	/***
 	 * Convenience getter method for {@link #getCalendar}
 	 * 
 	 * @return the wrapped GregorianCalendar as a Date
 	 */
 	public Date getTime()
 	{
 		return base.getTime();
 	}
 
 	/***
 	 * Getter for year.
 	 * 
 	 * @return int year
 	 */
 	public int getYear()
 	{
 		return base.get(Calendar.YEAR);
 	}
 
 	/***
 	 * Getter returning the wrapped {@link java.util.Calendar}month which is
 	 * zero-indexed. Values will be between 0 to 11 (inclusive) for {@link
 	 * GregorianCalendar}s.
 	 * 
 	 * @return int zero-indexed month
 	 */
 	public int getZeroIndexedMonth()
 	{
 		return base.get(Calendar.MONTH);
 	}
 
 	/***
 	 * Create a new TimePoint using the current instance plus n days. NOTE: the
 	 * existing instance will <b>not</b> change!
 	 * 
 	 * @param arg
 	 *                    number of days to add
 	 * 
 	 * @return a brand new TimePoint
 	 */
 	public TimePoint addDays(int arg)
 	{
 		return new TimePoint(
 			new GregorianCalendar(
 				getYear(),
 				getZeroIndexedMonth(),
 				getDayOfMonth() + arg,
 				getHourOfDay(),
 				getMinute())
 				.getTime(),
 			getDatePrecision());
 	}
 
 	/***
 	 * Create a new TimePoint using the current instance plus n hours. NOTE:
 	 * the existing instance will <b>not</b> change!
 	 * 
 	 * @param arg
 	 *                    number of hours to add
 	 * 
 	 * @return a brand new TimePoint
 	 */
 	public TimePoint addHours(int arg)
 	{
 		return new TimePoint(
 			(new GregorianCalendar(getYear(),
 				getZeroIndexedMonth(),
 				getDayOfMonth(),
 				getHourOfDay() + arg,
 				getMinute()))
 				.getTime(),
 			getDatePrecision());
 	}
 
 	/***
 	 * Create a new TimePoint using the current instance plus n milliseconds.
 	 * NOTE: the existing instance will <b>not</b> change!
 	 * 
 	 * @param arg
 	 *                    number of milliseconds to add
 	 * 
 	 * @return a brand new TimePoint
 	 */
 	public TimePoint addMilliSeconds(int arg)
 	{
 		//Add milliseconds (automatic promotion to long!)
 		long currentTimePlusDelta = base.getTimeInMillis() + arg;
 
 		Calendar aCalendar = Calendar.getInstance();
 
 		aCalendar.setTimeInMillis(currentTimePlusDelta);
 
 		return new TimePoint(aCalendar.getTime(), getDatePrecision());
 	}
 
 	/***
 	 * Create a new TimePoint using the current instance plus n minutes. NOTE:
 	 * the existing instance will <b>not</b> change!
 	 * 
 	 * @param arg
 	 *                    number of minutes to add
 	 * 
 	 * @return a brand new TimePoint
 	 */
 	public TimePoint addMinutes(int arg)
 	{
 		return new TimePoint(
 			new GregorianCalendar(
 				getYear(),
 				getZeroIndexedMonth(),
 				getDayOfMonth(),
 				getHourOfDay(),
 				getMinute() + arg)
 				.getTime(),
 			getDatePrecision());
 	}
 
 	/***
 	 * Create a new TimePoint using the current instance plus n months. NOTE:
 	 * the existing instance will <b>not</b> change!
 	 * 
 	 * @param arg
 	 *                    number of months to add
 	 * 
 	 * @return a brand new TimePoint
 	 */
 	public TimePoint addMonths(int arg)
 	{
 		return new TimePoint(
 			new GregorianCalendar(
 				getYear(),
 				getZeroIndexedMonth() + arg,
 				getDayOfMonth(),
 				getHourOfDay(),
 				getMinute())
 				.getTime(),
 			getDatePrecision());
 	}
 
 	/***
 	 * Create a new TimePoint using the current instance plus n seconds. NOTE:
 	 * the existing instance will <b>not</b> change!
 	 * 
 	 * @param arg
 	 *                    number of seconds to add
 	 * 
 	 * @return a brand new TimePoint
 	 */
 	public TimePoint addSeconds(int arg)
 	{
 		return new TimePoint(
 			new GregorianCalendar(
 				getYear(),
 				getZeroIndexedMonth(),
 				getDayOfMonth(),
 				getHourOfDay(),
 				getMinute(),
 				getSeconds() + arg)
 				.getTime(),
 			getDatePrecision());
 	}
 
 	/***
 	 * Create a new TimePoint using the current instance plus n years. NOTE:
 	 * the existing instance will <b>not</b> change!
 	 * 
 	 * @param arg
 	 *                    number of years to add
 	 * 
 	 * @return a brand new TimePoint
 	 */
 	public TimePoint addYears(int arg)
 	{
 		return new TimePoint(
 			new GregorianCalendar(
 				getYear() + arg,
 				getZeroIndexedMonth(),
 				getDayOfMonth(),
 				getHourOfDay(),
 				getMinute())
 				.getTime(),
 			getDatePrecision());
 	}
 
 	/***
 	 * Method to see whether this TimePoint instance occurs after another
 	 * TimePoint instance.
 	 * 
 	 * @param arg
 	 *                    the TimePoint to check
 	 * 
 	 * @return true if this TimePoint occurs after the one provided false if
 	 *               this TimePoint occurs before the one provided
 	 * 
 	 * @throws NullPointerException
 	 *                    if argument is null
 	 */
 	public boolean after(TimePoint arg)
 	{
 		if (arg == null)
 		{
 			throw new NullPointerException("TimePoint argument cannot be null.");
 		}
 
 		return getTime().after(arg.getTime());
 	}
 
 	/***
 	 * Method to see whether this TimePoint instance occurs before another
 	 * TimePoint instance.
 	 * 
 	 * @param arg
 	 *                    the TimePoint to check
 	 * 
 	 * @return true if this TimePoint occurs before the one provided false if
 	 *               this TimePoint occurs after the one provided
 	 * 
 	 * @throws NullPointerException
 	 *                    if argument is null
 	 */
 	public boolean before(TimePoint arg)
 	{
 		if (arg == null)
 		{
 			throw new NullPointerException("TimePoint argument cannot be null.");
 		}
 
 		return getTime().before(arg.getTime());
 	}
 
 	/***
 	 * Compare wrapped <code>GregorianCalendar</code>s.
 	 * 
 	 * @param arg
 	 *                    Object to compare
 	 * 
 	 * @return <ul>
 	 *               <li>-1 if this TimePoint occurs after the one provided</li>
 	 *               <li>0 if this TimePoint occurs at the same time as the one
 	 *               provided</li>
 	 *               <li>1 if this TimePoint occurs before the one provided</li>
 	 *               </ul>
 	 * 
 	 * @see {@link Comparable#compareTo(java.lang.Object)}
 	 */
 	public int compareTo(Object arg)
 	{
 		TimePoint other = (TimePoint) arg;
 
 		return getTime().compareTo(other.getTime());
 	}
 
 	/***
 	 * Compare wrapped <code>GregorianCalendar</code> s for equality
 	 * 
 	 * @param arg
 	 *                    Object to check
 	 * 
 	 * @return true if underlying GregorianCalendar instances are equal
 	 * 
 	 * @see {@link Object#equals(java.lang.Object)}
 	 */
 	public boolean equals(Object arg)
 	{
 		if (this == arg)
 		{
 			return true;
 		}
 
 		if (!(arg instanceof TimePoint))
 		{
 			return false;
 		}
 
 		TimePoint other = (TimePoint) arg;
 
 		return (base.equals(other.getCalendar()));
 	}
 
 	/*
 	 * @see java.lang.Object#hashCode()
 	 */
 	public int hashCode()
 	{
 		return base.hashCode();
 	}
 
 	/***
 	 * Increment this <code>TimePoint</code> using the current internal
 	 * {@link DatePrecision}by the number of units specified. This is
 	 * semantically, equivalent to calling {@link Calendar#add(int, int)}with
 	 * the first argument being the current TimePoint's DatePrecsion and the
 	 * second argument being the supplied positive or negative integer amount.
 	 * 
 	 * @param amount
 	 *                    int number of units to increment by.
 	 * 
 	 * @return TimePoint a brand new TimePoint
 	 */
 	public TimePoint increment(int amount)
 	{
 		return getDatePrecision().increment(this, amount);
 	}
 
 	/***
 	 * Create a <i>new</i> TimePoint using this <code>TimePoint</code>
 	 * current value set to the supplied {@link DatePrecision}.
 	 * 
 	 * @param precision
 	 *                    DatePrecision to use when creating the new TimePoint
 	 * 
 	 * @return TimePoint a brand new TimePoint
 	 */
 	public TimePoint toPrecison(DatePrecision precision)
 	{
 		return new TimePoint(base, precision);
 	}
 
 	/***
 	 * Create a new TimePoint using the current instance minus n days. NOTE:
 	 * the existing instance will <b>not</b> change!
 	 * 
 	 * @param arg
 	 *                    number of days to subtract
 	 * 
 	 * @return a brand new TimePoint
 	 */
 	public TimePoint minusDays(int arg)
 	{
 		return addDays(-arg);
 	}
 
 	/*
 	 * @see java.lang.Object#toString()
 	 */
 	public String toString()
 	{
 		return sdf.format(base.getTime());
 	}
 
 	private void clearAndRecompute(Calendar aCalendar, int field)
 	{
 		//Clear first!
 		aCalendar.clear(field);
 
 		//Side effect - force internal recompute :(
 		aCalendar.get(field);
 
 		//Normalize
 		aCalendar.set(field, aCalendar.getActualMinimum(field));
 	}
 
 	private void initializeToPrecision(
 		GregorianCalendar arg,
 		DatePrecision precision)
 	{
 		if (arg == null)
 		{
 			throw new NullPointerException("Calendar argument cannot be null.");
 		}
 
 		if (precision == null)
 		{
 			throw new NullPointerException("DatePrecision argument cannot be null.");
 		}
 
 		datePrecision = precision;
 
 		//Lenient?
 		arg.setLenient(false);
 
 		//It's either this or a switch...I prefer this :)
 		if (DatePrecision.MILLISECOND.equals(precision))
 		{
 			//No trim necessary
 			base = arg;
 		} else if (DatePrecision.SECOND.equals(precision))
 		{
 			base = trimToSeconds(arg);
 		} else if (DatePrecision.MINUTE.equals(precision))
 		{
 			base = trimToMinutes(arg);
 		} else if (DatePrecision.HOUR_OF_DAY.equals(precision))
 		{
 			base = trimToHours(arg);
 		} else if (DatePrecision.DATE.equals(precision))
 		{
 			base = trimToDays(arg);
 		} else if (DatePrecision.MONTH.equals(precision))
 		{
 			base = trimToMonths(arg);
 		} else if (DatePrecision.YEAR.equals(precision))
 		{
 			base = trimToYear(arg);
 		} else
 		{
 			throw new UnsupportedOperationException("Unknown precision.");
 		}
 	}
 
 	private GregorianCalendar trimToDays(GregorianCalendar arg)
 	{
 		GregorianCalendar result = arg;
 
 		trimToHours(result);
 
 		clearAndRecompute(result, Calendar.HOUR_OF_DAY);
 
 		return result;
 	}
 
 	private GregorianCalendar trimToHours(GregorianCalendar arg)
 	{
 		GregorianCalendar result = arg;
 		trimToMinutes(result);
 		clearAndRecompute(result, Calendar.MINUTE);
 
 		return result;
 	}
 
 	private GregorianCalendar trimToMinutes(GregorianCalendar arg)
 	{
 		GregorianCalendar result = arg;
 		clearAndRecompute(result, Calendar.SECOND);
 		clearAndRecompute(result, Calendar.MILLISECOND);
 
 		return result;
 	}
 
 	private GregorianCalendar trimToMonths(GregorianCalendar arg)
 	{
 		GregorianCalendar result = arg;
 		trimToDays(result);
 		clearAndRecompute(result, Calendar.DAY_OF_MONTH);
 
 		return result;
 	}
 
 	private GregorianCalendar trimToSeconds(GregorianCalendar arg)
 	{
 		GregorianCalendar result = arg;
 		clearAndRecompute(result, Calendar.MILLISECOND);
 
 		return result;
 	}
 
 	private GregorianCalendar trimToYear(GregorianCalendar arg)
 	{
 		GregorianCalendar result = arg;
 		trimToMonths(result);
 		clearAndRecompute(result, Calendar.MONTH);
 
 		return result;
 	}
 
 	private void validate(int value, DatePrecision precision)
 	{
 		if (DatePrecision.MILLISECOND.equals(precision)
 			&& ((value < 0) || (value > 1000)))
 		{
 			throw new IllegalArgumentException("Invalid second: " + value);
 		} else if (
 			DatePrecision.SECOND.equals(precision)
 				&& ((value < 0) || (value > 60)))
 		{
 			throw new IllegalArgumentException("Invalid second: " + value);
 		} else if (
 			DatePrecision.MINUTE.equals(precision)
 				&& ((value < 0) || (value > 60)))
 		{
 			throw new IllegalArgumentException("Invalid minute: " + value);
 		} else if (
 			DatePrecision.HOUR_OF_DAY.equals(precision)
 				&& ((value < 0) || (value > 24)))
 		{
 			throw new IllegalArgumentException("Invalid hour: " + value);
 		} else if (
 			DatePrecision.DATE.equals(precision)
 				&& ((value < 1) || (value > 31)))
 		{
 			throw new IllegalArgumentException("Invalid date: " + value);
 		} else if (
 			DatePrecision.MONTH.equals(precision)
 				&& ((value < 1) || (value > 12)))
 		{
 			throw new IllegalArgumentException("Invalid month: " + value);
 		} else if (DatePrecision.YEAR.equals(precision))
 		{
 			//Do nothing until I remember where to find min & max for
 			// Calendars
 			//throw new IllegalArgumentException("Invalid year: " + value);
 		}
 	}
 }