ERA_FULL_NAMES = new HashMap<>();
/**
* Fallback language for the era names.
*/
private static final String FALLBACK_LANGUAGE = "en";
/**
* Singleton instance of the Hijrah chronology.
* Must be initialized after the rest of the static initialization.
*/
public static final HijrahChrono INSTANCE;
/**
* Name data.
*/
static {
ERA_NARROW_NAMES.put(FALLBACK_LANGUAGE, new String[]{"BH", "HE"});
ERA_SHORT_NAMES.put(FALLBACK_LANGUAGE, new String[]{"B.H.", "H.E."});
ERA_FULL_NAMES.put(FALLBACK_LANGUAGE, new String[]{"Before Hijrah", "Hijrah Era"});
DEFAULT_MONTH_DAYS = Arrays.copyOf(NUM_DAYS, NUM_DAYS.length);
DEFAULT_LEAP_MONTH_DAYS = Arrays.copyOf(LEAP_NUM_DAYS, LEAP_NUM_DAYS.length);
DEFAULT_MONTH_LENGTHS = Arrays.copyOf(MONTH_LENGTH, MONTH_LENGTH.length);
DEFAULT_LEAP_MONTH_LENGTHS = Arrays.copyOf(LEAP_MONTH_LENGTH, LEAP_MONTH_LENGTH.length);
DEFAULT_CYCLE_YEARS = Arrays.copyOf(CYCLEYEAR_START_DATE, CYCLEYEAR_START_DATE.length);
INSTANCE = new HijrahChrono();
String extraCalendars = java.security.AccessController.doPrivileged(
new sun.security.action.GetPropertyAction("java.time.calendar.HijrahCalendars"));
if (extraCalendars != null) {
try {
// Split on whitespace
String[] splits = extraCalendars.split("\\s");
for (String cal : splits) {
if (!cal.isEmpty()) {
// Split on the delimiter between typeId "-" calendarType
String[] type = cal.split("-");
Chrono cal2 = new HijrahChrono(type[0], type.length > 1 ? type[1] : type[0]);
}
}
} catch (Exception ex) {
// Log the error
// ex.printStackTrace();
}
}
}
/**
* Restricted constructor.
*/
private HijrahChrono() {
this("Hijrah", "islamicc");
}
/**
* Constructor for name and type HijrahChrono.
* @param id the id of the calendar
* @param calendarType the calendar type
*/
private HijrahChrono(String id, String calendarType) {
this.typeId = id;
this.calendarType = calendarType;
ADJUSTED_CYCLES = new long[MAX_ADJUSTED_CYCLE];
for (int i = 0; i < ADJUSTED_CYCLES.length; i++) {
ADJUSTED_CYCLES[i] = (10631L * i);
}
// Initialize min values, least max values and max values.
ADJUSTED_MIN_VALUES = Arrays.copyOf(MIN_VALUES, MIN_VALUES.length);
ADJUSTED_LEAST_MAX_VALUES = Arrays.copyOf(LEAST_MAX_VALUES, LEAST_MAX_VALUES.length);
ADJUSTED_MAX_VALUES = Arrays.copyOf(MAX_VALUES,MAX_VALUES.length);
try {
// Implicitly reads deviation data for this HijrahChronology.
boolean any = HijrahDeviationReader.readDeviation(typeId, calendarType, this::addDeviationAsHijrah);
} catch (IOException | ParseException e) {
// do nothing. Log deviation config errors.
//e.printStackTrace();
}
}
/**
* Resolve singleton.
*
* @return the singleton instance, not null
*/
private Object readResolve() {
return INSTANCE;
}
//-----------------------------------------------------------------------
/**
* Gets the ID of the chronology - 'Hijrah'.
*
* The ID uniquely identifies the {@code Chrono}.
* It can be used to lookup the {@code Chrono} using {@link #of(String)}.
*
* @return the chronology ID - 'Hijrah'
* @see #getCalendarType()
*/
@Override
public String getId() {
return typeId;
}
/**
* Gets the calendar type of the underlying calendar system - 'islamicc'.
*
* The calendar type is an identifier defined by the
* Unicode Locale Data Markup Language (LDML) specification.
* It can be used to lookup the {@code Chrono} using {@link #of(String)}.
* It can also be used as part of a locale, accessible via
* {@link Locale#getUnicodeLocaleType(String)} with the key 'ca'.
*
* @return the calendar system type - 'islamicc'
* @see #getId()
*/
@Override
public String getCalendarType() {
return calendarType;
}
//-----------------------------------------------------------------------
@Override
public ChronoLocalDate date(int prolepticYear, int month, int dayOfMonth) {
return HijrahDate.of(this, prolepticYear, month, dayOfMonth);
}
@Override
public ChronoLocalDate dateYearDay(int prolepticYear, int dayOfYear) {
return HijrahDate.of(this, prolepticYear, 1, 1).plusDays(dayOfYear - 1); // TODO better
}
@Override
public ChronoLocalDate date(TemporalAccessor temporal) {
if (temporal instanceof HijrahDate) {
return (HijrahDate) temporal;
}
return HijrahDate.ofEpochDay(this, temporal.getLong(EPOCH_DAY));
}
//-----------------------------------------------------------------------
@Override
public boolean isLeapYear(long prolepticYear) {
return isLeapYear0(prolepticYear);
}
/**
* Returns if the year is a leap year.
* @param prolepticYear he year to compute from
* @return {@code true} if the year is a leap year, otherwise {@code false}
*/
private static boolean isLeapYear0(long prolepticYear) {
return (14 + 11 * (prolepticYear > 0 ? prolepticYear : -prolepticYear)) % 30 < 11;
}
@Override
public int prolepticYear(Era era, int yearOfEra) {
if (era instanceof HijrahEra == false) {
throw new DateTimeException("Era must be HijrahEra");
}
return (era == HijrahEra.AH ? yearOfEra : 1 - yearOfEra);
}
@Override
public Era eraOf(int eraValue) {
switch (eraValue) {
case 0:
return HijrahEra.BEFORE_AH;
case 1:
return HijrahEra.AH;
default:
throw new DateTimeException("invalid Hijrah era");
}
}
@Override
public List> eras() {
return Arrays.>asList(HijrahEra.values());
}
//-----------------------------------------------------------------------
@Override
public ValueRange range(ChronoField field) {
return field.range();
}
/**
* Check the validity of a yearOfEra.
* @param yearOfEra the year to check
*/
void checkValidYearOfEra(int yearOfEra) {
if (yearOfEra < MIN_YEAR_OF_ERA ||
yearOfEra > MAX_YEAR_OF_ERA) {
throw new DateTimeException("Invalid year of Hijrah Era");
}
}
void checkValidDayOfYear(int dayOfYear) {
if (dayOfYear < 1 ||
dayOfYear > getMaximumDayOfYear()) {
throw new DateTimeException("Invalid day of year of Hijrah date");
}
}
void checkValidMonth(int month) {
if (month < 1 || month > 12) {
throw new DateTimeException("Invalid month of Hijrah date");
}
}
void checkValidDayOfMonth(int dayOfMonth) {
if (dayOfMonth < 1 ||
dayOfMonth > getMaximumDayOfMonth()) {
throw new DateTimeException("Invalid day of month of Hijrah date, day "
+ dayOfMonth + " greater than " + getMaximumDayOfMonth() + " or less than 1");
}
}
//-----------------------------------------------------------------------
/**
* Returns the int array containing the following field from the julian day.
*
* int[0] = ERA
* int[1] = YEAR
* int[2] = MONTH
* int[3] = DATE
* int[4] = DAY_OF_YEAR
* int[5] = DAY_OF_WEEK
*
* @param gregorianDays a julian day.
*/
int[] getHijrahDateInfo(long gregorianDays) {
int era, year, month, date, dayOfWeek, dayOfYear;
int cycleNumber, yearInCycle, dayOfCycle;
long epochDay = gregorianDays - HIJRAH_JAN_1_1_GREGORIAN_DAY;
if (epochDay >= 0) {
cycleNumber = getCycleNumber(epochDay); // 0 - 99.
dayOfCycle = getDayOfCycle(epochDay, cycleNumber); // 0 - 10631.
yearInCycle = getYearInCycle(cycleNumber, dayOfCycle); // 0 - 29.
dayOfYear = getDayOfYear(cycleNumber, dayOfCycle, yearInCycle);
// 0 - 354/355
year = cycleNumber * 30 + yearInCycle + 1; // 1-based year.
month = getMonthOfYear(dayOfYear, year); // 0-based month-of-year
date = getDayOfMonth(dayOfYear, month, year); // 0-based date
++date; // Convert from 0-based to 1-based
era = HijrahEra.AH.getValue();
} else {
cycleNumber = (int) epochDay / 10631; // 0 or negative number.
dayOfCycle = (int) epochDay % 10631; // -10630 - 0.
if (dayOfCycle == 0) {
dayOfCycle = -10631;
cycleNumber++;
}
yearInCycle = getYearInCycle(cycleNumber, dayOfCycle); // 0 - 29.
dayOfYear = getDayOfYear(cycleNumber, dayOfCycle, yearInCycle);
year = cycleNumber * 30 - yearInCycle; // negative number.
year = 1 - year;
dayOfYear = (isLeapYear(year) ? (dayOfYear + 355)
: (dayOfYear + 354));
month = getMonthOfYear(dayOfYear, year);
date = getDayOfMonth(dayOfYear, month, year);
++date; // Convert from 0-based to 1-based
era = HijrahEra.BEFORE_AH.getValue();
}
// Hijrah day zero is a Friday
dayOfWeek = (int) ((epochDay + 5) % 7);
dayOfWeek += (dayOfWeek <= 0) ? 7 : 0;
int dateInfo[] = new int[6];
dateInfo[0] = era;
dateInfo[1] = year;
dateInfo[2] = month + 1; // change to 1-based.
dateInfo[3] = date;
dateInfo[4] = dayOfYear + 1; // change to 1-based.
dateInfo[5] = dayOfWeek;
return dateInfo;
}
/**
* Return Gregorian epoch day from Hijrah year, month, and day.
*
* @param prolepticYear the year to represent, caller calculated
* @param monthOfYear the month-of-year to represent, caller calculated
* @param dayOfMonth the day-of-month to represent, caller calculated
* @return a julian day
*/
long getGregorianEpochDay(int prolepticYear, int monthOfYear, int dayOfMonth) {
long day = yearToGregorianEpochDay(prolepticYear);
day += getMonthDays(monthOfYear - 1, prolepticYear);
day += dayOfMonth;
return day;
}
/**
* Returns the Gregorian epoch day from the proleptic year
* @param prolepticYear the proleptic year
* @return the Epoch day
*/
private long yearToGregorianEpochDay(int prolepticYear) {
int cycleNumber = (prolepticYear - 1) / 30; // 0-based.
int yearInCycle = (prolepticYear - 1) % 30; // 0-based.
int dayInCycle = getAdjustedCycle(cycleNumber)[Math.abs(yearInCycle)]
;
if (yearInCycle < 0) {
dayInCycle = -dayInCycle;
}
Long cycleDays;
try {
cycleDays = ADJUSTED_CYCLES[cycleNumber];
} catch (ArrayIndexOutOfBoundsException e) {
cycleDays = null;
}
if (cycleDays == null) {
cycleDays = new Long(cycleNumber * 10631);
}
return (cycleDays.longValue() + dayInCycle + HIJRAH_JAN_1_1_GREGORIAN_DAY - 1);
}
/**
* Returns the 30 year cycle number from the epoch day.
*
* @param epochDay an epoch day
* @return a cycle number
*/
private int getCycleNumber(long epochDay) {
long[] days = ADJUSTED_CYCLES;
int cycleNumber;
try {
for (int i = 0; i < days.length; i++) {
if (epochDay < days[i]) {
return i - 1;
}
}
cycleNumber = (int) epochDay / 10631;
} catch (ArrayIndexOutOfBoundsException e) {
cycleNumber = (int) epochDay / 10631;
}
return cycleNumber;
}
/**
* Returns day of cycle from the epoch day and cycle number.
*
* @param epochDay an epoch day
* @param cycleNumber a cycle number
* @return a day of cycle
*/
private int getDayOfCycle(long epochDay, int cycleNumber) {
Long day;
try {
day = ADJUSTED_CYCLES[cycleNumber];
} catch (ArrayIndexOutOfBoundsException e) {
day = null;
}
if (day == null) {
day = new Long(cycleNumber * 10631);
}
return (int) (epochDay - day.longValue());
}
/**
* Returns the year in cycle from the cycle number and day of cycle.
*
* @param cycleNumber a cycle number
* @param dayOfCycle day of cycle
* @return a year in cycle
*/
private int getYearInCycle(int cycleNumber, long dayOfCycle) {
int[] cycles = getAdjustedCycle(cycleNumber);
if (dayOfCycle == 0) {
return 0;
}
if (dayOfCycle > 0) {
for (int i = 0; i < cycles.length; i++) {
if (dayOfCycle < cycles[i]) {
return i - 1;
}
}
return 29;
} else {
dayOfCycle = -dayOfCycle;
for (int i = 0; i < cycles.length; i++) {
if (dayOfCycle <= cycles[i]) {
return i - 1;
}
}
return 29;
}
}
/**
* Returns adjusted 30 year cycle starting day as Integer array from the
* cycle number specified.
*
* @param cycleNumber a cycle number
* @return an Integer array
*/
int[] getAdjustedCycle(int cycleNumber) {
int[] cycles;
try {
cycles = ADJUSTED_CYCLE_YEARS.get(cycleNumber);
} catch (ArrayIndexOutOfBoundsException e) {
cycles = null;
}
if (cycles == null) {
cycles = DEFAULT_CYCLE_YEARS;
}
return cycles;
}
/**
* Returns adjusted month days as Integer array form the year specified.
*
* @param year a year
* @return an Integer array
*/
int[] getAdjustedMonthDays(int year) {
int[] newMonths;
try {
newMonths = ADJUSTED_MONTH_DAYS.get(year);
} catch (ArrayIndexOutOfBoundsException e) {
newMonths = null;
}
if (newMonths == null) {
if (isLeapYear0(year)) {
newMonths = DEFAULT_LEAP_MONTH_DAYS;
} else {
newMonths = DEFAULT_MONTH_DAYS;
}
}
return newMonths;
}
/**
* Returns adjusted month length as Integer array form the year specified.
*
* @param year a year
* @return an Integer array
*/
int[] getAdjustedMonthLength(int year) {
int[] newMonths;
try {
newMonths = ADJUSTED_MONTH_LENGTHS.get(year);
} catch (ArrayIndexOutOfBoundsException e) {
newMonths = null;
}
if (newMonths == null) {
if (isLeapYear0(year)) {
newMonths = DEFAULT_LEAP_MONTH_LENGTHS;
} else {
newMonths = DEFAULT_MONTH_LENGTHS;
}
}
return newMonths;
}
/**
* Returns day-of-year.
*
* @param cycleNumber a cycle number
* @param dayOfCycle day of cycle
* @param yearInCycle year in cycle
* @return day-of-year
*/
private int getDayOfYear(int cycleNumber, int dayOfCycle, int yearInCycle) {
int[] cycles = getAdjustedCycle(cycleNumber);
if (dayOfCycle > 0) {
return dayOfCycle - cycles[yearInCycle];
} else {
return cycles[yearInCycle] + dayOfCycle;
}
}
/**
* Returns month-of-year. 0-based.
*
* @param dayOfYear day-of-year
* @param year a year
* @return month-of-year
*/
private int getMonthOfYear(int dayOfYear, int year) {
int[] newMonths = getAdjustedMonthDays(year);
if (dayOfYear >= 0) {
for (int i = 0; i < newMonths.length; i++) {
if (dayOfYear < newMonths[i]) {
return i - 1;
}
}
return 11;
} else {
dayOfYear = (isLeapYear0(year) ? (dayOfYear + 355)
: (dayOfYear + 354));
for (int i = 0; i < newMonths.length; i++) {
if (dayOfYear < newMonths[i]) {
return i - 1;
}
}
return 11;
}
}
/**
* Returns day-of-month.
*
* @param dayOfYear day of year
* @param month month
* @param year year
* @return day-of-month
*/
private int getDayOfMonth(int dayOfYear, int month, int year) {
int[] newMonths = getAdjustedMonthDays(year);
if (dayOfYear >= 0) {
if (month > 0) {
return dayOfYear - newMonths[month];
} else {
return dayOfYear;
}
} else {
dayOfYear = (isLeapYear0(year) ? (dayOfYear + 355)
: (dayOfYear + 354));
if (month > 0) {
return dayOfYear - newMonths[month];
} else {
return dayOfYear;
}
}
}
/**
* Returns month days from the beginning of year.
*
* @param month month (0-based)
* @parma year year
* @return month days from the beginning of year
*/
private int getMonthDays(int month, int year) {
int[] newMonths = getAdjustedMonthDays(year);
return newMonths[month];
}
/**
* Returns month length.
*
* @param month month (0-based)
* @param year year
* @return month length
*/
private int getMonthLength(int month, int year) {
int[] newMonths = getAdjustedMonthLength(year);
return newMonths[month];
}
/**
* Returns year length.
*
* @param year year
* @return year length
*/
int getYearLength(int year) {
int cycleNumber = (year - 1) / 30;
int[] cycleYears;
try {
cycleYears = ADJUSTED_CYCLE_YEARS.get(cycleNumber);
} catch (ArrayIndexOutOfBoundsException e) {
cycleYears = null;
}
if (cycleYears != null) {
int yearInCycle = (year - 1) % 30;
if (yearInCycle == 29) {
return (int)(ADJUSTED_CYCLES[cycleNumber + 1]
- ADJUSTED_CYCLES[cycleNumber]
- cycleYears[yearInCycle]);
}
return cycleYears[yearInCycle + 1]
- cycleYears[yearInCycle];
} else {
return isLeapYear0(year) ? 355 : 354;
}
}
/**
* Returns maximum day-of-month.
*
* @return maximum day-of-month
*/
int getMaximumDayOfMonth() {
return ADJUSTED_MAX_VALUES[POSITION_DAY_OF_MONTH];
}
/**
* Returns smallest maximum day-of-month.
*
* @return smallest maximum day-of-month
*/
int getSmallestMaximumDayOfMonth() {
return ADJUSTED_LEAST_MAX_VALUES[POSITION_DAY_OF_MONTH];
}
/**
* Returns maximum day-of-year.
*
* @return maximum day-of-year
*/
int getMaximumDayOfYear() {
return ADJUSTED_MAX_VALUES[POSITION_DAY_OF_YEAR];
}
/**
* Returns smallest maximum day-of-year.
*
* @return smallest maximum day-of-year
*/
int getSmallestMaximumDayOfYear() {
return ADJUSTED_LEAST_MAX_VALUES[POSITION_DAY_OF_YEAR];
}
// ----- Deviation handling -----//
/**
* Adds deviation definition. The year and month specified should be the
* calculated Hijrah year and month. The month is 1 based. e.g. 9 for
* Ramadan (9th month) Addition of anything minus deviation days is
* calculated negatively in the case the user wants to subtract days from
* the calendar. For example, adding -1 days will subtract one day from the
* current date.
*
* @param startYear start year, 1 origin
* @param startMonth start month, 1 origin
* @param endYear end year, 1 origin
* @param endMonth end month, 1 origin
* @param offset offset -2, -1, +1, +2
*/
private void addDeviationAsHijrah(Deviation entry) {
int startYear = entry.startYear;
int startMonth = entry.startMonth - 1 ;
int endYear = entry.endYear;
int endMonth = entry.endMonth - 1;
int offset = entry.offset;
if (startYear < 1) {
throw new IllegalArgumentException("startYear < 1");
}
if (endYear < 1) {
throw new IllegalArgumentException("endYear < 1");
}
if (startMonth < 0 || startMonth > 11) {
throw new IllegalArgumentException(
"startMonth < 0 || startMonth > 11");
}
if (endMonth < 0 || endMonth > 11) {
throw new IllegalArgumentException("endMonth < 0 || endMonth > 11");
}
if (endYear > 9999) {
throw new IllegalArgumentException("endYear > 9999");
}
if (endYear < startYear) {
throw new IllegalArgumentException("startYear > endYear");
}
if (endYear == startYear && endMonth < startMonth) {
throw new IllegalArgumentException(
"startYear == endYear && endMonth < startMonth");
}
// Adjusting start year.
boolean isStartYLeap = isLeapYear0(startYear);
// Adjusting the number of month.
int[] orgStartMonthNums = ADJUSTED_MONTH_DAYS.get(startYear);
if (orgStartMonthNums == null) {
if (isStartYLeap) {
orgStartMonthNums = Arrays.copyOf(LEAP_NUM_DAYS, LEAP_NUM_DAYS.length);
} else {
orgStartMonthNums = Arrays.copyOf(NUM_DAYS, NUM_DAYS.length);
}
}
int[] newStartMonthNums = new int[orgStartMonthNums.length];
for (int month = 0; month < 12; month++) {
if (month > startMonth) {
newStartMonthNums[month] = (orgStartMonthNums[month] - offset);
} else {
newStartMonthNums[month] = (orgStartMonthNums[month]);
}
}
ADJUSTED_MONTH_DAYS.put(startYear, newStartMonthNums);
// Adjusting the days of month.
int[] orgStartMonthLengths = ADJUSTED_MONTH_LENGTHS.get(startYear);
if (orgStartMonthLengths == null) {
if (isStartYLeap) {
orgStartMonthLengths = Arrays.copyOf(LEAP_MONTH_LENGTH, LEAP_MONTH_LENGTH.length);
} else {
orgStartMonthLengths = Arrays.copyOf(MONTH_LENGTH, MONTH_LENGTH.length);
}
}
int[] newStartMonthLengths = new int[orgStartMonthLengths.length];
for (int month = 0; month < 12; month++) {
if (month == startMonth) {
newStartMonthLengths[month] = orgStartMonthLengths[month] - offset;
} else {
newStartMonthLengths[month] = orgStartMonthLengths[month];
}
}
ADJUSTED_MONTH_LENGTHS.put(startYear, newStartMonthLengths);
if (startYear != endYear) {
// System.out.println("over year");
// Adjusting starting 30 year cycle.
int sCycleNumber = (startYear - 1) / 30;
int sYearInCycle = (startYear - 1) % 30; // 0-based.
int[] startCycles = ADJUSTED_CYCLE_YEARS.get(sCycleNumber);
if (startCycles == null) {
startCycles = Arrays.copyOf(CYCLEYEAR_START_DATE, CYCLEYEAR_START_DATE.length);
}
for (int j = sYearInCycle + 1; j < CYCLEYEAR_START_DATE.length; j++) {
startCycles[j] = startCycles[j] - offset;
}
// System.out.println(sCycleNumber + ":" + sYearInCycle);
ADJUSTED_CYCLE_YEARS.put(sCycleNumber, startCycles);
int sYearInMaxY = (startYear - 1) / 30;
int sEndInMaxY = (endYear - 1) / 30;
if (sYearInMaxY != sEndInMaxY) {
// System.out.println("over 30");
// Adjusting starting 30 * MAX_ADJUSTED_CYCLE year cycle.
// System.out.println(sYearInMaxY);
for (int j = sYearInMaxY + 1; j < ADJUSTED_CYCLES.length; j++) {
ADJUSTED_CYCLES[j] = ADJUSTED_CYCLES[j] - offset;
}
// Adjusting ending 30 * MAX_ADJUSTED_CYCLE year cycles.
for (int j = sEndInMaxY + 1; j < ADJUSTED_CYCLES.length; j++) {
ADJUSTED_CYCLES[j] = ADJUSTED_CYCLES[j] + offset;
}
}
// Adjusting ending 30 year cycle.
int eCycleNumber = (endYear - 1) / 30;
int sEndInCycle = (endYear - 1) % 30; // 0-based.
int[] endCycles = ADJUSTED_CYCLE_YEARS.get(eCycleNumber);
if (endCycles == null) {
endCycles = Arrays.copyOf(CYCLEYEAR_START_DATE, CYCLEYEAR_START_DATE.length);
}
for (int j = sEndInCycle + 1; j < CYCLEYEAR_START_DATE.length; j++) {
endCycles[j] = endCycles[j] + offset;
}
ADJUSTED_CYCLE_YEARS.put(eCycleNumber, endCycles);
}
// Adjusting ending year.
boolean isEndYLeap = isLeapYear0(endYear);
int[] orgEndMonthDays = ADJUSTED_MONTH_DAYS.get(endYear);
if (orgEndMonthDays == null) {
if (isEndYLeap) {
orgEndMonthDays = Arrays.copyOf(LEAP_NUM_DAYS, LEAP_NUM_DAYS.length);
} else {
orgEndMonthDays = Arrays.copyOf(NUM_DAYS, NUM_DAYS.length);
}
}
int[] newEndMonthDays = new int[orgEndMonthDays.length];
for (int month = 0; month < 12; month++) {
if (month > endMonth) {
newEndMonthDays[month] = orgEndMonthDays[month] + offset;
} else {
newEndMonthDays[month] = orgEndMonthDays[month];
}
}
ADJUSTED_MONTH_DAYS.put(endYear, newEndMonthDays);
// Adjusting the days of month.
int[] orgEndMonthLengths = ADJUSTED_MONTH_LENGTHS.get(endYear);
if (orgEndMonthLengths == null) {
if (isEndYLeap) {
orgEndMonthLengths = Arrays.copyOf(LEAP_MONTH_LENGTH, LEAP_MONTH_LENGTH.length);
} else {
orgEndMonthLengths = Arrays.copyOf(MONTH_LENGTH, MONTH_LENGTH.length);
}
}
int[] newEndMonthLengths = new int[orgEndMonthLengths.length];
for (int month = 0; month < 12; month++) {
if (month == endMonth) {
newEndMonthLengths[month] = orgEndMonthLengths[month] + offset;
} else {
newEndMonthLengths[month] = orgEndMonthLengths[month];
}
}
ADJUSTED_MONTH_LENGTHS.put(endYear, newEndMonthLengths);
int[] startMonthLengths = ADJUSTED_MONTH_LENGTHS.get(startYear);
int[] endMonthLengths = ADJUSTED_MONTH_LENGTHS.get(endYear);
int[] startMonthDays = ADJUSTED_MONTH_DAYS.get(startYear);
int[] endMonthDays = ADJUSTED_MONTH_DAYS.get(endYear);
int startMonthLength = startMonthLengths[startMonth];
int endMonthLength = endMonthLengths[endMonth];
int startMonthDay = startMonthDays[11] + startMonthLengths[11];
int endMonthDay = endMonthDays[11] + endMonthLengths[11];
int maxMonthLength = ADJUSTED_MAX_VALUES[POSITION_DAY_OF_MONTH];
int leastMaxMonthLength = ADJUSTED_LEAST_MAX_VALUES[POSITION_DAY_OF_MONTH];
if (maxMonthLength < startMonthLength) {
maxMonthLength = startMonthLength;
}
if (maxMonthLength < endMonthLength) {
maxMonthLength = endMonthLength;
}
ADJUSTED_MAX_VALUES[POSITION_DAY_OF_MONTH] = maxMonthLength;
if (leastMaxMonthLength > startMonthLength) {
leastMaxMonthLength = startMonthLength;
}
if (leastMaxMonthLength > endMonthLength) {
leastMaxMonthLength = endMonthLength;
}
ADJUSTED_LEAST_MAX_VALUES[POSITION_DAY_OF_MONTH] = leastMaxMonthLength;
int maxMonthDay = ADJUSTED_MAX_VALUES[POSITION_DAY_OF_YEAR];
int leastMaxMonthDay = ADJUSTED_LEAST_MAX_VALUES[POSITION_DAY_OF_YEAR];
if (maxMonthDay < startMonthDay) {
maxMonthDay = startMonthDay;
}
if (maxMonthDay < endMonthDay) {
maxMonthDay = endMonthDay;
}
ADJUSTED_MAX_VALUES[POSITION_DAY_OF_YEAR] = maxMonthDay;
if (leastMaxMonthDay > startMonthDay) {
leastMaxMonthDay = startMonthDay;
}
if (leastMaxMonthDay > endMonthDay) {
leastMaxMonthDay = endMonthDay;
}
ADJUSTED_LEAST_MAX_VALUES[POSITION_DAY_OF_YEAR] = leastMaxMonthDay;
}
/**
* Package private Entry for suppling deviations from the Reader.
* Each entry consists of a range using the Hijrah calendar,
* start year, month, end year, end month, and an offset.
* The offset is used to modify the length of the month +2, +1, -1, -2.
*/
static final class Deviation {
Deviation(int startYear, int startMonth, int endYear, int endMonth, int offset) {
this.startYear = startYear;
this.startMonth = startMonth;
this.endYear = endYear;
this.endMonth = endMonth;
this.offset = offset;
}
final int startYear;
final int startMonth;
final int endYear;
final int endMonth;
final int offset;
int getStartYear() {
return startYear;
}
int getStartMonth() {
return startMonth;
}
int getEndYear() {
return endYear;
}
int getEndMonth() {
return endMonth;
}
int getOffset() {
return offset;
}
@Override
public String toString() {
return String.format("[year: %4d, month: %2d, offset: %+d]", startYear, startMonth, offset);
}
}
}