com.groupbyinc.common.joda.time.chrono.GregorianChronology Maven / Gradle / Ivy
/*
* Copyright 2001-2014 Stephen Colebourne
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.joda.time.chrono;
import java.util.concurrent.ConcurrentHashMap;
import org.joda.time.Chronology;
import org.joda.time.DateTimeConstants;
import org.joda.time.DateTimeZone;
/**
* Implements a pure proleptic Gregorian calendar system, which defines every
* fourth year as leap, unless the year is divisible by 100 and not by 400.
* This improves upon the Julian calendar leap year rule.
*
* Although the Gregorian calendar did not exist before 1582 CE, this
* chronology assumes it did, thus it is proleptic. This implementation also
* fixes the start of the year at January 1, and defines the year zero.
*
* GregorianChronology is thread-safe and immutable.
*
* @see Wikipedia
* @see JulianChronology
* @see GJChronology
*
* @author Guy Allard
* @author Stephen Colebourne
* @author Brian S O'Neill
* @since 1.0
*/
public final class GregorianChronology extends BasicGJChronology {
/** Serialization lock */
private static final long serialVersionUID = -861407383323710522L;
private static final long MILLIS_PER_YEAR =
(long) (365.2425 * DateTimeConstants.MILLIS_PER_DAY);
private static final long MILLIS_PER_MONTH =
(long) (365.2425 * DateTimeConstants.MILLIS_PER_DAY / 12);
private static final int DAYS_0000_TO_1970 = 719527;
/** The lowest year that can be fully supported. */
private static final int MIN_YEAR = -292275054;
/** The highest year that can be fully supported. */
private static final int MAX_YEAR = 292278993;
/** Singleton instance of a UTC GregorianChronology */
private static final GregorianChronology INSTANCE_UTC;
/** Cache of zone to chronology arrays */
private static final ConcurrentHashMap cCache = new ConcurrentHashMap();
static {
INSTANCE_UTC = getInstance(DateTimeZone.UTC);
}
/**
* Gets an instance of the GregorianChronology.
* The time zone of the returned instance is UTC.
*
* @return a singleton UTC instance of the chronology
*/
public static GregorianChronology getInstanceUTC() {
return INSTANCE_UTC;
}
/**
* Gets an instance of the GregorianChronology in the default time zone.
*
* @return a chronology in the default time zone
*/
public static GregorianChronology getInstance() {
return getInstance(DateTimeZone.getDefault(), 4);
}
/**
* Gets an instance of the GregorianChronology in the given time zone.
*
* @param zone the time zone to get the chronology in, null is default
* @return a chronology in the specified time zone
*/
public static GregorianChronology getInstance(DateTimeZone zone) {
return getInstance(zone, 4);
}
/**
* Gets an instance of the GregorianChronology in the given time zone.
*
* @param zone the time zone to get the chronology in, null is default
* @param minDaysInFirstWeek minimum number of days in first week of the year; default is 4
* @return a chronology in the specified time zone
*/
public static GregorianChronology getInstance(DateTimeZone zone, int minDaysInFirstWeek) {
if (zone == null) {
zone = DateTimeZone.getDefault();
}
GregorianChronology chrono;
GregorianChronology[] chronos = cCache.get(zone);
if (chronos == null) {
chronos = new GregorianChronology[7];
GregorianChronology[] oldChronos = cCache.putIfAbsent(zone, chronos);
if (oldChronos != null) {
chronos = oldChronos;
}
}
try {
chrono = chronos[minDaysInFirstWeek - 1];
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalArgumentException
("Invalid min days in first week: " + minDaysInFirstWeek);
}
if (chrono == null) {
synchronized (chronos) {
chrono = chronos[minDaysInFirstWeek - 1];
if (chrono == null) {
if (zone == DateTimeZone.UTC) {
chrono = new GregorianChronology(null, null, minDaysInFirstWeek);
} else {
chrono = getInstance(DateTimeZone.UTC, minDaysInFirstWeek);
chrono = new GregorianChronology
(ZonedChronology.getInstance(chrono, zone), null, minDaysInFirstWeek);
}
chronos[minDaysInFirstWeek - 1] = chrono;
}
}
}
return chrono;
}
// Constructors and instance variables
//-----------------------------------------------------------------------
/**
* Restricted constructor
*/
private GregorianChronology(Chronology base, Object param, int minDaysInFirstWeek) {
super(base, param, minDaysInFirstWeek);
}
/**
* Serialization singleton
*/
private Object readResolve() {
Chronology base = getBase();
int minDays = getMinimumDaysInFirstWeek();
minDays = (minDays == 0 ? 4 : minDays); // handle rename of BaseGJChronology
return base == null ?
getInstance(DateTimeZone.UTC, minDays) :
getInstance(base.getZone(), minDays);
}
// Conversion
//-----------------------------------------------------------------------
/**
* Gets the Chronology in the UTC time zone.
*
* @return the chronology in UTC
*/
public Chronology withUTC() {
return INSTANCE_UTC;
}
/**
* 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);
}
protected void assemble(Fields fields) {
if (getBase() == null) {
super.assemble(fields);
}
}
boolean isLeapYear(int year) {
return ((year & 3) == 0) && ((year % 100) != 0 || (year % 400) == 0);
}
long calculateFirstDayOfYearMillis(int year) {
// Initial value is just temporary.
int leapYears = year / 100;
if (year < 0) {
// Add 3 before shifting right since /4 and >>2 behave differently
// on negative numbers. When the expression is written as
// (year / 4) - (year / 100) + (year / 400),
// it works for both positive and negative values, except this optimization
// eliminates two divisions.
leapYears = ((year + 3) >> 2) - leapYears + ((leapYears + 3) >> 2) - 1;
} else {
leapYears = (year >> 2) - leapYears + (leapYears >> 2);
if (isLeapYear(year)) {
leapYears--;
}
}
return (year * 365L + (leapYears - DAYS_0000_TO_1970)) * DateTimeConstants.MILLIS_PER_DAY;
}
int getMinYear() {
return MIN_YEAR;
}
int getMaxYear() {
return MAX_YEAR;
}
long getAverageMillisPerYear() {
return MILLIS_PER_YEAR;
}
long getAverageMillisPerYearDividedByTwo() {
return MILLIS_PER_YEAR / 2;
}
long getAverageMillisPerMonth() {
return MILLIS_PER_MONTH;
}
long getApproxMillisAtEpochDividedByTwo() {
return (1970L * MILLIS_PER_YEAR) / 2;
}
}