Java tutorial
/* * The MIT License * Copyright (c) 2012 Microsoft Corporation * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ package microsoft.exchange.webservices.data.misc; import microsoft.exchange.webservices.data.core.exception.misc.FormatException; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * The Class TimeSpan. */ public class TimeSpan implements Comparable<TimeSpan>, java.io.Serializable, Cloneable { private static final Log LOG = LogFactory.getLog(TimeSpan.class); /** * Constant serialized ID used for compatibility. */ private static final long serialVersionUID = 1L; /** * The time. */ private long time = 0; /** * Constant for milliseconds unit and conversion. */ public static final int MILLISECONDS = 1; /** * Constant for seconds unit and conversion. */ public static final int SECONDS = MILLISECONDS * 1000; /** * Constant for minutes unit and conversion. */ public static final int MINUTES = SECONDS * 60; /** * Constant for hours unit and conversion. */ public static final int HOURS = MINUTES * 60; /** * Constant for days unit and conversion. */ public static final int DAYS = HOURS * 24; /** * Represents the Maximum TimeSpan value. */ public static final TimeSpan MAX_VALUE = new TimeSpan(Long.MAX_VALUE); /** * Represents the Minimum TimeSpan value. */ public static final TimeSpan MIN_VALUE = new TimeSpan(Long.MIN_VALUE); /** * Represents the TimeSpan with a value of zero. */ public static final TimeSpan ZERO = new TimeSpan(0L); /** * Creates a new instance of TimeSpan based on the number of milliseconds * entered. * * @param time the number of milliseconds for this TimeSpan. */ public TimeSpan(long time) { this.time = time; } /** * Creates a new TimeSpan object based on the unit and value entered. * * @param units the type of unit to use to create a TimeSpan instance. * @param value the number of units to use to create a TimeSpan instance. */ public TimeSpan(int units, long value) { this.time = TimeSpan.toMilliseconds(units, value); } /* * public static TimeSpan fromMinutes(int value) { int l = value*60*100; * return l; } */ /** * Subtracts two Date objects creating a new TimeSpan object. * * @param date1 Date to use as the base value. * @param date2 Date to subtract from the base value. * @return a TimeSpan object representing the difference bewteen the two * Date objects. */ public static TimeSpan subtract(java.util.Date date1, java.util.Date date2) { return new TimeSpan(date1.getTime() - date2.getTime()); } /** * Compares this object with the specified object for order. Returns a * negative integer, zero, or a positive integer as this object is less * than, equal to, or greater than the specified object. Comparison is based * on the number of milliseconds in this TimeSpan. * * @param o the Object to be compared. * @return a negative integer, zero, or a positive integer as this object is * less than, equal to, or greater than the specified object. */ public int compareTo(TimeSpan o) { TimeSpan compare = (TimeSpan) o; if (this.time == compare.time) { return 0; } if (this.time > compare.time) { return +1; } return -1; } /** * Indicates whether some other object is "equal to" this one. Comparison is * based on the number of milliseconds in this TimeSpan. * * @param obj the reference object with which to compare. * @return if the obj argument is a TimeSpan object with the exact same * number of milliseconds. otherwise. */ public boolean equals(Object obj) { if (obj instanceof TimeSpan) { TimeSpan compare = (TimeSpan) obj; if (this.time == compare.time) { return true; } } return false; } /** * Returns a hash code value for the object. This method is supported for * the benefit of hashtables such as those provided by * <code>java.util.Hashtable</code>. The method uses the same algorithm as * found in the Long class. * * @return a hash code value for this object. * @see Object#equals(Object) * @see java.util.Hashtable */ public int hashCode() { return Long.valueOf(this.time).hashCode(); } /** * Returns a string representation of the object in the format. * "[-]d.hh:mm:ss.ff" where "-" is an optional sign for negative TimeSpan * values, the "d" component is days, "hh" is hours, "mm" is minutes, "ss" * is seconds, and "ff" is milliseconds * * @return a string containing the number of milliseconds. */ public String toString() { StringBuffer sb = new StringBuffer(); long millis = this.time; if (millis < 0) { sb.append("-"); millis = -millis; } long day = millis / TimeSpan.DAYS; if (day != 0) { sb.append(day); sb.append("d."); millis = millis % TimeSpan.DAYS; } sb.append(millis / TimeSpan.HOURS); millis = millis % TimeSpan.HOURS; sb.append("h:"); sb.append(millis / TimeSpan.MINUTES); millis = millis % TimeSpan.MINUTES; sb.append("m:"); sb.append(millis / TimeSpan.SECONDS); sb.append("s"); millis = millis % TimeSpan.SECONDS; if (millis != 0) { sb.append("."); sb.append(millis); sb.append("ms"); } return sb.toString(); } /** * Returns a clone of this TimeSpan. * * @return a clone of this TimeSpan. */ public Object clone() { try { return super.clone(); } catch (CloneNotSupportedException e) { LOG.error(e); throw new InternalError(); } } /** * Indicates whether the value of the TimeSpan is positive. * * @return if the value of the TimeSpan is greater than * zero. otherwise. */ public boolean isPositive() { return this.compareTo(TimeSpan.ZERO) > 0 ? true : false; } /** * Indicates whether the value of the TimeSpan is negative. * * @return if the value of the TimeSpan is less than zero. * otherwise. */ public boolean isNegative() { return this.compareTo(TimeSpan.ZERO) < 0 ? true : false; } /** * Indicates whether the value of the TimeSpan is zero. * * @return if the value of the TimeSpan is equal to zero. * otherwise. */ public boolean isZero() { return this.equals(TimeSpan.ZERO); } /** * Gets the number of milliseconds. * * @return the number of milliseconds. */ public long getMilliseconds() { return (((this.time % TimeSpan.HOURS) % TimeSpan.MINUTES) % TimeSpan.MILLISECONDS) / TimeSpan.MILLISECONDS; } /** * Gets the number of milliseconds. * * @return the number of milliseconds. */ public long getTotalMilliseconds() { return this.time; } /** * Gets the number of seconds (truncated). * * @return the number of seconds. */ public long getSeconds() { return ((this.time % TimeSpan.HOURS) % TimeSpan.MINUTES) / TimeSpan.SECONDS; } /** * Gets the number of seconds including fractional seconds. * * @return the number of seconds. */ public double getTotalSeconds() { return this.time / 1000.0d; } /** * Gets the number of minutes (truncated). * * @return the number of minutes. */ public long getMinutes() { return (this.time % TimeSpan.HOURS) / TimeSpan.MINUTES;// (this.time/1000)/60; } /** * Gets the number of minutes including fractional minutes. * * @return the number of minutes. */ public double getTotalMinutes() { return (this.time / 1000.0d) / 60.0d; } /** * Gets the number of hours (truncated). * * @return the number of hours. */ public long getHours() { return ((this.time / 1000) / 60) / 60; } /** * Gets the number of hours including fractional hours. * * @return the number of hours. */ public double getTotalHours() { return ((this.time / 1000.0d) / 60.0d) / 60.0d; } /** * Gets the number of days (truncated). * * @return the number of days. */ public long getDays() { return (((this.time / 1000) / 60) / 60) / 24; } /** * Gets the number of days including fractional days. * * @return the number of days. */ public double getTotalDays() { return (((this.time / 1000.0d) / 60.0d) / 60.0d) / 24.0d; } /** * Adds a TimeSpan to this TimeSpan. * * @param timespan the TimeSpan to add to this TimeSpan. */ public void add(TimeSpan timespan) { add(TimeSpan.MILLISECONDS, timespan.time); } /** * Adds a number of units to this TimeSpan. * * @param units the type of unit to add to this TimeSpan. * @param value the number of units to add to this TimeSpan. */ public void add(int units, long value) { this.time += TimeSpan.toMilliseconds(units, value); } /** * Compares two TimeSpan objects. * * @param first first TimeSpan to use in the compare. * @param second second TimeSpan to use in the compare. * @return a negative integer, zero, or a positive integer as the first * TimeSpan is less than, equal to, or greater than the second * TimeSpan. */ public static int compare(TimeSpan first, TimeSpan second) { if (first.time == second.time) { return 0; } if (first.time > second.time) { return +1; } return -1; } /** * Returns a TimeSpan whose value is the absolute value of this TimeSpan. * * @return a TimeSpan whose value is the absolute value of this TimeSpan. */ public TimeSpan duration() { return new TimeSpan(Math.abs(this.time)); } /** * Returns a TimeSpan whose value is the negated value of this TimeSpan. * * @return a TimeSpan whose value is the negated value of this TimeSpan. */ public TimeSpan negate() { return new TimeSpan(-this.time); } /** * Subtracts a TimeSpan from this TimeSpan. * * @param timespan the TimeSpan to subtract from this TimeSpan. */ public void subtract(TimeSpan timespan) { subtract(TimeSpan.MILLISECONDS, timespan.time); } /** * Subtracts a number of units from this TimeSpan. * * @param units the type of unit to subtract from this TimeSpan. * @param value the number of units to subtract from this TimeSpan. */ public void subtract(int units, long value) { add(units, -value); } /** * To milliseconds. * * @param units the units * @param value the value * @return the long */ private static long toMilliseconds(int units, long value) { long millis; switch (units) { case TimeSpan.MILLISECONDS: case TimeSpan.SECONDS: case TimeSpan.MINUTES: case TimeSpan.HOURS: case TimeSpan.DAYS: millis = value * units; break; default: throw new IllegalArgumentException("Unrecognized units: " + units); } return millis; } public static TimeSpan parse(String s) throws Exception { String str = s.trim(); String[] st1 = str.split("\\."); int days = 0, millsec = 0, totMillSec = 0; String data = str; switch (st1.length) { case 1: data = str; break; case 2: if (st1[0].split(":").length > 1) { millsec = Integer.parseInt(st1[1]); data = st1[0]; } else { days = Integer.parseInt(st1[0]); data = st1[1]; } break; case 3: days = Integer.parseInt(st1[0]); data = st1[1]; millsec = Integer.parseInt(st1[2]); break; default: throw new FormatException("Bad Format"); } String[] st = data.split(":"); switch (st.length) { case 1: totMillSec = Integer.parseInt(str) * 24 * 60 * 60 * 1000; break; case 2: totMillSec = (Integer.parseInt(st[0]) * 60 * 60 * 1000) + (Integer.parseInt(st[1]) * 60 * 1000); break; case 3: totMillSec = (Integer.parseInt(st[0]) * 60 * 60 * 1000) + (Integer.parseInt(st[1]) * 60 * 1000) + (Integer.parseInt(st[2]) * 1000); break; case 4: totMillSec = (Integer.parseInt(st[0]) * 24 * 60 * 60 * 1000) + (Integer.parseInt(st[1]) * 60 * 60 * 1000) + (Integer.parseInt(st[2]) * 60 * 1000) + (Integer.parseInt(st[3]) * 1000); break; default: throw new FormatException("Bad Format/Overflow"); } totMillSec += (days * 24 * 60 * 60 * 1000) + millsec; return new TimeSpan(totMillSec); } }