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包/类
public void testGetDurationConverter() {
    DurationConverter c = ConverterManager.getInstance().getDurationConverter(new Long(0L));
    assertEquals(Long.class, c.getSupportedType());
    
    c = ConverterManager.getInstance().getDurationConverter(new Duration(123L));
    assertEquals(ReadableDuration.class, c.getSupportedType());
    
    c = ConverterManager.getInstance().getDurationConverter(new Interval(0L, 1000L));
    assertEquals(ReadableInterval.class, c.getSupportedType());
    
    c = ConverterManager.getInstance().getDurationConverter("");
    assertEquals(String.class, c.getSupportedType());
    
    c = ConverterManager.getInstance().getDurationConverter(null);
    assertEquals(null, c.getSupportedType());
    
    try {
        ConverterManager.getInstance().getDurationConverter(Boolean.TRUE);
        fail();
    } catch (IllegalArgumentException ex) {}
}
 

import org.joda.time.ReadableInterval; //导入依赖的package包/类
public void testGetPeriodConverter() {
    PeriodConverter c = ConverterManager.getInstance().getPeriodConverter(new Period(1, 2, 3, 4, 5, 6, 7, 8));
    assertEquals(ReadablePeriod.class, c.getSupportedType());
    
    c = ConverterManager.getInstance().getPeriodConverter(new Duration(123L));
    assertEquals(ReadableDuration.class, c.getSupportedType());
    
    c = ConverterManager.getInstance().getPeriodConverter(new Interval(0L, 1000L));
    assertEquals(ReadableInterval.class, c.getSupportedType());
    
    c = ConverterManager.getInstance().getPeriodConverter("");
    assertEquals(String.class, c.getSupportedType());
    
    c = ConverterManager.getInstance().getPeriodConverter(null);
    assertEquals(null, c.getSupportedType());
    
    try {
        ConverterManager.getInstance().getPeriodConverter(Boolean.TRUE);
        fail();
    } catch (IllegalArgumentException ex) {}
}
 

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包/类
public static Interval intersect(ReadableInterval interval1, ReadableInterval interval2) {
    if (DateUtils.intersects(interval1, interval2) == false) {
        return null;
    }
    long start = Math.max(interval1.getStartMillis(), interval2.getStartMillis());
    long end = Math.min(interval1.getEndMillis(), interval2.getEndMillis());
    return new Interval(start, end);
}
 

import org.joda.time.ReadableInterval; //导入依赖的package包/类
/**
 * Is this time interval entirely after the specified interval.
 * <p>
 * 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.
 * 
 * @param interval  the interval to compare to, null means now
 * @return 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);
}
 

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包/类
@Override
public Object create(Object request, SpecimenContext context) {
    if (!(request.equals(ReadableInterval.class) || request.equals(ReadWritableInterval.class)))
        return new NoSpecimen();

    Interval interval = (Interval) context.resolve(Interval.class);
    return new MutableInterval(interval);
}
 

import org.joda.time.ReadableInterval; //导入依赖的package包/类
@Test
public void creates_instance_of_ReadableInterval() throws ParseException {
    ReadableInterval interval = fixture.create(ReadableInterval.class);
    assertThat(interval, notNullValue());
    assertThat(interval.getStart().toDate(), is(date));
    assertThat(interval.getEnd().toDate(), is(secondDate));
}
 

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包/类
/**
 * Returns ReadableInterval.class.
 */
public Class<?> getSupportedType() {
    return ReadableInterval.class;
}
 

import org.joda.time.ReadableInterval; //导入依赖的package包/类
public void testSupportedType() throws Exception {
    assertEquals(ReadableInterval.class, ReadableIntervalConverter.INSTANCE.getSupportedType());
}