All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.joda.time.chrono.GregorianChronology Maven / Gradle / Ivy

There is a newer version: 2.12.15
Show newest version
/*
 *  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; } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy