/*

/**

public static final int BEFORE_MEIJI = 0;

/**

public static final int MEIJI = 1;

/**

public static final int TAISHO = 2;

/**

public static final int SHOWA = 3;

/**

public static final int HEISEI = 4;

private static final int EPOCH_OFFSET = 719163; // Fixed date of January 1, 1970 (Gregorian)

private static final int EPOCH_YEAR = 1970;

// Useful millisecond constants. Although ONE_DAY and ONE_WEEK can fit

// into ints, they must be longs in order to prevent arithmetic overflow

// when performing (bug 4173516).

private static final int ONE_SECOND = 1000;

private static final int ONE_MINUTE = 60*ONE_SECOND;

private static final int ONE_HOUR = 60*ONE_MINUTE;

private static final long ONE_DAY = 24*ONE_HOUR;

private static final long ONE_WEEK = 7*ONE_DAY;

// Reference to the sun.util.calendar.LocalGregorianCalendar instance (singleton).

private static final LocalGregorianCalendar jcal

= (LocalGregorianCalendar) CalendarSystem.forName("japanese");

// Gregorian calendar instance. This is required because era

// transition dates are given in Gregorian dates.

private static final Gregorian gcal = CalendarSystem.getGregorianCalendar();

// The Era instance representing "before Meiji".

private static final Era BEFORE_MEIJI_ERA = new Era("BeforeMeiji", "BM", Long.MIN_VALUE, false);

// Imperial eras. The sun.util.calendar.LocalGregorianCalendar

// doesn't have an Era representing before Meiji, which is

// inconvenient for a Calendar. So, era[0] is a reference to

// BEFORE_MEIJI_ERA.

private static final Era[] eras;

// Fixed date of the first date of each era.

private static final long[] sinceFixedDates;

/*

static final int MIN_VALUES[] = {

0, // ERA

-292275055, // YEAR

JANUARY, // MONTH

1, // WEEK_OF_YEAR

0, // WEEK_OF_MONTH

1, // DAY_OF_MONTH

1, // DAY_OF_YEAR

SUNDAY, // DAY_OF_WEEK

1, // DAY_OF_WEEK_IN_MONTH

AM, // AM_PM

0, // HOUR

0, // HOUR_OF_DAY

0, // MINUTE

0, // SECOND

0, // MILLISECOND

-13*ONE_HOUR, // ZONE_OFFSET (UNIX compatibility)

0 // DST_OFFSET

};

static final int LEAST_MAX_VALUES[] = {

0, // ERA (initialized later)

0, // YEAR (initialized later)

JANUARY, // MONTH (Showa 64 ended in January.)

0, // WEEK_OF_YEAR (Showa 1 has only 6 days which could be 0 weeks.)

4, // WEEK_OF_MONTH

28, // DAY_OF_MONTH

0, // DAY_OF_YEAR (initialized later)

SATURDAY, // DAY_OF_WEEK

4, // DAY_OF_WEEK_IN

PM, // AM_PM

11, // HOUR

23, // HOUR_OF_DAY

59, // MINUTE

59, // SECOND

999, // MILLISECOND

14*ONE_HOUR, // ZONE_OFFSET

20*ONE_MINUTE // DST_OFFSET (historical least maximum)

};

static final int MAX_VALUES[] = {

0, // ERA

292278994, // YEAR

DECEMBER, // MONTH

53, // WEEK_OF_YEAR

6, // WEEK_OF_MONTH

31, // DAY_OF_MONTH

366, // DAY_OF_YEAR

SATURDAY, // DAY_OF_WEEK

6, // DAY_OF_WEEK_IN

PM, // AM_PM

11, // HOUR

23, // HOUR_OF_DAY

59, // MINUTE

59, // SECOND

999, // MILLISECOND

14*ONE_HOUR, // ZONE_OFFSET

2*ONE_HOUR // DST_OFFSET (double summer time)

};

// Proclaim serialization compatibility with JDK 1.6

private static final long serialVersionUID = -3364572813905467929L;

static {

Era[] es = jcal.getEras();

int length = es.length + 1;

eras = new Era[length];

sinceFixedDates = new long[length];

// eras[BEFORE_MEIJI] and sinceFixedDate[BEFORE_MEIJI] are the

// same as Gregorian.

int index = BEFORE_MEIJI;

sinceFixedDates[index] = gcal.getFixedDate(BEFORE_MEIJI_ERA.getSinceDate());

eras[index++] = BEFORE_MEIJI_ERA;

for (Era e : es) {

CalendarDate d = e.getSinceDate();

sinceFixedDates[index] = gcal.getFixedDate(d);

eras[index++] = e;

}

LEAST_MAX_VALUES[ERA] = MAX_VALUES[ERA] = eras.length - 1;

// Calculate the least maximum year and least day of Year

// values. The following code assumes that there's at most one

// era transition in a Gregorian year.

int year = Integer.MAX_VALUE;

int dayOfYear = Integer.MAX_VALUE;

CalendarDate date = gcal.newCalendarDate(TimeZone.NO_TIMEZONE);

for (int i = 1; i < eras.length; i++) {

long fd = sinceFixedDates[i];

CalendarDate transitionDate = eras[i].getSinceDate();

date.setDate(transitionDate.getYear(), BaseCalendar.JANUARY, 1);

long fdd = gcal.getFixedDate(date);

if (fd != fdd) {

dayOfYear = Math.min((int)(fd - fdd) + 1, dayOfYear);

}

date.setDate(transitionDate.getYear(), BaseCalendar.DECEMBER, 31);

fdd = gcal.getFixedDate(date);

if (fd != fdd) {

dayOfYear = Math.min((int)(fdd - fd) + 1, dayOfYear);

}

LocalGregorianCalendar.Date lgd = getCalendarDate(fd - 1);

int y = lgd.getYear();

// Unless the first year starts from January 1, the actual

// max value could be one year short. For example, if it's

// Showa 63 January 8, 63 is the actual max value since

// Showa 64 January 8 doesn't exist.

if (!(lgd.getMonth() == BaseCalendar.JANUARY && lgd.getDayOfMonth() == 1)) {

y--;

}

year = Math.min(y, year);

}

LEAST_MAX_VALUES[YEAR] = year; // Max year could be smaller than this value.

LEAST_MAX_VALUES[DAY_OF_YEAR] = dayOfYear;

}

/**

private transient LocalGregorianCalendar.Date jdate;

/**

private transient int[] zoneOffsets;

/**

private transient int[] originalFields;

/**

JapaneseImperialCalendar(TimeZone zone, Locale aLocale) {

super(zone, aLocale);

jdate = jcal.newCalendarDate(zone);

setTimeInMillis(System.currentTimeMillis());

}

/**

JapaneseImperialCalendar(TimeZone zone, Locale aLocale, boolean flag) {

super(zone, aLocale);

jdate = jcal.newCalendarDate(zone);

}

/**

@Override

public String getCalendarType() {

return "japanese";

}

/**

public boolean equals(Object obj) {

return obj instanceof JapaneseImperialCalendar &&

super.equals(obj);

}

/**

public int hashCode() {

return super.hashCode() ^ jdate.hashCode();

}

/**

public void add(int field, int amount) {

// If amount == 0, do nothing even the given field is out of

// range. This is tested by JCK.

if (amount == 0) {

return; // Do nothing!

}

if (field < 0 || field >= ZONE_OFFSET) {

throw new IllegalArgumentException();

}

// Sync the time and calendar fields.

complete();

if (field == YEAR) {

LocalGregorianCalendar.Date d = (LocalGregorianCalendar.Date) jdate.clone();

d.addYear(amount);

pinDayOfMonth(d);

set(ERA, getEraIndex(d));

set(YEAR, d.getYear());

set(MONTH, d.getMonth() - 1);

set(DAY_OF_MONTH, d.getDayOfMonth());

} else if (field == MONTH) {

LocalGregorianCalendar.Date d = (LocalGregorianCalendar.Date) jdate.clone();

d.addMonth(amount);

pinDayOfMonth(d);

set(ERA, getEraIndex(d));

set(YEAR, d.getYear());

set(MONTH, d.getMonth() - 1);

set(DAY_OF_MONTH, d.getDayOfMonth());

} else if (field == ERA) {

int era = internalGet(ERA) + amount;

if (era < 0) {

era = 0;

} else if (era > eras.length - 1) {

era = eras.length - 1;

}

set(ERA, era);

} else {

long delta = amount;

long timeOfDay = 0;

switch (field) {

// Handle the time fields here. Convert the given

// amount to milliseconds and call setTimeInMillis.

case HOUR:

case HOUR_OF_DAY:

delta *= 60 * 60 * 1000; // hours to milliseconds

break;

case MINUTE:

delta *= 60 * 1000; // minutes to milliseconds

break;

case SECOND:

delta *= 1000; // seconds to milliseconds

break;

case MILLISECOND:

break;

// Handle week, day and AM_PM fields which involves

// time zone offset change adjustment. Convert the

// given amount to the number of days.

case WEEK_OF_YEAR:

case WEEK_OF_MONTH:

case DAY_OF_WEEK_IN_MONTH:

delta *= 7;

break;

case DAY_OF_MONTH: // synonym of DATE

case DAY_OF_YEAR:

case DAY_OF_WEEK:

break;

case AM_PM:

// Convert the amount to the number of days (delta)

// and +12 or -12 hours (timeOfDay).

delta = amount / 2;

timeOfDay = 12 * (amount % 2);

break;

}

// The time fields don't require time zone offset change

// adjustment.

if (field >= HOUR) {

setTimeInMillis(time + delta);

return;

}

// The rest of the fields (week, day or AM_PM fields)

// require time zone offset (both GMT and DST) change

// adjustment.

// Translate the current time to the fixed date and time

// of the day.

long fd = cachedFixedDate;

timeOfDay += internalGet(HOUR_OF_DAY);

timeOfDay *= 60;

timeOfDay += internalGet(MINUTE);

timeOfDay *= 60;

timeOfDay += internalGet(SECOND);

timeOfDay *= 1000;

timeOfDay += internalGet(MILLISECOND);

if (timeOfDay >= ONE_DAY) {

fd++;

timeOfDay -= ONE_DAY;

} else if (timeOfDay < 0) {

fd--;

timeOfDay += ONE_DAY;

}

fd += delta; // fd is the expected fixed date after the calculation

int zoneOffset = internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET);

setTimeInMillis((fd - EPOCH_OFFSET) * ONE_DAY + timeOfDay - zoneOffset);

zoneOffset -= internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET);

// If the time zone offset has changed, then adjust the difference.

if (zoneOffset != 0) {

setTimeInMillis(time + zoneOffset);

long fd2 = cachedFixedDate;

// If the adjustment has changed the date, then take

// the previous one.

if (fd2 != fd) {

setTimeInMillis(time - zoneOffset);

}

}

}

}

public void roll(int field, boolean up) {

roll(field, up ? +1 : -1);

}

/**

public void roll(int field, int amount) {

// If amount == 0, do nothing even the given field is out of

// range. This is tested by JCK.

if (amount == 0) {

return;

}

if (field < 0 || field >= ZONE_OFFSET) {

throw new IllegalArgumentException();

}

// Sync the time and calendar fields.

complete();

int min = getMinimum(field);

int max = getMaximum(field);

switch (field) {

case ERA:

case AM_PM:

case MINUTE:

case SECOND:

case MILLISECOND:

// These fields are handled simply, since they have fixed

// minima and maxima. Other fields are complicated, since

// the range within they must roll varies depending on the

// date, a time zone and the era transitions.

break;

case HOUR:

case HOUR_OF_DAY:

{

int unit = max + 1; // 12 or 24 hours

int h = internalGet(field);

int nh = (h + amount) % unit;

if (nh < 0) {

nh += unit;

}

time += ONE_HOUR * (nh - h);

// The day might have changed, which could happen if

// the daylight saving time transition brings it to

// the next day, although it's very unlikely. But we

// have to make sure not to change the larger fields.

CalendarDate d = jcal.getCalendarDate(time, getZone());

if (internalGet(DAY_OF_MONTH) != d.getDayOfMonth()) {

d.setEra(jdate.getEra());

d.setDate(internalGet(YEAR),

internalGet(MONTH) + 1,

internalGet(DAY_OF_MONTH));

if (field == HOUR) {

assert (internalGet(AM_PM) == PM);

d.addHours(+12); // restore PM

}

time = jcal.getTime(d);

}

int hourOfDay = d.getHours();

internalSet(field, hourOfDay % unit);

if (field == HOUR) {

internalSet(HOUR_OF_DAY, hourOfDay);

} else {

internalSet(AM_PM, hourOfDay / 12);

internalSet(HOUR, hourOfDay % 12);

}

// Time zone offset and/or daylight saving might have changed.

int zoneOffset = d.getZoneOffset();

int saving = d.getDaylightSaving();

internalSet(ZONE_OFFSET, zoneOffset - saving);

internalSet(DST_OFFSET, saving);

return;

}

case YEAR:

min = getActualMinimum(field);

max = getActualMaximum(field);

break;

case MONTH:

// Rolling the month involves both pinning the final value to [0, 11]

// and adjusting the DAY_OF_MONTH if necessary. We only adjust the

// DAY_OF_MONTH if, after updating the MONTH field, it is illegal.

// E.g., <jan31>.roll(MONTH, 1) -> <feb28> or <feb29>.

{

if (!isTransitionYear(jdate.getNormalizedYear())) {

int year = jdate.getYear();

if (year == getMaximum(YEAR)) {

CalendarDate jd = jcal.getCalendarDate(time, getZone());

CalendarDate d = jcal.getCalendarDate(Long.MAX_VALUE, getZone());

max = d.getMonth() - 1;

int n = getRolledValue(internalGet(field), amount, min, max);

if (n == max) {

// To avoid overflow, use an equivalent year.

jd.addYear(-400);

jd.setMonth(n + 1);

if (jd.getDayOfMonth() > d.getDayOfMonth()) {

jd.setDayOfMonth(d.getDayOfMonth());

jcal.normalize(jd);

}

if (jd.getDayOfMonth() == d.getDayOfMonth()

&& jd.getTimeOfDay() > d.getTimeOfDay()) {

jd.setMonth(n + 1);

jd.setDayOfMonth(d.getDayOfMonth() - 1);

jcal.normalize(jd);

// Month may have changed by the normalization.

n = jd.getMonth() - 1;

}

set(DAY_OF_MONTH, jd.getDayOfMonth());

}

set(MONTH, n);

} else if (year == getMinimum(YEAR)) {

CalendarDate jd = jcal.getCalendarDate(time, getZone());

CalendarDate d = jcal.getCalendarDate(Long.MIN_VALUE, getZone());

min = d.getMonth() - 1;

int n = getRolledValue(internalGet(field), amount, min, max);

if (n == min) {

// To avoid underflow, use an equivalent year.

jd.addYear(+400);

jd.setMonth(n + 1);

if (jd.getDayOfMonth() < d.getDayOfMonth()) {

jd.setDayOfMonth(d.getDayOfMonth());

jcal.normalize(jd);

}

if (jd.getDayOfMonth() == d.getDayOfMonth()

&& jd.getTimeOfDay() < d.getTimeOfDay()) {

jd.setMonth(n + 1);

jd.setDayOfMonth(d.getDayOfMonth() + 1);

jcal.normalize(jd);

// Month may have changed by the normalization.

n = jd.getMonth() - 1;

}

set(DAY_OF_MONTH, jd.getDayOfMonth());

}

set(MONTH, n);

} else {

int mon = (internalGet(MONTH) + amount) % 12;

if (mon < 0) {

mon += 12;

}

set(MONTH, mon);

// Keep the day of month in the range. We

// don't want to spill over into the next

// month; e.g., we don't want jan31 + 1 mo ->

// feb31 -> mar3.

int monthLen = monthLength(mon);

if (internalGet(DAY_OF_MONTH) > monthLen) {

set(DAY_OF_MONTH, monthLen);

}

}

} else {

int eraIndex = getEraIndex(jdate);

CalendarDate transition = null;

if (jdate.getYear() == 1) {

transition = eras[eraIndex].getSinceDate();

min = transition.getMonth() - 1;

} else {

if (eraIndex < eras.length - 1) {

transition = eras[eraIndex + 1].getSinceDate();

if (transition.getYear() == jdate.getNormalizedYear()) {

max = transition.getMonth() - 1;

if (transition.getDayOfMonth() == 1) {

max--;

}

}

}

}

if (min == max) {

// The year has only one month. No need to

// process further. (Showa Gan-nen (year 1)

// and the last year have only one month.)

return;

}

int n = getRolledValue(internalGet(field), amount, min, max);

set(MONTH, n);

if (n == min) {

if (!(transition.getMonth() == BaseCalendar.JANUARY

&& transition.getDayOfMonth() == 1)) {

if (jdate.getDayOfMonth() < transition.getDayOfMonth()) {

set(DAY_OF_MONTH, transition.getDayOfMonth());

}

}

} else if (n == max && (transition.getMonth() - 1 == n)) {

int dom = transition.getDayOfMonth();

if (jdate.getDayOfMonth() >= dom) {

set(DAY_OF_MONTH, dom - 1);

}

}

}

return;

}

case WEEK_OF_YEAR:

{

int y = jdate.getNormalizedYear();

max = getActualMaximum(WEEK_OF_YEAR);

set(DAY_OF_WEEK, internalGet(DAY_OF_WEEK)); // update stamp[field]

int woy = internalGet(WEEK_OF_YEAR);

int value = woy + amount;

if (!isTransitionYear(jdate.getNormalizedYear())) {

int year = jdate.getYear();

if (year == getMaximum(YEAR)) {

max = getActualMaximum(WEEK_OF_YEAR);

} else if (year == getMinimum(YEAR)) {

min = getActualMinimum(WEEK_OF_YEAR);

max = getActualMaximum(WEEK_OF_YEAR);

if (value > min && value < max) {

set(WEEK_OF_YEAR, value);

return;

}

}

// If the new value is in between min and max

// (exclusive), then we can use the value.

if (value > min && value < max) {

set(WEEK_OF_YEAR, value);

return;

}

long fd = cachedFixedDate;

// Make sure that the min week has the current DAY_OF_WEEK

long day1 = fd - (7 * (woy - min));

if (year != getMinimum(YEAR)) {

if (gcal.getYearFromFixedDate(day1) != y) {

min++;

}

} else {

CalendarDate d = jcal.getCalendarDate(Long.MIN_VALUE, getZone());

if (day1 < jcal.getFixedDate(d)) {

min++;

}

}

// Make sure the same thing for the max week

fd += 7 * (max - internalGet(WEEK_OF_YEAR));

if (gcal.getYearFromFixedDate(fd) != y) {

max--;

}

break;

}

// Handle transition here.

long fd = cachedFixedDate;

long day1 = fd - (7 * (woy - min));

// Make sure that the min week has the current DAY_OF_WEEK

LocalGregorianCalendar.Date d = getCalendarDate(day1);

if (!(d.getEra() == jdate.getEra() && d.getYear() == jdate.getYear())) {

min++;

}

// Make sure the same thing for the max week

fd += 7 * (max - woy);

jcal.getCalendarDateFromFixedDate(d, fd);

if (!(d.getEra() == jdate.getEra() && d.getYear() == jdate.getYear())) {

max--;

}

// value: the new WEEK_OF_YEAR which must be converted

// to month and day of month.

value = getRolledValue(woy, amount, min, max) - 1;

d = getCalendarDate(day1 + value * 7);

set(MONTH, d.getMonth() - 1);

set(DAY_OF_MONTH, d.getDayOfMonth());

return;

}

case WEEK_OF_MONTH:

{

boolean isTransitionYear = isTransitionYear(jdate.getNormalizedYear());

// dow: relative day of week from the first day of week

int dow = internalGet(DAY_OF_WEEK) - getFirstDayOfWeek();

if (dow < 0) {

dow += 7;

}

long fd = cachedFixedDate;

long month1; // fixed date of the first day (usually 1) of the month

int monthLength; // actual month length

if (isTransitionYear) {

month1 = getFixedDateMonth1(jdate, fd);

monthLength = actualMonthLength();

} else {

month1 = fd - internalGet(DAY_OF_MONTH) + 1;

monthLength = jcal.getMonthLength(jdate);

}

// the first day of week of the month.

long monthDay1st = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(month1 + 6,

getFirstDayOfWeek());

// if the week has enough days to form a week, the

// week starts from the previous month.

if ((int)(monthDay1st - month1) >= getMinimalDaysInFirstWeek()) {

monthDay1st -= 7;

}

max = getActualMaximum(field);

// value: the new WEEK_OF_MONTH value

int value = getRolledValue(internalGet(field), amount, 1, max) - 1;

// nfd: fixed date of the rolled date

long nfd = monthDay1st + value * 7 + dow;

// Unlike WEEK_OF_YEAR, we need to change day of week if the

// nfd is out of the month.

if (nfd < month1) {

nfd = month1;

} else if (nfd >= (month1 + monthLength)) {

nfd = month1 + monthLength - 1;

}

set(DAY_OF_MONTH, (int)(nfd - month1) + 1);

return;

}

case DAY_OF_MONTH:

{

if (!isTransitionYear(jdate.getNormalizedYear())) {

max = jcal.getMonthLength(jdate);

break;

}

// TODO: Need to change the spec to be usable DAY_OF_MONTH rolling...

// Transition handling. We can't change year and era

// values here due to the Calendar roll spec!

long month1 = getFixedDateMonth1(jdate, cachedFixedDate);

// It may not be a regular month. Convert the date and range to

// the relative values, perform the roll, and

// convert the result back to the rolled date.

int value = getRolledValue((int)(cachedFixedDate - month1), amount,

0, actualMonthLength() - 1);

LocalGregorianCalendar.Date d = getCalendarDate(month1 + value);

assert getEraIndex(d) == internalGetEra()

&& d.getYear() == internalGet(YEAR) && d.getMonth()-1 == internalGet(MONTH);

set(DAY_OF_MONTH, d.getDayOfMonth());

return;

}

case DAY_OF_YEAR:

{

max = getActualMaximum(field);

if (!isTransitionYear(jdate.getNormalizedYear())) {

break;

}

// Handle transition. We can't change year and era values

// here due to the Calendar roll spec.

int value = getRolledValue(internalGet(DAY_OF_YEAR), amount, min, max);

long jan0 = cachedFixedDate - internalGet(DAY_OF_YEAR);

LocalGregorianCalendar.Date d = getCalendarDate(jan0 + value);

assert getEraIndex(d) == internalGetEra() && d.getYear() == internalGet(YEAR);

set(MONTH, d.getMonth() - 1);

set(DAY_OF_MONTH, d.getDayOfMonth());

return;

}

case DAY_OF_WEEK:

{

int normalizedYear = jdate.getNormalizedYear();

if (!isTransitionYear(normalizedYear) && !isTransitionYear(normalizedYear - 1)) {

// If the week of year is in the same year, we can

// just change DAY_OF_WEEK.

int weekOfYear = internalGet(WEEK_OF_YEAR);

if (weekOfYear > 1 && weekOfYear < 52) {

set(WEEK_OF_YEAR, internalGet(WEEK_OF_YEAR));

max = SATURDAY;

break;

}

}

// We need to handle it in a different way around year

// boundaries and in the transition year. Note that

// changing era and year values violates the roll

// rule: not changing larger calendar fields...

amount %= 7;

if (amount == 0) {

return;

}

long fd = cachedFixedDate;

long dowFirst = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(fd, getFirstDayOfWeek());

fd += amount;

if (fd < dowFirst) {

fd += 7;

} else if (fd >= dowFirst + 7) {

fd -= 7;

}

LocalGregorianCalendar.Date d = getCalendarDate(fd);

set(ERA, getEraIndex(d));

set(d.getYear(), d.getMonth() - 1, d.getDayOfMonth());

return;

}

case DAY_OF_WEEK_IN_MONTH:

{

min = 1; // after having normalized, min should be 1.

if (!isTransitionYear(jdate.getNormalizedYear())) {

int dom = internalGet(DAY_OF_MONTH);

int monthLength = jcal.getMonthLength(jdate);

int lastDays = monthLength % 7;

max = monthLength / 7;

int x = (dom - 1) % 7;

if (x < lastDays) {

max++;

}

set(DAY_OF_WEEK, internalGet(DAY_OF_WEEK));

break;

}

// Transition year handling.

long fd = cachedFixedDate;

long month1 = getFixedDateMonth1(jdate, fd);

int monthLength = actualMonthLength();

int lastDays = monthLength % 7;

max = monthLength / 7;

int x = (int)(fd - month1) % 7;

if (x < lastDays) {

max++;

}

int value = getRolledValue(internalGet(field), amount, min, max) - 1;

fd = month1 + value * 7 + x;

LocalGregorianCalendar.Date d = getCalendarDate(fd);

set(DAY_OF_MONTH, d.getDayOfMonth());

return;

}

}

set(field, getRolledValue(internalGet(field), amount, min, max));

}

@Override

public String getDisplayName(int field, int style, Locale locale) {

if (!checkDisplayNameParams(field, style, SHORT, NARROW_FORMAT, locale,

ERA_MASK|YEAR_MASK|MONTH_MASK|DAY_OF_WEEK_MASK|AM_PM_MASK)) {

return null;

}

int fieldValue = get(field);

// "GanNen" is supported only in the LONG style.

if (field == YEAR

&& (getBaseStyle(style) != LONG || fieldValue != 1 || get(ERA) == 0)) {

return null;

}

String name = CalendarDataUtility.retrieveFieldValueName(getCalendarType(), field,

fieldValue, style, locale);

// If the ERA value is null, then

// try to get its name or abbreviation from the Era instance.

if (name == null && field == ERA && fieldValue < eras.length) {

Era era = eras[fieldValue];

name = (style == SHORT) ? era.getAbbreviation() : era.getName();

}

return name;

}

@Override

public Map<String,Integer> getDisplayNames(int field, int style, Locale locale) {

if (!checkDisplayNameParams(field, style, ALL_STYLES, NARROW_FORMAT, locale,

ERA_MASK|YEAR_MASK|MONTH_MASK|DAY_OF_WEEK_MASK|AM_PM_MASK)) {

return null;

}

Map<String, Integer> names;

names = CalendarDataUtility.retrieveFieldValueNames(getCalendarType(), field, style, locale);

// If strings[] has fewer than eras[], get more names from eras[].

if (names != null) {

if (field == ERA) {