Caldavsync Sources / file revision

 /**

  * Copyright (c) 2012, Ben Fortuna

  * All rights reserved.

  *

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions

  * are met:

  *

  *  o Redistributions of source code must retain the above copyright

  * notice, this list of conditions and the following disclaimer.

  *

  *  o 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.

  *

  *  o Neither the name of Ben Fortuna nor the names of any other contributors

  * may be used to endorse or promote products derived from this software

  * without specific prior written permission.

  *

  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

  * "AS IS" AND ANY EXPRESS 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 COPYRIGHT OWNER OR

  * 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.

  */

 package net.fortuna.ical4j.model;

 import java.io.IOException;

 import java.io.Serializable;

 import java.util.Calendar;

 import java.util.Date;

 import java.util.StringTokenizer;

 import net.fortuna.ical4j.util.Dates;

 import org.apache.commons.lang.builder.HashCodeBuilder;

 /**

  * $Id$

  *

  * Created on 20/06/2005

  *

  * Represents a duration of time in iCalendar. Note that according to RFC2445 durations represented in weeks are

  * mutually exclusive of other duration fields.

  * 

  * <pre>

  *  4.3.6   Duration

  *  

  *     Value Name: DURATION

  *  

  *     Purpose: This value type is used to identify properties that contain

  *     a duration of time.

  *  

  *     Formal Definition: The value type is defined by the following

  *     notation:

  *  

  *       dur-value  = (["+"] / "-") "P" (dur-date / dur-time / dur-week)

  *  

  *       dur-date   = dur-day [dur-time]

  *       dur-time   = "T" (dur-hour / dur-minute / dur-second)

  *       dur-week   = 1*DIGIT "W"

  *       dur-hour   = 1*DIGIT "H" [dur-minute]

  *       dur-minute = 1*DIGIT "M" [dur-second]

  *       dur-second = 1*DIGIT "S"

  *       dur-day    = 1*DIGIT "D"

  * </pre>

  * 

  * @author Ben Fortuna

  */

 public class Dur implements Comparable, Serializable {

     private static final long serialVersionUID = 5013232281547134583L;

     private static final int DAYS_PER_WEEK = 7;

     private static final int SECONDS_PER_MINUTE = 60;

     private static final int MINUTES_PER_HOUR = 60;

     private static final int HOURS_PER_DAY = 24;

     private static final int DAYS_PER_YEAR = 365;

     private boolean negative;

     private int weeks;

     private int days;

     private int hours;

     private int minutes;

     private int seconds;

     /**

      * Constructs a new duration instance from a string representation.

      * @param value a string representation of a duration

      */

     public Dur(final String value) {

         negative = false;

         weeks = 0;

         days = 0;

         hours = 0;

         minutes = 0;

         seconds = 0;

         String token = null;

         String prevToken = null;

         final StringTokenizer t = new StringTokenizer(value, "+-PWDTHMS", true);

         while (t.hasMoreTokens()) {

             prevToken = token;

             token = t.nextToken();

             if ("+".equals(token)) {

                 negative = false;

             }

             else if ("-".equals(token)) {

                 negative = true;

             }

             else if ("P".equals(token)) {

                 // does nothing..

             }

             else if ("W".equals(token)) {

                 weeks = Integer.parseInt(prevToken);

             }

             else if ("D".equals(token)) {

                 days = Integer.parseInt(prevToken);

             }

             else if ("T".equals(token)) {

                 // does nothing..

             }

             else if ("H".equals(token)) {

                 hours = Integer.parseInt(prevToken);

             }

             else if ("M".equals(token)) {

                 minutes = Integer.parseInt(prevToken);

             }

             else if ("S".equals(token)) {

                 seconds = Integer.parseInt(prevToken);

             }

         }

     }

     /**

      * Constructs a new duration from the specified weeks.

      * @param weeks a duration in weeks.

      */

     public Dur(final int weeks) {

         this.weeks = Math.abs(weeks);

         this.days = 0;

         this.hours = 0;

         this.minutes = 0;

         this.seconds = 0;

         this.negative = weeks < 0;

     }

     /**

      * Constructs a new duration from the specified arguments.

      * @param days duration in days

      * @param hours duration in hours

      * @param minutes duration in minutes

      * @param seconds duration in seconds

      */

     public Dur(final int days, final int hours, final int minutes,

             final int seconds) {

         if (!(days >= 0 && hours >= 0 && minutes >= 0 && seconds >= 0)

                 && !(days <= 0 && hours <= 0 && minutes <= 0 && seconds <= 0)) {

             throw new IllegalArgumentException("Invalid duration representation");

         }

         this.weeks = 0;

         this.days = Math.abs(days);

         this.hours = Math.abs(hours);

         this.minutes = Math.abs(minutes);

         this.seconds = Math.abs(seconds);

         this.negative = days < 0 || hours < 0 || minutes < 0 || seconds < 0;

     }

     /**

      * Constructs a new duration representing the time between the two specified dates. The end date may precede the

      * start date in order to represent a negative duration.

      * @param date1 the first date of the duration

      * @param date2 the second date of the duration

      */

     public Dur(final Date date1, final Date date2) {

         Date start = null;

         Date end = null;

         // Negative range? (start occurs after end)

         negative = date1.compareTo(date2) > 0;

         if (negative) {

             // Swap the dates (which eliminates the need to bother with

             // negative after this!)

             start = date2;

             end = date1;

         }

         else {

             start = date1;

             end = date2;

         }

         final Calendar startCal;

         if (start instanceof net.fortuna.ical4j.model.Date) {

             startCal = Dates.getCalendarInstance((net.fortuna.ical4j.model.Date)start);

         } else {

             startCal = Calendar.getInstance();

         }

         startCal.setTime(start);

         final Calendar endCal = Calendar.getInstance(startCal.getTimeZone());

         endCal.setTime(end);

         // Init our duration interval (which is in units that evolve as we

         // compute, below)

         int dur = 0;

         // Count days to get to the right year (loop in the very rare chance

         // that a leap year causes us to come up short)

         int nYears = endCal.get(Calendar.YEAR) - startCal.get(Calendar.YEAR);

         while (nYears > 0) {

             startCal.add(Calendar.DATE, DAYS_PER_YEAR * nYears);

             dur += DAYS_PER_YEAR * nYears;

             nYears = endCal.get(Calendar.YEAR) - startCal.get(Calendar.YEAR);

         }

         // Count days to get to the right day

         dur += endCal.get(Calendar.DAY_OF_YEAR)

                 - startCal.get(Calendar.DAY_OF_YEAR);

         // Count hours to get to right hour

         dur *= HOURS_PER_DAY; // days -> hours

         dur += endCal.get(Calendar.HOUR_OF_DAY)

                 - startCal.get(Calendar.HOUR_OF_DAY);

         // ... to the right minute

         dur *= MINUTES_PER_HOUR; // hours -> minutes

         dur += endCal.get(Calendar.MINUTE) - startCal.get(Calendar.MINUTE);

         // ... and second

         dur *= SECONDS_PER_MINUTE; // minutes -> seconds

         dur += endCal.get(Calendar.SECOND) - startCal.get(Calendar.SECOND);

         // Now unwind our units

         seconds = dur % SECONDS_PER_MINUTE;

         dur = dur / SECONDS_PER_MINUTE; // seconds -> minutes (drop remainder seconds)

         minutes = dur % MINUTES_PER_HOUR;

         dur /= MINUTES_PER_HOUR; // minutes -> hours (drop remainder minutes)

         hours = dur % HOURS_PER_DAY;

         dur /= HOURS_PER_DAY; // hours -> days (drop remainder hours)

         days = dur;

         weeks = 0;

         // Special case for week-only representation

         if (seconds == 0 && minutes == 0 && hours == 0

                 && (days % DAYS_PER_WEEK) == 0) {

             weeks = days / DAYS_PER_WEEK;

             days = 0;

         }

     }

     /**

      * Returns a date representing the end of this duration from the specified start date.

      * @param start the date to start the duration

      * @return the end of the duration as a date

      */

     public final Date getTime(final Date start) {

         final Calendar cal;

         if (start instanceof net.fortuna.ical4j.model.Date) {

             cal = Dates.getCalendarInstance((net.fortuna.ical4j.model.Date)start);

         } else {

             cal = Calendar.getInstance();

         }

         cal.setTime(start);

         if (isNegative()) {

             cal.add(Calendar.WEEK_OF_YEAR, -weeks);

             cal.add(Calendar.DAY_OF_WEEK, -days);

             cal.add(Calendar.HOUR_OF_DAY, -hours);

             cal.add(Calendar.MINUTE, -minutes);

             cal.add(Calendar.SECOND, -seconds);

         }

         else {

             cal.add(Calendar.WEEK_OF_YEAR, weeks);

             cal.add(Calendar.DAY_OF_WEEK, days);

             cal.add(Calendar.HOUR_OF_DAY, hours);

             cal.add(Calendar.MINUTE, minutes);

             cal.add(Calendar.SECOND, seconds);

         }

         return cal.getTime();

     }

     /**

      * Provides a negation of this instance.

      * @return a Dur instance that represents a negation of this instance

      */

     public final Dur negate() {

         final Dur negated = new Dur(days, hours, minutes, seconds);

         negated.weeks = weeks;

         negated.negative = !negative;

         return negated;

     }

     /**

      * Add two durations. Durations may only be added if they are both positive

      * or both negative durations.

      * @param duration the duration to add to this duration

      * @return a new instance representing the sum of the two durations.

      */

     public final Dur add(final Dur duration) {

         if ((!isNegative() && duration.isNegative())

                 || (isNegative() && !duration.isNegative())) {

             throw new IllegalArgumentException(

                     "Cannot add a negative and a positive duration");

         }

         Dur sum = null;

         if (weeks > 0 && duration.weeks > 0) {

             sum = new Dur(weeks + duration.weeks);

         }

         else {

             int daySum = (weeks > 0) ? weeks * DAYS_PER_WEEK + days : days;

             int hourSum = hours;

             int minuteSum = minutes;

             int secondSum = seconds;

             if ((secondSum + duration.seconds) / SECONDS_PER_MINUTE > 0) {

                 minuteSum += (secondSum + duration.seconds) / SECONDS_PER_MINUTE;

                 secondSum = (secondSum + duration.seconds) % SECONDS_PER_MINUTE;

             }

             else {

                 secondSum += duration.seconds;

             }

             if ((minuteSum + duration.minutes) / MINUTES_PER_HOUR > 0) {

                 hourSum += (minuteSum + duration.minutes) / MINUTES_PER_HOUR;

                 minuteSum = (minuteSum + duration.minutes) % MINUTES_PER_HOUR;

             }

             else {

                 minuteSum += duration.minutes;

             }

             if ((hourSum + duration.hours) / HOURS_PER_DAY > 0) {

                 daySum += (hourSum + duration.hours) / HOURS_PER_DAY;

                 hourSum = (hourSum + duration.hours) % HOURS_PER_DAY;

             }

             else {

                 hourSum += duration.hours;

             }

             daySum += (duration.weeks > 0) ? duration.weeks * DAYS_PER_WEEK

                     + duration.days : duration.days;

             sum = new Dur(daySum, hourSum, minuteSum, secondSum);

         }

         sum.negative = negative;

         return sum;

     }

     /**

      * {@inheritDoc}

      */

     public final String toString() {

         final StringBuffer b = new StringBuffer();

         if (negative) {

             b.append('-');

         }

         b.append('P');

         if (weeks > 0) {

             b.append(weeks);

             b.append('W');

         }

         else {

             if (days > 0) {

                 b.append(days);

                 b.append('D');

             }

             if (hours > 0 || minutes > 0 || seconds > 0) {

                 b.append('T');

                 if (hours > 0) {

                     b.append(hours);

                     b.append('H');

                 }

                 if (minutes > 0) {

                     b.append(minutes);

                     b.append('M');

                 }

                 if (seconds > 0) {

                     b.append(seconds);

                     b.append('S');

                 }

             }

             // handle case of zero length duration

             if ((hours + minutes + seconds + days + weeks) == 0) {

                 b.append("T0S");

             }

         }

         return b.toString();

     }

     /**

      * {@inheritDoc}

      */

     public final int compareTo(final Object arg0) {

         return compareTo((Dur) arg0);

     }

     /**

      * Compares this duration with another, acording to their length.

      * @param arg0 another duration instance

      * @return a postive value if this duration is longer, zero if the duration

      * lengths are equal, otherwise a negative value

      */

     public final int compareTo(final Dur arg0) {

         int result;

         if (isNegative() != arg0.isNegative()) {

             // return Boolean.valueOf(isNegative()).compareTo(Boolean.valueOf(arg0.isNegative()));

             // for pre-java 1.5 compatibility..

             if (isNegative()) {

                 return Integer.MIN_VALUE;

             }

             else {

                 return Integer.MAX_VALUE;

             }

         }

         else if (getWeeks() != arg0.getWeeks()) {

             result = getWeeks() - arg0.getWeeks();

         }

         else if (getDays() != arg0.getDays()) {

             result = getDays() - arg0.getDays();

         }

         else if (getHours() != arg0.getHours()) {

             result = getHours() - arg0.getHours();

         }

         else if (getMinutes() != arg0.getMinutes()) {

             result = getMinutes() - arg0.getMinutes();

         }

         else {

             result = getSeconds() - arg0.getSeconds();

         }

         // invert sense of all tests if both durations are negative

         if (isNegative()) {

             return -result;

         }

         else {

             return result;

         }

     }

     /**

      * {@inheritDoc}

      */

     public boolean equals(final Object obj) {

         if (obj instanceof Dur) {

             return ((Dur) obj).compareTo(this) == 0;

         }

         return super.equals(obj);

     }

     /**

      * {@inheritDoc}

      */

     public int hashCode() {

         return new HashCodeBuilder().append(weeks).append(days).append(

                 hours).append(minutes).append(seconds).append(negative).toHashCode();

     }

     /**

      * @return Returns the days.

      */

     public final int getDays() {

         return days;

     }

     /**

      * @return Returns the hours.

      */

     public final int getHours() {

         return hours;

     }

     /**

      * @return Returns the minutes.

      */

     public final int getMinutes() {

         return minutes;

     }

     /**

      * @return Returns the negative.

      */

     public final boolean isNegative() {

         return negative;

     }

     /**

      * @return Returns the seconds.

      */

     public final int getSeconds() {

         return seconds;

     }

     /**

      * @return Returns the weeks.

      */

     public final int getWeeks() {

         return weeks;

     }

     /**

      * @param stream

      * @throws IOException

      * @throws ClassNotFoundException

      */

     private void readObject(final java.io.ObjectInputStream stream) throws IOException, ClassNotFoundException {

         stream.defaultReadObject();

     }

 }