下面列出了怎么用org.joda.time.Chronology的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* If month-day is 02-29 and year isn't leap, advances to next leap year.
*/
private long setDayOfMonthNext(Chronology chrono, long next) {
try {
next = setDayOfMonth(chrono, next);
} catch (IllegalArgumentException e) {
if (iMonthOfYear == 2 && iDayOfMonth == 29) {
while (chrono.year().isLeap(next) == false) {
next = chrono.year().add(next, 1);
}
next = setDayOfMonth(chrono, next);
} else {
throw e;
}
}
return next;
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* If month-day is 02-29 and year isn't leap, retreats to previous leap year.
*/
private long setDayOfMonthPrevious(Chronology chrono, long prev) {
try {
prev = setDayOfMonth(chrono, prev);
} catch (IllegalArgumentException e) {
if (iMonthOfYear == 2 && iDayOfMonth == 29) {
while (chrono.year().isLeap(prev) == false) {
prev = chrono.year().add(prev, -1);
}
prev = setDayOfMonth(chrono, prev);
} else {
throw e;
}
}
return prev;
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* If month-day is 02-29 and year isn't leap, advances to next leap year.
*/
private long setDayOfMonthNext(Chronology chrono, long next) {
try {
next = setDayOfMonth(chrono, next);
} catch (IllegalArgumentException e) {
if (iMonthOfYear == 2 && iDayOfMonth == 29) {
while (chrono.year().isLeap(next) == false) {
next = chrono.year().add(next, 1);
}
next = setDayOfMonth(chrono, next);
} else {
throw e;
}
}
return next;
}
/**
* If month-day is 02-29 and year isn't leap, retreats to previous leap year.
*/
private long setDayOfMonthPrevious(Chronology chrono, long prev) {
try {
prev = setDayOfMonth(chrono, prev);
} catch (IllegalArgumentException e) {
if (iMonthOfYear == 2 && iDayOfMonth == 29) {
while (chrono.year().isLeap(prev) == false) {
prev = chrono.year().add(prev, -1);
}
prev = setDayOfMonth(chrono, prev);
} else {
throw e;
}
}
return prev;
}
/**
* If month-day is 02-29 and year isn't leap, advances to next leap year.
*/
private long setDayOfMonthNext(Chronology chrono, long next) {
try {
next = setDayOfMonth(chrono, next);
} catch (IllegalArgumentException e) {
if (iMonthOfYear == 2 && iDayOfMonth == 29) {
while (chrono.year().isLeap(next) == false) {
next = chrono.year().add(next, 1);
}
next = setDayOfMonth(chrono, next);
} else {
throw e;
}
}
return next;
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
private long setDayOfWeek(Chronology chrono, long instant) {
int dayOfWeek = chrono.dayOfWeek().get(instant);
int daysToAdd = iDayOfWeek - dayOfWeek;
if (daysToAdd != 0) {
if (iAdvance) {
if (daysToAdd < 0) {
daysToAdd += 7;
}
} else {
if (daysToAdd > 0) {
daysToAdd -= 7;
}
}
instant = chrono.dayOfWeek().add(instant, daysToAdd);
}
return instant;
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* Parses only the local date-time from the given text, returning a new LocalDate.
* <p>
* This will parse the text fully according to the formatter, using the UTC zone.
* Once parsed, only the local date-time will be used.
* This means that any parsed time-zone or offset field is completely ignored.
* It also means that the zone and offset-parsed settings are ignored.
*
* @param text the text to parse, not null
* @return the parsed date-time, never null
* @throws UnsupportedOperationException if parsing is not supported
* @throws IllegalArgumentException if the text to parse is invalid
* @since 2.0
*/
public LocalDateTime parseLocalDateTime(String text) {
DateTimeParser parser = requireParser();
Chronology chrono = selectChronology(null).withUTC(); // always use UTC, avoiding DST gaps
DateTimeParserBucket bucket = new DateTimeParserBucket(0, chrono, iLocale, iPivotYear, iDefaultYear);
int newPos = parser.parseInto(bucket, text, 0);
if (newPos >= 0) {
if (newPos >= text.length()) {
long millis = bucket.computeMillis(true, text);
if (bucket.getOffsetInteger() != null) { // treat withOffsetParsed() as being true
int parsedOffset = bucket.getOffsetInteger();
DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset);
chrono = chrono.withZone(parsedZone);
} else if (bucket.getZone() != null) {
chrono = chrono.withZone(bucket.getZone());
}
return new LocalDateTime(millis, chrono);
}
} else {
newPos = ~newPos;
}
throw new IllegalArgumentException(FormatUtils.createErrorMessage(text, newPos));
}
private long setDayOfWeek(Chronology chrono, long instant) {
int dayOfWeek = chrono.dayOfWeek().get(instant);
int daysToAdd = iDayOfWeek - dayOfWeek;
if (daysToAdd != 0) {
if (iAdvance) {
if (daysToAdd < 0) {
daysToAdd += 7;
}
} else {
if (daysToAdd > 0) {
daysToAdd -= 7;
}
}
instant = chrono.dayOfWeek().add(instant, daysToAdd);
}
return instant;
}
/**
* If month-day is 02-29 and year isn't leap, retreats to previous leap year.
*/
private long setDayOfMonthPrevious(Chronology chrono, long prev) {
try {
prev = setDayOfMonth(chrono, prev);
} catch (IllegalArgumentException e) {
if (iMonthOfYear == 2 && iDayOfMonth == 29) {
while (chrono.year().isLeap(prev) == false) {
prev = chrono.year().add(prev, -1);
}
prev = setDayOfMonth(chrono, prev);
} else {
throw e;
}
}
return prev;
}
/**
* Calculates the number of whole units between the two specified partial datetimes.
* <p>
* The two partials must contain the same fields, for example you can specify
* two <code>LocalDate</code> objects.
*
* @param start the start partial date, validated to not be null
* @param end the end partial date, validated to not be null
* @param zeroInstance the zero instance constant, must not be null
* @return the period
* @throws IllegalArgumentException if the partials are null or invalid
*/
protected static int between(ReadablePartial start, ReadablePartial end, ReadablePeriod zeroInstance) {
if (start == null || end == null) {
throw new IllegalArgumentException("ReadablePartial objects must not be null");
}
if (start.size() != end.size()) {
throw new IllegalArgumentException("ReadablePartial objects must have the same set of fields");
}
for (int i = 0, isize = start.size(); i < isize; i++) {
if (start.getFieldType(i) != end.getFieldType(i)) {
throw new IllegalArgumentException("ReadablePartial objects must have the same set of fields");
}
}
if (DateTimeUtils.isContiguous(start) == false) {
throw new IllegalArgumentException("ReadablePartial objects must be contiguous");
}
Chronology chrono = DateTimeUtils.getChronology(start.getChronology()).withUTC();
int[] values = chrono.get(zeroInstance, chrono.set(start, 0L), chrono.set(end, 0L));
return values[0];
}
public long getDateTimeMillis(int year, int monthOfYear, int dayOfMonth,
int millisOfDay)
throws IllegalArgumentException
{
Chronology base;
if ((base = getBase()) != null) {
return base.getDateTimeMillis(year, monthOfYear, dayOfMonth, millisOfDay);
}
// Assume date is Gregorian.
long instant = iGregorianChronology.getDateTimeMillis
(year, monthOfYear, dayOfMonth, millisOfDay);
if (instant < iCutoverMillis) {
// Maybe it's Julian.
instant = iJulianChronology.getDateTimeMillis
(year, monthOfYear, dayOfMonth, millisOfDay);
if (instant >= iCutoverMillis) {
// Okay, it's in the illegal cutover gap.
throw new IllegalArgumentException("Specified date does not exist");
}
}
return instant;
}
/**
* If month-day is 02-29 and year isn't leap, retreats to previous leap year.
*/
private long setDayOfMonthPrevious(Chronology chrono, long prev) {
try {
prev = setDayOfMonth(chrono, prev);
} catch (IllegalArgumentException e) {
if (iMonthOfYear == 2 && iDayOfMonth == 29) {
while (chrono.year().isLeap(prev) == false) {
prev = chrono.year().add(prev, -1);
}
prev = setDayOfMonth(chrono, prev);
} else {
throw e;
}
}
return prev;
}
private void printTo(Writer buf, long instant, Chronology chrono) throws IOException {
DateTimePrinter printer = requirePrinter();
chrono = selectChronology(chrono);
// Shift instant into local time (UTC) to avoid excessive offset
// calculations when printing multiple fields in a composite printer.
DateTimeZone zone = chrono.getZone();
int offset = zone.getOffset(instant);
long adjustedInstant = instant + offset;
if ((instant ^ adjustedInstant) < 0 && (instant ^ offset) >= 0) {
// Time zone offset overflow, so revert to UTC.
zone = DateTimeZone.UTC;
offset = 0;
adjustedInstant = instant;
}
printer.printTo(buf, adjustedInstant, chrono.withUTC(), offset, zone, iLocale);
}
/**
* If month-day is 02-29 and year isn't leap, advances to next leap year.
*/
private long setDayOfMonthNext(Chronology chrono, long next) {
try {
next = setDayOfMonth(chrono, next);
} catch (IllegalArgumentException e) {
if (iMonthOfYear == 2 && iDayOfMonth == 29) {
while (chrono.year().isLeap(next) == false) {
next = chrono.year().add(next, 1);
}
next = setDayOfMonth(chrono, next);
} else {
throw e;
}
}
return next;
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* @param standardOffset standard offset just before previous recurrence
*/
public long previous(long instant, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
// Convert from UTC to local time.
instant += offset;
Chronology chrono = ISOChronology.getInstanceUTC();
long prev = chrono.monthOfYear().set(instant, iMonthOfYear);
// Be lenient with millisOfDay.
prev = chrono.millisOfDay().set(prev, 0);
prev = chrono.millisOfDay().add(prev, iMillisOfDay);
prev = setDayOfMonthPrevious(chrono, prev);
if (iDayOfWeek == 0) {
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = setDayOfMonthPrevious(chrono, prev);
}
} else {
prev = setDayOfWeek(chrono, prev);
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = chrono.monthOfYear().set(prev, iMonthOfYear);
prev = setDayOfMonthPrevious(chrono, prev);
prev = setDayOfWeek(chrono, prev);
}
}
// Convert from local time to UTC.
return prev - offset;
}
/**
* Called when applying a time zone.
*/
private GJChronology(Chronology base,
JulianChronology julian,
GregorianChronology gregorian,
Instant cutoverInstant) {
super(base, new Object[] {julian, gregorian, cutoverInstant});
}
@Override
public void write(Kryo kryo, Output output, LocalTime object) {
final int time = object.getMillisOfDay();
output.writeInt(time, true);
final Chronology chronology = object.getChronology();
if (chronology != null && chronology != ISOChronology.getInstanceUTC()) {
throw new RuntimeException("Unsupported chronology: " + chronology);
}
}
/**
* Gets the Chronology in a specific time zone.
*
* @param zone the zone to get the chronology in, null is default
* @return the chronology
*/
public Chronology withZone(DateTimeZone zone) {
if (zone == null) {
zone = DateTimeZone.getDefault();
}
if (zone == getZone()) {
return this;
}
return getInstance(zone, iCutoverInstant, getMinimumDaysInFirstWeek());
}
/**
* @param standardOffset standard offset just before previous recurrence
*/
public long previous(long instant, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
// Convert from UTC to local time.
instant += offset;
Chronology chrono = ISOChronology.getInstanceUTC();
long prev = chrono.monthOfYear().set(instant, iMonthOfYear);
// Be lenient with millisOfDay.
prev = chrono.millisOfDay().set(prev, 0);
prev = chrono.millisOfDay().add(prev, iMillisOfDay);
prev = setDayOfMonthPrevious(chrono, prev);
if (iDayOfWeek == 0) {
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = setDayOfMonthPrevious(chrono, prev);
}
} else {
prev = setDayOfWeek(chrono, prev);
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = chrono.monthOfYear().set(prev, iMonthOfYear);
prev = setDayOfMonthPrevious(chrono, prev);
prev = setDayOfWeek(chrono, prev);
}
}
// Convert from local time to UTC.
return prev - offset;
}
/**
* 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();
}
}
/**
* @param standardOffset standard offset just before previous recurrence
*/
public long previous(long instant, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
// Convert from UTC to local time.
instant += offset;
Chronology chrono = ISOChronology.getInstanceUTC();
long prev = chrono.monthOfYear().set(instant, iMonthOfYear);
// Be lenient with millisOfDay.
prev = chrono.millisOfDay().set(prev, 0);
prev = chrono.millisOfDay().add(prev, iMillisOfDay);
prev = setDayOfMonthPrevious(chrono, prev);
if (iDayOfWeek == 0) {
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = setDayOfMonthPrevious(chrono, prev);
}
} else {
prev = setDayOfWeek(chrono, prev);
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = chrono.monthOfYear().set(prev, iMonthOfYear);
prev = setDayOfMonthPrevious(chrono, prev);
prev = setDayOfWeek(chrono, prev);
}
}
// Convert from local time to UTC.
return prev - offset;
}
/**
* Called when applying a time zone.
*/
private GJChronology(Chronology base,
JulianChronology julian,
GregorianChronology gregorian,
Instant cutoverInstant) {
super(base, new Object[] {julian, gregorian, cutoverInstant});
}