Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *  Copyright 2001-2011 Stephen Colebourne
   *
   *  Licensed under the Apache License, Version 2.0 (the "License");
   *  you may not use this file except in compliance with the License.
   *  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 package org.joda.time.base;
 
AbstractInterval provides the common behaviour for time intervals.

This class should generally not be used directly by API users. The org.joda.time.ReadableInterval interface should be used when different kinds of intervals are to be referenced.

AbstractInterval subclasses may be mutable and not thread-safe.

Author(s):
Brian S O'Neill
Stephen Colebourne
Since:
1.0
 
 public abstract class AbstractInterval implements ReadableInterval {

    
Constructor.
 
     protected AbstractInterval() {
         super();
     }
 
     //-----------------------------------------------------------------------
     
Validates an interval.

Parameters:
start the start instant in milliseconds
end the end instant in milliseconds
Throws:
java.lang.IllegalArgumentException if the interval is invalid
 
     protected void checkInterval(long startlong end) {
         if (end < start) {
             throw new IllegalArgumentException("The end instant must be greater or equal to the start");
         }
     }
 
     //-----------------------------------------------------------------------
     
Gets the start of this time interval, which is inclusive, as a DateTime.

Returns:
the start of the time interval
 
     public DateTime getStart() {
         return new DateTime(getStartMillis(), getChronology());
     }

    
Gets the end of this time interval, which is exclusive, as a DateTime.

Returns:
the end of the time interval
 
     public DateTime getEnd() {
         return new DateTime(getEndMillis(), getChronology());
     }
 
     //-----------------------------------------------------------------------
     
Does this time interval contain the specified millisecond instant.

Non-zero duration intervals are inclusive of the start instant and exclusive of the end. A zero duration interval cannot contain anything.

Parameters:
millisInstant the instant to compare to, millisecond instant from 1970-01-01T00:00:00Z
Returns:
true if this time interval contains the millisecond
 
     public boolean contains(long millisInstant) {
         long thisStart = getStartMillis();
         long thisEnd = getEndMillis();
        return (millisInstant >= thisStart && millisInstant < thisEnd);
    }

    
Does this time interval contain the current instant.

Non-zero duration intervals are inclusive of the start instant and exclusive of the end. A zero duration interval cannot contain anything.

Returns:
true if this time interval contains the current instant
    public boolean containsNow() {
        return contains(DateTimeUtils.currentTimeMillis());
    }

    
Does this time interval contain the specified instant.

Non-zero duration intervals are inclusive of the start instant and exclusive of the end. A zero duration interval cannot contain anything.

For example:

 [09:00 to 10:00) contains 08:59  = false (before start)
 [09:00 to 10:00) contains 09:00  = true
 [09:00 to 10:00) contains 09:59  = true
 [09:00 to 10:00) contains 10:00  = false (equals end)
 [09:00 to 10:00) contains 10:01  = false (after end)
 
 [14:00 to 14:00) contains 14:00  = false (zero duration contains nothing)
 
Passing in a null parameter will have the same effect as calling containsNow().

Parameters:
instant the instant, null means now
Returns:
true if this time interval contains the instant
    public boolean contains(ReadableInstant instant) {
        if (instant == null) {
            return containsNow();
        }
        return contains(instant.getMillis());
    }

    
Does this time interval contain the specified time interval.

Non-zero duration intervals are inclusive of the start instant and exclusive of the end. The other interval is contained if this interval wholly contains, starts, finishes or equals it. A zero duration interval cannot contain anything.

When two intervals are compared the result is one of three states: (a) they abut, (b) there is a gap between them, (c) they overlap. The contains method is not related to these states. In particular, a zero duration interval is contained at the start of a larger interval, but does not overlap (it abuts instead).

For example:

 [09:00 to 10:00) contains [09:00 to 10:00)  = true
 [09:00 to 10:00) contains [09:00 to 09:30)  = true
 [09:00 to 10:00) contains [09:30 to 10:00)  = true
 [09:00 to 10:00) contains [09:15 to 09:45)  = true
 [09:00 to 10:00) contains [09:00 to 09:00)  = true
 
 [09:00 to 10:00) contains [08:59 to 10:00)  = false (otherStart before thisStart)
 [09:00 to 10:00) contains [09:00 to 10:01)  = false (otherEnd after thisEnd)
 [09:00 to 10:00) contains [10:00 to 10:00)  = false (otherStart equals thisEnd)
 
 [14:00 to 14:00) contains [14:00 to 14:00)  = false (zero duration contains nothing)
 
Passing in a null parameter will have the same effect as calling containsNow().

Parameters:
interval the time interval to compare to, null means a zero duration interval now
Returns:
true if this time interval contains the time interval
    public boolean contains(ReadableInterval interval) {
        if (interval == null) {
            return containsNow();
        }
        long otherStart = interval.getStartMillis();
        long otherEnd = interval.getEndMillis();
        long thisStart = getStartMillis();
        long thisEnd = getEndMillis();
        return (thisStart <= otherStart && otherStart < thisEnd && otherEnd <= thisEnd);
    }

    
Does this time interval overlap the specified time interval.

Intervals are inclusive of the start instant and exclusive of the end. An interval overlaps another if it shares some common part of the datetime continuum.

When two intervals are compared the result is one of three states: (a) they abut, (b) there is a gap between them, (c) they overlap. The abuts state takes precedence over the other two, thus a zero duration interval at the start of a larger interval abuts and does not overlap.

For example:

 [09:00 to 10:00) overlaps [08:00 to 08:30)  = false (completely before)
 [09:00 to 10:00) overlaps [08:00 to 09:00)  = false (abuts before)
 [09:00 to 10:00) overlaps [08:00 to 09:30)  = true
 [09:00 to 10:00) overlaps [08:00 to 10:00)  = true
 [09:00 to 10:00) overlaps [08:00 to 11:00)  = true
 
 [09:00 to 10:00) overlaps [09:00 to 09:00)  = false (abuts before)
 [09:00 to 10:00) overlaps [09:00 to 09:30)  = true
 [09:00 to 10:00) overlaps [09:00 to 10:00)  = true
 [09:00 to 10:00) overlaps [09:00 to 11:00)  = true
 
 [09:00 to 10:00) overlaps [09:30 to 09:30)  = true
 [09:00 to 10:00) overlaps [09:30 to 10:00)  = true
 [09:00 to 10:00) overlaps [09:30 to 11:00)  = true
 
 [09:00 to 10:00) overlaps [10:00 to 10:00)  = false (abuts after)
 [09:00 to 10:00) overlaps [10:00 to 11:00)  = false (abuts after)
 
 [09:00 to 10:00) overlaps [10:30 to 11:00)  = false (completely after)
 
 [14:00 to 14:00) overlaps [14:00 to 14:00)  = false (abuts before and after)
 [14:00 to 14:00) overlaps [13:00 to 15:00)  = true
 

Parameters:
interval the time interval to compare to, null means a zero length interval now
Returns:
true if the time intervals overlap
    public boolean overlaps(ReadableInterval interval) {
        long thisStart = getStartMillis();
        long thisEnd = getEndMillis();
        if (interval == null) {
            long now = DateTimeUtils.currentTimeMillis();
            return (thisStart < now && now < thisEnd);
        }  else {
            long otherStart = interval.getStartMillis();
            long otherEnd = interval.getEndMillis();
            return (thisStart < otherEnd && otherStart < thisEnd);
        }
    }
    //-----------------------------------------------------------------------
    
Is this interval equal to the specified interval ignoring the chronology.

This compares the underlying instants, ignoring the chronology.

Parameters:
other a readable interval to check against
Returns:
true if the intervals are equal comparing the start and end millis
Since:
2.3
    public boolean isEqual(ReadableInterval other) {
        return getStartMillis() == other.getStartMillis() &&
                getEndMillis() == other.getEndMillis();
    }

    
Is this time interval before the specified millisecond instant.

Intervals are inclusive of the start instant and exclusive of the end.

Parameters:
millisInstant the instant to compare to, millisecond instant from 1970-01-01T00:00:00Z
Returns:
true if this time interval is before the instant
    public boolean isBefore(long millisInstant) {
        return (getEndMillis() <= millisInstant);
    }

    
Is this time interval before the current instant.

Intervals are inclusive of the start instant and exclusive of the end.

Returns:
true if this time interval is before the current instant
    public boolean isBeforeNow() {
        return isBefore(DateTimeUtils.currentTimeMillis());
    }

    
Is this time interval before the specified instant.

Intervals are inclusive of the start instant and exclusive of the end.

Parameters:
instant the instant to compare to, null means now
Returns:
true if this time interval is before the instant
    public boolean isBefore(ReadableInstant instant) {
        if (instant == null) {
            return isBeforeNow();
        }
        return isBefore(instant.getMillis());
    }

    
Is this time interval entirely before the specified instant.

Intervals are inclusive of the start instant and exclusive of the end.

Parameters:
interval the interval to compare to, null means now
Returns:
true if this time interval is before the interval specified
    public boolean isBefore(ReadableInterval interval) {
        if (interval == null) {
            return isBeforeNow();
        }
        return isBefore(interval.getStartMillis());
    }
    //-----------------------------------------------------------------------
    
Is this time interval after the specified millisecond instant.

Intervals are inclusive of the start instant and exclusive of the end.

Parameters:
millisInstant the instant to compare to, millisecond instant from 1970-01-01T00:00:00Z
Returns:
true if this time interval is after the instant
    public boolean isAfter(long millisInstant) {
        return (getStartMillis() > millisInstant);
    }

    
Is this time interval after the current instant.

Intervals are inclusive of the start instant and exclusive of the end.

Returns:
true if this time interval is after the current instant
    public boolean isAfterNow() {
        return isAfter(DateTimeUtils.currentTimeMillis());
    }

    
Is this time interval after the specified instant.

Intervals are inclusive of the start instant and exclusive of the end.

Parameters:
instant the instant to compare to, null means now
Returns:
true if this time interval is after the instant
    public boolean isAfter(ReadableInstant instant) {
        if (instant == null) {
            return isAfterNow();
        }
        return isAfter(instant.getMillis());
    }

    
Is this time interval entirely after the specified interval.

Intervals are inclusive of the start instant and exclusive of the end. Only the end time of the specified interval is used in the comparison.

Parameters:
interval the interval to compare to, null means now
Returns:
true if this time interval is after the interval specified
    public boolean isAfter(ReadableInterval interval) {
        long endMillis;
        if (interval == null) {
            endMillis = DateTimeUtils.currentTimeMillis();
        } else {
            endMillis = interval.getEndMillis();
        }
        return (getStartMillis() >= endMillis);
    }
    //-----------------------------------------------------------------------
    
Get this interval as an immutable Interval object.

Returns:
the interval as an Interval object
    public Interval toInterval() {
        return new Interval(getStartMillis(), getEndMillis(), getChronology());
    }

    
Get this time interval as a MutableInterval.

This will always return a new MutableInterval with the same interval.

Returns:
the time interval as a MutableInterval object
        return new MutableInterval(getStartMillis(), getEndMillis(), getChronology());
    }
    //-----------------------------------------------------------------------
    
Gets the duration of this time interval in milliseconds.

The duration is equal to the end millis minus the start millis.

Returns:
the duration of the time interval in milliseconds
Throws:
java.lang.ArithmeticException if the duration exceeds the capacity of a long
    public long toDurationMillis() {
        return FieldUtils.safeAdd(getEndMillis(), -getStartMillis());
    }

    
Gets the duration of this time interval.

The duration is equal to the end millis minus the start millis.

Returns:
the duration of the time interval
Throws:
java.lang.ArithmeticException if the duration exceeds the capacity of a long
    public Duration toDuration() {
        long durMillis = toDurationMillis();
        if (durMillis == 0) {
            return .;
        } else {
            return new Duration(durMillis);
        }
    }
    //-----------------------------------------------------------------------
    
Converts the duration of the interval to a Period using the All period type.

This method should be used to exract the field values describing the difference between the start and end instants.

Returns:
a time period derived from the interval
    public Period toPeriod() {
        return new Period(getStartMillis(), getEndMillis(), getChronology());
    }

    
Converts the duration of the interval to a Period using the specified period type.

This method should be used to exract the field values describing the difference between the start and end instants.

Parameters:
type the requested type of the duration, null means AllType
Returns:
a time period derived from the interval
    public Period toPeriod(PeriodType type) {
        return new Period(getStartMillis(), getEndMillis(), typegetChronology());
    }
    //-----------------------------------------------------------------------
    
Compares this object with the specified object for equality based on start and end millis plus the chronology. All ReadableInterval instances are accepted.

To compare the duration of two time intervals, use toDuration() to get the durations and compare those.

Parameters:
readableInterval a readable interval to check against
Returns:
true if the intervals are equal comparing the start millis, end millis and chronology
    public boolean equals(Object readableInterval) {
        if (this == readableInterval) {
            return true;
        }
        if (readableInterval instanceof ReadableInterval == false) {
            return false;
        }
        ReadableInterval other = (ReadableIntervalreadableInterval;
        return 
            getStartMillis() == other.getStartMillis() &&
            getEndMillis() == other.getEndMillis() &&
            FieldUtils.equals(getChronology(), other.getChronology());
    }

    
Hashcode compatible with equals method.

Returns:
suitable hashcode
    public int hashCode() {
        long start = getStartMillis();
        long end = getEndMillis();
        int result = 97;
        result = 31 * result + ((int) (start ^ (start >>> 32)));
        result = 31 * result + ((int) (end ^ (end >>> 32)));
        result = 31 * result + getChronology().hashCode();
        return result;
    }

    
Output a string in ISO8601 interval format.

From version 2.1, the string includes the time zone offset.

Returns:
re-parsable string (in the default zone)
    public String toString() {
        DateTimeFormatter printer = ISODateTimeFormat.dateTime();
        printer = printer.withChronology(getChronology());
        StringBuffer buf = new StringBuffer(48);
        printer.printTo(bufgetStartMillis());
        buf.append('/');
        printer.printTo(bufgetEndMillis());
        return buf.toString();
    }
New to GrepCode? Check out our FAQ X