Java DateTimeUtils.getChronology方法代碼示例

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Creates a new period based on another using the {@link ConverterManager}.
 *
 * @param period  the period to convert
 * @param type  which set of fields this period supports, null means use type from object
 * @param chrono  the chronology to use, null means ISO default
 * @throws IllegalArgumentException if period is invalid
 * @throws IllegalArgumentException if an unsupported field's value is non-zero
 */
protected BasePeriod(Object period, PeriodType type, Chronology chrono) {
    super();
    PeriodConverter converter = ConverterManager.getInstance().getPeriodConverter(period);
    type = (type == null ? converter.getPeriodType(period) : type);
    type = checkPeriodType(type);
    iType = type;
    if (this instanceof ReadWritablePeriod) {
        iValues = new int[size()];
        chrono = DateTimeUtils.getChronology(chrono);
        converter.setInto((ReadWritablePeriod) this, period, chrono);
    } else {
        iValues = new MutablePeriod(period, type, chrono).getValues();
    }
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Determines the correct chronology to use.
 *
 * @param chrono  the proposed chronology
 * @return the actual chronology
 */
private Chronology selectChronology(Chronology chrono) {
    chrono = DateTimeUtils.getChronology(chrono);
    if (iChrono != null) {
        chrono = iChrono;
    }
    if (iZone != null) {
        chrono = chrono.withZone(iZone);
    }
    return chrono;
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Constructs a bucket, with the option of specifying the pivot year for
 * two-digit year parsing.
 *
 * @param instantLocal  the initial millis from 1970-01-01T00:00:00, local time
 * @param chrono  the chronology to use
 * @param locale  the locale to use
 * @param pivotYear  the pivot year to use when parsing two-digit years
 * @since 2.0
 */
public DateTimeParserBucket(long instantLocal, Chronology chrono,
        Locale locale, Integer pivotYear, int defaultYear) {
    super();
    chrono = DateTimeUtils.getChronology(chrono);
    iMillis = instantLocal;
    iZone = chrono.getZone();
    iChrono = chrono.withUTC();
    iLocale = (locale == null ? Locale.getDefault() : locale);
    iPivotYear = pivotYear;
    iDefaultYear = defaultYear;
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
private Chronology selectChronology() {
    Chronology chrono = DateTimeUtils.getChronology(null);
    if (getChronolgy() != null) {
        chrono = getChronolgy();
    }
    if (getZone() != null) {
        chrono = chrono.withZone(getZone());
    }
    return chrono;
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Constructs an interval from a start and end instant.
 * 
 * @param startInstant  start of this interval, as milliseconds from 1970-01-01T00:00:00Z.
 * @param endInstant  end of this interval, as milliseconds from 1970-01-01T00:00:00Z.
 * @param chrono  the chronology to use, null is ISO default
 * @throws IllegalArgumentException if the end is before the start
 */
protected BaseInterval(long startInstant, long endInstant, Chronology chrono) {
    super();
    iChronology = DateTimeUtils.getChronology(chrono);
    checkInterval(startInstant, endInstant);
    iStartMillis = startInstant;
    iEndMillis = endInstant;
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Sets this interval from two millisecond instants and a chronology.
 *
 * @param startInstant  the start of the time interval
 * @param endInstant  the start of the time interval
 * @param chrono  the chronology, not null
 * @throws IllegalArgumentException if the end is before the start
 */
protected void setInterval(long startInstant, long endInstant, Chronology chrono) {
    checkInterval(startInstant, endInstant);
    iStartMillis = startInstant;
    iEndMillis = endInstant;
    iChronology = DateTimeUtils.getChronology(chrono);
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Constructs a partial extracting the partial fields from the specified
 * milliseconds using the chronology provided.
 * <p>
 * The constructor uses the time zone of the chronology specified.
 * Once the constructor is complete, all further calculations are performed
 * without reference to a timezone (by switching to UTC).
 *
 * @param instant  the milliseconds from 1970-01-01T00:00:00Z
 * @param chronology  the chronology, null means ISOChronology in the default zone
 */
protected BasePartial(long instant, Chronology chronology) {
    super();
    chronology = DateTimeUtils.getChronology(chronology);
    iChronology = chronology.withUTC();
    iValues = chronology.get(this, instant);
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Gets the chronology, which is taken from the ReadableInstant.
 * <p>
 * If the passed in chronology is non-null, it is used.
 * Otherwise the chronology from the instant is used.
 * 
 * @param object  the ReadablePartial to convert, must not be null
 * @param chrono  the chronology to use, null means use that from object
 * @return the chronology, never null
 */
public Chronology getChronology(Object object, Chronology chrono) {
    if (chrono == null) {
        chrono = ((ReadablePartial) object).getChronology();
        chrono = DateTimeUtils.getChronology(chrono);
    }
    return chrono;
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Gets the chronology, which is taken from the ReadableInstant.
 * <p>
 * If the passed in chronology is non-null, it is used.
 * Otherwise the chronology from the instant is used.
 * 
 * @param object  the ReadableInstant to convert, must not be null
 * @param chrono  the chronology to use, null means use that from object
 * @return the chronology, never null
 */
public Chronology getChronology(Object object, Chronology chrono) {
    if (chrono == null) {
        chrono = ((ReadableInstant) object).getChronology();
        chrono = DateTimeUtils.getChronology(chrono);
    }
    return chrono;
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Extracts duration values from an object of this converter's type, and
 * sets them into the given ReadWritableDuration.
 *
 * @param writablePeriod  period to get modified
 * @param object  the object to convert, must not be null
 * @param chrono  the chronology to use, must not be null
 * @throws NullPointerException if the duration or object is null
 * @throws ClassCastException if the object is an invalid type
 * @throws IllegalArgumentException if the object is invalid
 */
public void setInto(ReadWritablePeriod writablePeriod, Object object, Chronology chrono) {
    ReadableDuration dur = (ReadableDuration) object;
    chrono = DateTimeUtils.getChronology(chrono);
    long duration = dur.getMillis();
    int[] values = chrono.get(writablePeriod, duration);
    for (int i = 0; i < values.length; i++) {
        writablePeriod.setValue(i, values[i]);
    }
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Checks the specified chronology before storing it, potentially altering it.
 * This method must not access any instance variables.
 * <p>
 * This implementation converts nulls to ISOChronology in the default zone.
 *
 * @param chronology the chronology to use, may be null
 * @return the chronology to store in this datetime, not null
 */
protected Chronology checkChronology(Chronology chronology) {
    return DateTimeUtils.getChronology(chronology);
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Checks the specified chronology before storing it, potentially altering it.
 * This method must not access any instance variables.
 * <p>
 * This implementation converts nulls to ISOChronology in the default zone.
 *
 * @param chronology  the chronology to use, may be null
 * @return the chronology to store in this datetime, not null
 */
protected Chronology checkChronology(Chronology chronology) {
    return DateTimeUtils.getChronology(chronology);
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Get this object as a DateTime using the same chronology but a different zone.
 * 
 * @param zone time zone to apply, or default if null
 * @return a DateTime using the same millis
 */
public DateTime toDateTime(DateTimeZone zone) {
    Chronology chrono = DateTimeUtils.getChronology(getChronology());
    chrono = chrono.withZone(zone);
    return new DateTime(getMillis(), chrono);
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Get this object as a MutableDateTime using the same chronology but a different zone.
 * 
 * @param zone time zone to apply, or default if null
 * @return a MutableDateTime using the same millis
 */
public MutableDateTime toMutableDateTime(DateTimeZone zone) {
    Chronology chrono = DateTimeUtils.getChronology(getChronology());
    chrono = chrono.withZone(zone);
    return new MutableDateTime(getMillis(), chrono);
}
 

import org.joda.time.DateTimeUtils; //導入方法依賴的package包/類
/**
 * Extracts the chronology from an object of this convertor's type
 * where the chronology is specified.
 * <p>
 * This implementation returns the chronology specified, or the
 * ISO chronology in the default zone if null passed in.
 * 
 * @param object  the object to convert
 * @param chrono  the chronology to use, null means ISO default
 * @return the chronology, never null
 */
public Chronology getChronology(Object object, Chronology chrono) {
    return DateTimeUtils.getChronology(chrono);
}