Java DateTimeUtils.getInstantChronology方法代碼示例

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Constructs an interval from a start and end instant.
 * 
 * @param start  start of this interval, null means now
 * @param end  end of this interval, null means now
 * @throws IllegalArgumentException if the end is before the start
 */
protected BaseInterval(ReadableInstant start, ReadableInstant end) {
    super();
    if (start == null && end == null) {
        iStartMillis = iEndMillis = DateTimeUtils.currentTimeMillis();
        iChronology = ISOChronology.getInstance();
    } else {
        iChronology = DateTimeUtils.getInstantChronology(start);
        iStartMillis = DateTimeUtils.getInstantMillis(start);
        iEndMillis = DateTimeUtils.getInstantMillis(end);
        checkInterval(iStartMillis, iEndMillis);
    }
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Creates a period from the given start point and duration.
 *
 * @param startInstant  the interval start, null means now
 * @param duration  the duration of the interval, null means zero-length
 * @param type  which set of fields this period supports, null means standard
 */
protected BasePeriod(ReadableInstant startInstant, ReadableDuration duration, PeriodType type) {
    super();
    type = checkPeriodType(type);
    long startMillis = DateTimeUtils.getInstantMillis(startInstant);
    long durationMillis = DateTimeUtils.getDurationMillis(duration);
    long endMillis = FieldUtils.safeAdd(startMillis, durationMillis);
    Chronology chrono = DateTimeUtils.getInstantChronology(startInstant);
    iType = type;
    iValues = chrono.get(this, startMillis, endMillis);
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Calculates the number of whole units between the two specified datetimes.
 *
 * @param start  the start instant, validated to not be null
 * @param end  the end instant, validated to not be null
 * @param field  the field type to use, must not be null
 * @return the period
 * @throws IllegalArgumentException if the instants are null or invalid
 */
protected static int between(ReadableInstant start, ReadableInstant end, DurationFieldType field) {
    if (start == null || end == null) {
        throw new IllegalArgumentException("ReadableInstant objects must not be null");
    }
    Chronology chrono = DateTimeUtils.getInstantChronology(start);
    int amount = field.getField(chrono).getDifference(end.getMillis(), start.getMillis());
    return amount;
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Gets the total millisecond duration of this period relative to a start instant.
 * <p>
 * This method adds the period to the specified instant in order to
 * calculate the duration.
 * <p>
 * An instant must be supplied as the duration of a period varies.
 * For example, a period of 1 month could vary between the equivalent of
 * 28 and 31 days in milliseconds due to different length months.
 * Similarly, a day can vary at Daylight Savings cutover, typically between
 * 23 and 25 hours.
 *
 * @param startInstant  the instant to add the period to, thus obtaining the duration
 * @return the total length of the period as a duration relative to the start instant
 * @throws ArithmeticException if the millis exceeds the capacity of the duration
 */
public Duration toDurationFrom(ReadableInstant startInstant) {
    long startMillis = DateTimeUtils.getInstantMillis(startInstant);
    Chronology chrono = DateTimeUtils.getInstantChronology(startInstant);
    long endMillis = chrono.add(this, startMillis, 1);
    return new Duration(startMillis, endMillis);
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Gets the total millisecond duration of this period relative to an
 * end instant.
 * <p>
 * This method subtracts the period from the specified instant in order
 * to calculate the duration.
 * <p>
 * An instant must be supplied as the duration of a period varies.
 * For example, a period of 1 month could vary between the equivalent of
 * 28 and 31 days in milliseconds due to different length months.
 * Similarly, a day can vary at Daylight Savings cutover, typically between
 * 23 and 25 hours.
 *
 * @param endInstant  the instant to subtract the period from, thus obtaining the duration
 * @return the total length of the period as a duration relative to the end instant
 * @throws ArithmeticException if the millis exceeds the capacity of the duration
 */
public Duration toDurationTo(ReadableInstant endInstant) {
    long endMillis = DateTimeUtils.getInstantMillis(endInstant);
    Chronology chrono = DateTimeUtils.getInstantChronology(endInstant);
    long startMillis = chrono.add(this, endMillis, -1);
    return new Duration(startMillis, endMillis);
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Resolves this partial against another complete instant to create a new
 * full instant. The combination is performed using the chronology of the
 * specified instant.
 * <p>
 * For example, if this partial represents a time, then the result of this
 * method will be the datetime from the specified base instant plus the
 * time from this partial.
 *
 * @param baseInstant  the instant that provides the missing fields, null means now
 * @return the combined datetime
 */
public DateTime toDateTime(ReadableInstant baseInstant) {
    Chronology chrono = DateTimeUtils.getInstantChronology(baseInstant);
    long instantMillis = DateTimeUtils.getInstantMillis(baseInstant);
    long resolved = chrono.set(this, instantMillis);
    return new DateTime(resolved, chrono);
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Prints a ReadableInstant, using the chronology supplied by the instant.
 *
 * @param buf  the destination to format to, not null
 * @param instant  instant to format, null means now
 */
public void printTo(StringBuffer buf, ReadableInstant instant) {
    long millis = DateTimeUtils.getInstantMillis(instant);
    Chronology chrono = DateTimeUtils.getInstantChronology(instant);
    printTo(buf, millis, chrono);
}