Java ReadableInterval.getStartMillis方法代码示例

import org.joda.time.ReadableInterval; //导入方法依赖的package包/类
/**
 * Constructs a time interval converting or copying from another object
 * that describes an interval.
 * 
 * @param interval  the time interval to copy
 * @param chrono  the chronology to use, null means let converter decide
 * @throws IllegalArgumentException if the interval is invalid
 */
protected BaseInterval(Object interval, Chronology chrono) {
    super();
    IntervalConverter converter = ConverterManager.getInstance().getIntervalConverter(interval);
    if (converter.isReadableInterval(interval, chrono)) {
        ReadableInterval input = (ReadableInterval) interval;
        iChronology = (chrono != null ? chrono : input.getChronology());
        iStartMillis = input.getStartMillis();
        iEndMillis = input.getEndMillis();
    } else if (this instanceof ReadWritableInterval) {
        converter.setInto((ReadWritableInterval) this, interval, chrono);
    } else {
        MutableInterval mi = new MutableInterval();
        converter.setInto(mi, interval, chrono);
        iChronology = mi.getChronology();
        iStartMillis = mi.getStartMillis();
        iEndMillis = mi.getEndMillis();
    }
    checkInterval(iStartMillis, iEndMillis);
}
 

import org.joda.time.ReadableInterval; //导入方法依赖的package包/类
/**
 * Does a time interval contain a specified time interval.
 * 
 * @param interval the interval to check
 * @param intervalCompareTo the interval to compare to
 * @return true if this time ' intervalCompareTo' contains 'intervalCompareTo'
 */
public static boolean contains(ReadableInterval interval, ReadableInterval intervalCompareTo) {
    if (intervalCompareTo == null) {
        return DateUtils.containsNow(intervalCompareTo);
    }
    long otherStart = intervalCompareTo.getStartMillis();
    long otherEnd = intervalCompareTo.getEndMillis();
    long thisStart = interval.getStartMillis();
    long thisEnd = interval.getEndMillis();
    return (thisStart <= otherStart && otherStart <= thisEnd && otherEnd <= thisEnd);
}
 

import org.joda.time.ReadableInterval; //导入方法依赖的package包/类
/**
 * Does a time interval intersect another time interval.
 * <p>
 * 
 * @param interval1 the interval1
 * @param interval2 the interval2
 * @return true if the time intervals intersect
 */
public static boolean intersects(ReadableInterval interval1, ReadableInterval interval2) {

    if (interval1 == null) {
        return false;
    }
    if (interval2 == null) {
        return false;
    }
    long thisStart = interval1.getStartMillis();
    long thisEnd = interval1.getEndMillis();
    long otherStart = interval2.getStartMillis();
    long otherEnd = interval2.getEndMillis();
    return (thisStart <= otherEnd && otherStart <= thisEnd);
}
 

import org.joda.time.ReadableInterval; //导入方法依赖的package包/类
/**
 * Compares this object with the specified object for equality based
 * on start and end millis plus the chronology.
 * All ReadableInterval instances are accepted.
 * <p>
 * To compare the duration of two time intervals, use {@link #toDuration()}
 * to get the durations and compare those.
 *
 * @param readableInterval  a readable interval to check against
 * @return true if the start and end millis are equal
 */
public boolean equals(Object readableInterval) {
    if (this == readableInterval) {
        return true;
    }
    if (readableInterval instanceof ReadableInterval == false) {
        return false;
    }
    ReadableInterval other = (ReadableInterval) readableInterval;
    return 
        getStartMillis() == other.getStartMillis() &&
        getEndMillis() == other.getEndMillis() &&
        FieldUtils.equals(getChronology(), other.getChronology());
}
 

import org.joda.time.ReadableInterval; //导入方法依赖的package包/类
/**
 * Sets the values of the mutable duration from the specified interval.
 * 
 * @param writablePeriod  the period to modify
 * @param object  the interval to set from
 * @param chrono  the chronology to use
 */
public void setInto(ReadWritablePeriod writablePeriod, Object object, Chronology chrono) {
    ReadableInterval interval = (ReadableInterval) object;
    chrono = (chrono != null ? chrono : DateTimeUtils.getIntervalChronology(interval));
    long start = interval.getStartMillis();
    long end = interval.getEndMillis();
    int[] values = chrono.get(writablePeriod, start, end);
    for (int i = 0; i < values.length; i++) {
        writablePeriod.setValue(i, values[i]);
    }
}
 

import org.joda.time.ReadableInterval; //导入方法依赖的package包/类
/**
 * Compares this object with the specified object for equality based
 * on start and end millis plus the chronology.
 * All ReadableInterval instances are accepted.
 * <p>
 * To compare the duration of two time intervals, use {@link #toDuration()}
 * to get the durations and compare those.
 *
 * @param readableInterval  a readable interval to check against
 * @return 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 = (ReadableInterval) readableInterval;
    return 
        getStartMillis() == other.getStartMillis() &&
        getEndMillis() == other.getEndMillis() &&
        FieldUtils.equals(getChronology(), other.getChronology());
}
 

import org.joda.time.ReadableInterval; //导入方法依赖的package包/类
/**
 * Does this time interval contain the specified time interval.
 * <p>
 * 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.
 * <p>
 * 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 <code>contains</code> 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).
 * <p>
 * For example:
 * <pre>
 * [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)
 * </pre>
 * Passing in a <code>null</code> parameter will have the same effect as
 * calling {@link #containsNow()}.
 *
 * @param interval  the time interval to compare to, null means a zero duration interval now
 * @return 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);
}
 

import org.joda.time.ReadableInterval; //导入方法依赖的package包/类
/**
 * Does this time interval overlap the specified time interval.
 * <p>
 * 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. 
 * <p>
 * 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.
 * <p>
 * For example:
 * <pre>
 * [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
 * </pre>
 *
 * @param interval  the time interval to compare to, null means a zero length interval now
 * @return 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);
    }
}
 

import org.joda.time.ReadableInterval; //导入方法依赖的package包/类
/**
 * Is this interval equal to the specified interval ignoring the chronology.
 * <p>
 * This compares the underlying instants, ignoring the chronology.
 *
 * @param other  a readable interval to check against
 * @return 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();
}