dayOfWeek.
*
* @param dayOfWeek The day of the week on which this holiday occurs.
* The following values are legal: TimeZoneRule is an abstract class representing a rule for time zone.
* TimeZoneRule has a set of time zone attributes, such as zone name,
* raw offset (UTC offset for standard time) and daylight saving time offset.
*
* @see com.ibm.icu.util.TimeZoneTransition
* @see com.ibm.icu.util.RuleBasedTimeZone
*
* @stable ICU 3.8
*/
public abstract class TimeZoneRule implements Serializable {
private static final long serialVersionUID = 6374143828553768100L;
private final String name;
private final int rawOffset;
private final int dstSavings;
/**
* Constructs a TimeZoneRule with the name, the GMT offset of its
* standard time and the amount of daylight saving offset adjustment.
*
* @param name The time zone name.
* @param rawOffset The UTC offset of its standard time in milliseconds.
* @param dstSavings The amount of daylight saving offset adjustment in milliseconds.
* If this is a rule for standard time, the value of this argument is 0.
*
* @stable ICU 3.8
*/
public TimeZoneRule(String name, int rawOffset, int dstSavings) {
this.name = name;
this.rawOffset = rawOffset;
this.dstSavings = dstSavings;
}
/**
* Gets the name of this time zone.
*
* @return The name of this time zone.
*
* @stable ICU 3.8
*/
public String getName() {
return name;
}
/**
* Gets the standard time offset.
*
* @return The standard time offset from UTC in milliseconds.
*
* @stable ICU 3.8
*/
public int getRawOffset() {
return rawOffset;
}
/**
* Gets the amount of daylight saving delta time from the standard time.
*
* @return The amount of daylight saving offset used by this rule
* in milliseconds.
*
* @stable ICU 3.8
*/
public int getDSTSavings() {
return dstSavings;
}
/**
* Returns if this rule represents the same rule and offsets as another.
* When two TimeZoneRule objects differ only its names, this method returns
* true.
*
* @param other The TimeZoneRule object to be compared with.
* @return true if the other TimeZoneRule is the same as this one.
*
* @stable ICU 3.8
*/
public boolean isEquivalentTo(TimeZoneRule other) {
if (rawOffset == other.rawOffset && dstSavings == other.dstSavings) {
return true;
}
return false;
}
/**
* Gets the very first time when this rule takes effect.
*
* @param prevRawOffset The standard time offset from UTC before this rule
* takes effect in milliseconds.
* @param prevDSTSavings The amount of daylight saving offset from the
* standard time.
*
* @return The very first time when this rule takes effect.
*
* @stable ICU 3.8
*/
public abstract Date getFirstStart(int prevRawOffset, int prevDSTSavings);
/**
* Gets the final time when this rule takes effect.
*
* @param prevRawOffset The standard time offset from UTC before this rule
* takes effect in milliseconds.
* @param prevDSTSavings The amount of daylight saving offset from the
* standard time.
*
* @return The very last time when this rule takes effect,
* or null if this rule is applied for future dates infinitely.
*
* @stable ICU 3.8
*/
public abstract Date getFinalStart(int prevRawOffset, int prevDSTSavings);
/**
* Gets the first time when this rule takes effect after the specified time.
*
* @param base The first time after this time is returned.
* @param prevRawOffset The standard time offset from UTC before this rule
* takes effect in milliseconds.
* @param prevDSTSavings The amount of daylight saving offset from the
* standard time.
* @param inclusive Whether the base time is inclusive or not.
*
* @return The first time when this rule takes effect after the specified time,
* or null when this rule never takes effect after the specified time.
*
* @stable ICU 3.8
*/
public abstract Date getNextStart(long base, int prevRawOffset, int prevDSTSavings, boolean inclusive);
/**
* Gets the most recent time when this rule takes effect before the specified time.
*
* @param base The most recent time when this rule takes effect before
* this time is returned.
* @param prevRawOffset The standard time offset from UTC before this rule
* takes effect in milliseconds.
* @param prevDSTSavings The amount of daylight saving offset from the
* standard time.
* @param inclusive Whether the base time is inclusive or not.
*
* @return The most recent time when this rule takes effect before the specified time,
* or null when this rule never takes effect before the specified time.
*
* @stable ICU 3.8
*/
public abstract Date getPreviousStart(long base, int prevRawOffset, int prevDSTSavings, boolean inclusive);
/**
* Returns if this TimeZoneRule has one or more start times.
*
* @return true if this String representation of this TimeZoneRule object.
* This method is used for debugging purpose only. The string representation can be changed
* in future version of ICU without any notice.
* @stable ICU 3.8
*/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("name=" + name);
buf.append(", stdOffset=" + rawOffset);
buf.append(", dstSaving=" + dstSavings);
return buf.toString();
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/VTimeZone.java 0000644 0001750 0001750 00000231506 11017153155 021233 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2007-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.MissingResourceException;
import com.ibm.icu.impl.Grego;
import com.ibm.icu.util.DateTimeRule;
/**
* VTimeZone is a class implementing RFC2445 VTIMEZONE. You can create a
* VTimeZone instance from a time zone ID supported by TimeZone.
* With the VTimeZone instance created from the ID, you can write out the rule
* in RFC2445 VTIMEZONE format. Also, you can create a VTimeZone instance
* from RFC2445 VTIMEZONE data stream, which allows you to calculate time
* zone offset by the rules defined by the data.VTimeZone instance by the time zone ID.
*
* @param tzid The time zone ID, such as America/New_York
* @return A VTimeZone initialized by the time zone ID, or null
* when the ID is unknown.
*
* @stable ICU 3.8
*/
public static VTimeZone create(String tzid) {
VTimeZone vtz = new VTimeZone();
vtz.tz = (BasicTimeZone)TimeZone.getTimeZone(tzid, TimeZone.TIMEZONE_ICU);
vtz.olsonzid = vtz.tz.getID();
vtz.setID(tzid);
return vtz;
}
/**
* Create a VTimeZone instance by RFC2445 VTIMEZONE data.
*
* @param reader The Reader for VTIMEZONE data input stream
* @return A VTimeZone initialized by the VTIMEZONE data or
* null if failed to load the rule from the VTIMEZONE data.
*
* @stable ICU 3.8
*/
public static VTimeZone create(Reader reader) {
VTimeZone vtz = new VTimeZone();
if (vtz.load(reader)) {
return vtz;
}
return null;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public int getOffset(int era, int year, int month, int day, int dayOfWeek,
int milliseconds) {
return tz.getOffset(era, year, month, day, dayOfWeek, milliseconds);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public void getOffset(long date, boolean local, int[] offsets) {
tz.getOffset(date, local, offsets);
}
/**
* {@inheritDoc}
* @internal
* @deprecated This API is ICU internal only.
*/
public void getOffsetFromLocal(long date,
int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets) {
tz.getOffsetFromLocal(date, nonExistingTimeOpt, duplicatedTimeOpt, offsets);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public int getRawOffset() {
return tz.getRawOffset();
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public boolean inDaylightTime(Date date) {
return tz.inDaylightTime(date);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public void setRawOffset(int offsetMillis) {
tz.setRawOffset(offsetMillis);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public boolean useDaylightTime() {
return tz.useDaylightTime();
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public boolean hasSameRules(TimeZone other) {
return tz.hasSameRules(other);
}
/**
* Gets the RFC2445 TZURL property value. When a VTimeZone instance was created from
* VTIMEZONE data, the value is set by the TZURL property value in the data. Otherwise,
* the initial value is null.
*
* @return The RFC2445 TZURL property value
*
* @stable ICU 3.8
*/
public String getTZURL() {
return tzurl;
}
/**
* Sets the RFC2445 TZURL property value.
*
* @param url The TZURL property value.
*
* @stable ICU 3.8
*/
public void setTZURL(String url) {
tzurl = url;
}
/**
* Gets the RFC2445 LAST-MODIFIED property value. When a VTimeZone instance was created
* from VTIMEZONE data, the value is set by the LAST-MODIFIED property value in the data.
* Otherwise, the initial value is null.
*
* @return The Date represents the RFC2445 LAST-MODIFIED date.
*
* @stable ICU 3.8
*/
public Date getLastModified() {
return lastmod;
}
/**
* Sets the date used for RFC2445 LAST-MODIFIED property value.
*
* @param date The Date object represents the date for RFC2445 LAST-MODIFIED property value.
*
* @stable ICU 3.8
*/
public void setLastModified(Date date) {
lastmod = date;
}
/**
* Writes RFC2445 VTIMEZONE data for this time zone
*
* @param writer A Writer used for the output
* @throws IOException
*
* @stable ICU 3.8
*/
public void write(Writer writer) throws IOException {
BufferedWriter bw = new BufferedWriter(writer);
if (vtzlines != null) {
Iterator it = vtzlines.iterator();
while (it.hasNext()) {
String line = (String)it.next();
if (line.startsWith(ICAL_TZURL + COLON)) {
if (tzurl != null) {
bw.write(ICAL_TZURL);
bw.write(COLON);
bw.write(tzurl);
bw.write(NEWLINE);
}
} else if (line.startsWith(ICAL_LASTMOD + COLON)) {
if (lastmod != null) {
bw.write(ICAL_LASTMOD);
bw.write(COLON);
bw.write(getUTCDateTimeString(lastmod.getTime()));
bw.write(NEWLINE);
}
} else {
bw.write(line);
bw.write(NEWLINE);
}
}
bw.flush();
} else {
String[] customProperties = null;
if (olsonzid != null && ICU_TZVERSION != null) {
customProperties = new String[1];
customProperties[0] = ICU_TZINFO_PROP + COLON + olsonzid + "[" + ICU_TZVERSION + "]";
}
writeZone(writer, tz, customProperties);
}
}
/**
* Writes RFC2445 VTIMEZONE data applicable for dates after
* the specified start time.
*
* @param writer The Writer used for the output
* @param start The start time
*
* @throws IOException
*
* @stable ICU 3.8
*/
public void write(Writer writer, long start) throws IOException {
// Extract rules applicable to dates after the start time
TimeZoneRule[] rules = tz.getTimeZoneRules(start);
// Create a RuleBasedTimeZone with the subset rule
RuleBasedTimeZone rbtz = new RuleBasedTimeZone(tz.getID(), (InitialTimeZoneRule)rules[0]);
for (int i = 1; i < rules.length; i++) {
rbtz.addTransitionRule(rules[i]);
}
String[] customProperties = null;
if (olsonzid != null && ICU_TZVERSION != null) {
customProperties = new String[1];
customProperties[0] = ICU_TZINFO_PROP + COLON + olsonzid + "[" + ICU_TZVERSION +
"/Partial@" + start + "]";
}
writeZone(writer, rbtz, customProperties);
}
/**
* Writes RFC2445 VTIMEZONE data applicable near the specified date.
* Some common iCalendar implementations can only handle a single time
* zone property or a pair of standard and daylight time properties using
* BYDAY rule with day of week (such as BYDAY=1SUN). This method produce
* the VTIMEZONE data which can be handled these implementations. The rules
* produced by this method can be used only for calculating time zone offset
* around the specified date.
*
* @param writer The Writer used for the output
* @param time The date
*
* @throws IOException
*
* @stable ICU 3.8
*/
public void writeSimple(Writer writer, long time) throws IOException {
// Extract simple rules
TimeZoneRule[] rules = tz.getSimpleTimeZoneRulesNear(time);
// Create a RuleBasedTimeZone with the subset rule
RuleBasedTimeZone rbtz = new RuleBasedTimeZone(tz.getID(), (InitialTimeZoneRule)rules[0]);
for (int i = 1; i < rules.length; i++) {
rbtz.addTransitionRule(rules[i]);
}
String[] customProperties = null;
if (olsonzid != null && ICU_TZVERSION != null) {
customProperties = new String[1];
customProperties[0] = ICU_TZINFO_PROP + COLON + olsonzid + "[" + ICU_TZVERSION +
"/Simple@" + time + "]";
}
writeZone(writer, rbtz, customProperties);
}
// BasicTimeZone methods
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public TimeZoneTransition getNextTransition(long base, boolean inclusive) {
return tz.getNextTransition(base, inclusive);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public TimeZoneTransition getPreviousTransition(long base, boolean inclusive) {
return tz.getPreviousTransition(base, inclusive);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public boolean hasEquivalentTransitions(TimeZone other, long start, long end) {
return tz.hasEquivalentTransitions(other, start, end);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public TimeZoneRule[] getTimeZoneRules() {
return tz.getTimeZoneRules();
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public TimeZoneRule[] getTimeZoneRules(long start) {
return tz.getTimeZoneRules(start);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public Object clone() {
VTimeZone other = (VTimeZone)super.clone();
other.tz = (BasicTimeZone)tz.clone();
return other;
}
// private stuff ------------------------------------------------------
private BasicTimeZone tz;
private List vtzlines;
private String olsonzid = null;
private String tzurl = null;
private Date lastmod = null;
private static String ICU_TZVERSION;
private static final String ICU_TZINFO_PROP = "X-TZINFO";
// Default DST savings
private static final int DEF_DSTSAVINGS = 60*60*1000; // 1 hour
// Default time start
private static final long DEF_TZSTARTTIME = 0;
// minimum/max
private static final long MIN_TIME = Long.MIN_VALUE;
private static final long MAX_TIME = Long.MAX_VALUE;
// Symbol characters used by RFC2445 VTIMEZONE
private static final String COLON = ":";
private static final String SEMICOLON = ";";
private static final String EQUALS_SIGN = "=";
private static final String COMMA = ",";
private static final String NEWLINE = "\r\n"; // CRLF
// RFC2445 VTIMEZONE tokens
private static final String ICAL_BEGIN_VTIMEZONE = "BEGIN:VTIMEZONE";
private static final String ICAL_END_VTIMEZONE = "END:VTIMEZONE";
private static final String ICAL_BEGIN = "BEGIN";
private static final String ICAL_END = "END";
private static final String ICAL_VTIMEZONE = "VTIMEZONE";
private static final String ICAL_TZID = "TZID";
private static final String ICAL_STANDARD = "STANDARD";
private static final String ICAL_DAYLIGHT = "DAYLIGHT";
private static final String ICAL_DTSTART = "DTSTART";
private static final String ICAL_TZOFFSETFROM = "TZOFFSETFROM";
private static final String ICAL_TZOFFSETTO = "TZOFFSETTO";
private static final String ICAL_RDATE = "RDATE";
private static final String ICAL_RRULE = "RRULE";
private static final String ICAL_TZNAME = "TZNAME";
private static final String ICAL_TZURL = "TZURL";
private static final String ICAL_LASTMOD = "LAST-MODIFIED";
private static final String ICAL_FREQ = "FREQ";
private static final String ICAL_UNTIL = "UNTIL";
private static final String ICAL_YEARLY = "YEARLY";
private static final String ICAL_BYMONTH = "BYMONTH";
private static final String ICAL_BYDAY = "BYDAY";
private static final String ICAL_BYMONTHDAY = "BYMONTHDAY";
private static final String[] ICAL_DOW_NAMES =
{"SU", "MO", "TU", "WE", "TH", "FR", "SA"};
// Month length in regular year
private static final int[] MONTHLENGTH = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
static {
// Initialize ICU_TZVERSION
try {
UResourceBundle tzbundle = UResourceBundle.getBundleInstance(
"com/ibm/icu/impl/data/icudt" + VersionInfo.ICU_DATA_VERSION, "zoneinfo");
ICU_TZVERSION = tzbundle.getString("TZVersion");
} catch (MissingResourceException e) {
///CLOVER:OFF
ICU_TZVERSION = null;
///CLOVER:ON
}
}
/* Hide the constructor */
private VTimeZone() {
}
/*
* Read the input stream to locate the VTIMEZONE block and
* parse the contents to initialize this VTimeZone object.
* The reader skips other RFC2445 message headers. After
* the parse is completed, the reader points at the beginning
* of the header field just after the end of VTIMEZONE block.
* When VTIMEZONE block is found and this object is successfully
* initialized by the rules described in the data, this method
* returns true. Otherwise, returns false.
*/
private boolean load(Reader reader) {
// Read VTIMEZONE block into string array
try {
vtzlines = new LinkedList();
boolean eol = false;
boolean start = false;
boolean success = false;
StringBuffer line = new StringBuffer();
while (true) {
int ch = reader.read();
if (ch == -1) {
// end of file
if (start && line.toString().startsWith(ICAL_END_VTIMEZONE)) {
vtzlines.add(line.toString());
success = true;
}
break;
}
if (ch == 0x0D) {
// CR, must be followed by LF by the definition in RFC2445
continue;
}
if (eol) {
if (ch != 0x09 && ch != 0x20) {
// NOT followed by TAB/SP -> new line
if (start) {
if (line.length() > 0) {
vtzlines.add(line.toString());
}
}
line.setLength(0);
if (ch != 0x0A) {
line.append((char)ch);
}
}
eol = false;
} else {
if (ch == 0x0A) {
// LF
eol = true;
if (start) {
if (line.toString().startsWith(ICAL_END_VTIMEZONE)) {
vtzlines.add(line.toString());
success = true;
break;
}
} else {
if (line.toString().startsWith(ICAL_BEGIN_VTIMEZONE)) {
vtzlines.add(line.toString());
line.setLength(0);
start = true;
eol = false;
}
}
} else {
line.append((char)ch);
}
}
}
if (!success) {
return false;
}
} catch (IOException ioe) {
///CLOVER:OFF
return false;
///CLOVER:ON
}
return parse();
}
// parser state
private static final int INI = 0; // Initial state
private static final int VTZ = 1; // In VTIMEZONE
private static final int TZI = 2; // In STANDARD or DAYLIGHT
private static final int ERR = 3; // Error state
/*
* Parse VTIMEZONE data and create a RuleBasedTimeZone
*/
private boolean parse() {
///CLOVER:OFF
if (vtzlines == null || vtzlines.size() == 0) {
return false;
}
///CLOVER:ON
// timezone ID
String tzid = null;
int state = INI;
boolean dst = false; // current zone type
String from = null; // current zone from offset
String to = null; // current zone offset
String tzname = null; // current zone name
String dtstart = null; // current zone starts
boolean isRRULE = false;// true if the rule is described by RRULE
List dates = null; // list of RDATE or RRULE strings
List rules = new LinkedList(); // rule list
int initialRawOffset = 0; // initial offset
int initialDSTSavings = 0; // initial offset
long firstStart = MAX_TIME; // the earliest rule start time
Iterator it = vtzlines.iterator();
while (it.hasNext()) {
String line = (String)it.next();
int valueSep = line.indexOf(COLON);
if (valueSep < 0) {
continue;
}
String name = line.substring(0, valueSep);
String value = line.substring(valueSep + 1);
switch (state) {
case INI:
if (name.equals(ICAL_BEGIN) && value.equals(ICAL_VTIMEZONE)) {
state = VTZ;
}
break;
case VTZ:
if (name.equals(ICAL_TZID)) {
tzid = value;
} else if (name.equals(ICAL_TZURL)) {
tzurl = value;
} else if (name.equals(ICAL_LASTMOD)) {
// Always in 'Z' format, so the offset argument for the parse method
// can be any value.
lastmod = new Date(parseDateTimeString(value, 0));
} else if (name.equals(ICAL_BEGIN)) {
boolean isDST = value.equals(ICAL_DAYLIGHT);
if (value.equals(ICAL_STANDARD) || isDST) {
// tzid must be ready at this point
if (tzid == null) {
state = ERR;
break;
}
// initialize current zone properties
dates = null;
isRRULE = false;
from = null;
to = null;
tzname = null;
dst = isDST;
state = TZI;
} else {
// BEGIN property other than STANDARD/DAYLIGHT
// must not be there.
state = ERR;
break;
}
} else if (name.equals(ICAL_END) /* && value.equals(ICAL_VTIMEZONE) */) {
break;
}
break;
case TZI:
if (name.equals(ICAL_DTSTART)) {
dtstart = value;
} else if (name.equals(ICAL_TZNAME)) {
tzname = value;
} else if (name.equals(ICAL_TZOFFSETFROM)) {
from = value;
} else if (name.equals(ICAL_TZOFFSETTO)) {
to = value;
} else if (name.equals(ICAL_RDATE)) {
// RDATE mixed with RRULE is not supported
if (isRRULE) {
state = ERR;
break;
}
if (dates == null) {
dates = new LinkedList();
}
// RDATE value may contain multiple date delimited
// by comma
StringTokenizer st = new StringTokenizer(value, COMMA);
while (st.hasMoreTokens()) {
String date = st.nextToken();
dates.add(date);
}
} else if (name.equals(ICAL_RRULE)) {
// RRULE mixed with RDATE is not supported
if (!isRRULE && dates != null) {
state = ERR;
break;
} else if (dates == null) {
dates = new LinkedList();
}
isRRULE = true;
dates.add(value);
} else if (name.equals(ICAL_END)) {
// Mandatory properties
if (dtstart == null || from == null || to == null) {
state = ERR;
break;
}
// if tzname is not available, create one from tzid
if (tzname == null) {
tzname = getDefaultTZName(tzid, dst);
}
// create a time zone rule
TimeZoneRule rule = null;
int fromOffset = 0;
int toOffset = 0;
int rawOffset = 0;
int dstSavings = 0;
long start = 0;
try {
// Parse TZOFFSETFROM/TZOFFSETTO
fromOffset = offsetStrToMillis(from);
toOffset = offsetStrToMillis(to);
if (dst) {
// If daylight, use the previous offset as rawoffset if positive
if (toOffset - fromOffset > 0) {
rawOffset = fromOffset;
dstSavings = toOffset - fromOffset;
} else {
// This is rare case.. just use 1 hour DST savings
rawOffset = toOffset - DEF_DSTSAVINGS;
dstSavings = DEF_DSTSAVINGS;
}
} else {
rawOffset = toOffset;
dstSavings = 0;
}
// start time
start = parseDateTimeString(dtstart, fromOffset);
// Create the rule
Date actualStart = null;
if (isRRULE) {
rule = createRuleByRRULE(tzname, rawOffset, dstSavings, start, dates, fromOffset);
} else {
rule = createRuleByRDATE(tzname, rawOffset, dstSavings, start, dates, fromOffset);
}
if (rule != null) {
actualStart = rule.getFirstStart(fromOffset, 0);
if (actualStart.getTime() < firstStart) {
// save from offset information for the earliest rule
firstStart = actualStart.getTime();
// If this is STD, assume the time before this transtion
// is DST when the difference is 1 hour. This might not be
// accurate, but VTIMEZONE data does not have such info.
if (dstSavings > 0) {
initialRawOffset = fromOffset;
initialDSTSavings = 0;
} else {
if (fromOffset - toOffset == DEF_DSTSAVINGS) {
initialRawOffset = fromOffset - DEF_DSTSAVINGS;
initialDSTSavings = DEF_DSTSAVINGS;
} else {
initialRawOffset = fromOffset;
initialDSTSavings = 0;
}
}
}
}
} catch (IllegalArgumentException iae) {
// bad format - rule == null..
}
if (rule == null) {
state = ERR;
break;
}
rules.add(rule);
state = VTZ;
}
break;
}
if (state == ERR) {
vtzlines = null;
return false;
}
}
// Must have at least one rule
if (rules.size() == 0) {
return false;
}
// Create a initial rule
InitialTimeZoneRule initialRule = new InitialTimeZoneRule(getDefaultTZName(tzid, false),
initialRawOffset, initialDSTSavings);
// Finally, create the RuleBasedTimeZone
RuleBasedTimeZone rbtz = new RuleBasedTimeZone(tzid, initialRule);
int finalRuleIdx = -1;
int finalRuleCount = 0;
for (int i = 0; i < rules.size(); i++) {
TimeZoneRule r = (TimeZoneRule)rules.get(i);
if (r instanceof AnnualTimeZoneRule) {
if (((AnnualTimeZoneRule)r).getEndYear() == AnnualTimeZoneRule.MAX_YEAR) {
finalRuleCount++;
finalRuleIdx = i;
}
}
}
if (finalRuleCount > 2) {
// Too many final rules
return false;
}
if (finalRuleCount == 1) {
if (rules.size() == 1) {
// Only one final rule, only governs the initial rule,
// which is already initialized, thus, we do not need to
// add this transition rule
rules.clear();
} else {
// Normalize the final rule
AnnualTimeZoneRule finalRule = (AnnualTimeZoneRule)rules.get(finalRuleIdx);
int tmpRaw = finalRule.getRawOffset();
int tmpDST = finalRule.getDSTSavings();
// Find the last non-final rule
Date finalStart = finalRule.getFirstStart(initialRawOffset, initialDSTSavings);
Date start = finalStart;
for (int i = 0; i < rules.size(); i++) {
if (finalRuleIdx == i) {
continue;
}
TimeZoneRule r = (TimeZoneRule)rules.get(i);
Date lastStart = r.getFinalStart(tmpRaw, tmpDST);
if (lastStart.after(start)) {
start = finalRule.getNextStart(lastStart.getTime(),
r.getRawOffset(),
r.getDSTSavings(),
false);
}
}
TimeZoneRule newRule;
if (start == finalStart) {
// Transform this into a single transition
newRule = new TimeArrayTimeZoneRule(
finalRule.getName(),
finalRule.getRawOffset(),
finalRule.getDSTSavings(),
new long[] {finalStart.getTime()},
DateTimeRule.UTC_TIME);
} else {
// Update the end year
int fields[] = Grego.timeToFields(start.getTime(), null);
newRule = new AnnualTimeZoneRule(
finalRule.getName(),
finalRule.getRawOffset(),
finalRule.getDSTSavings(),
finalRule.getRule(),
finalRule.getStartYear(),
fields[0]);
}
rules.set(finalRuleIdx, newRule);
}
}
Iterator rit = rules.iterator();
while(rit.hasNext()) {
rbtz.addTransitionRule((TimeZoneRule)rit.next());
}
tz = rbtz;
setID(tzid);
return true;
}
/*
* Create a default TZNAME from TZID
*/
private static String getDefaultTZName(String tzid, boolean isDST) {
if (isDST) {
return tzid + "(DST)";
}
return tzid + "(STD)";
}
/*
* Create a TimeZoneRule by the RRULE definition
*/
private static TimeZoneRule createRuleByRRULE(String tzname,
int rawOffset, int dstSavings, long start, List dates, int fromOffset) {
if (dates == null || dates.size() == 0) {
return null;
}
// Parse the first rule
String rrule = (String)dates.get(0);
long until[] = new long[1];
int[] ruleFields = parseRRULE(rrule, until);
if (ruleFields == null) {
// Invalid RRULE
return null;
}
int month = ruleFields[0];
int dayOfWeek = ruleFields[1];
int nthDayOfWeek = ruleFields[2];
int dayOfMonth = ruleFields[3];
if (dates.size() == 1) {
// No more rules
if (ruleFields.length > 4) {
// Multiple BYMONTHDAY values
if (ruleFields.length != 10 || month == -1 || dayOfWeek == 0) {
// Only support the rule using 7 continuous days
// BYMONTH and BYDAY must be set at the same time
return null;
}
int firstDay = 31; // max possible number of dates in a month
int days[] = new int[7];
for (int i = 0; i < 7; i++) {
days[i] = ruleFields[3 + i];
// Resolve negative day numbers. A negative day number should
// not be used in February, but if we see such case, we use 28
// as the base.
days[i] = days[i] > 0 ? days[i] : MONTHLENGTH[month] + days[i] + 1;
firstDay = days[i] < firstDay ? days[i] : firstDay;
}
// Make sure days are continuous
for (int i = 1; i < 7; i++) {
boolean found = false;
for (int j = 0; j < 7; j++) {
if (days[j] == firstDay + i) {
found = true;
break;
}
}
if (!found) {
// days are not continuous
return null;
}
}
// Use DOW_GEQ_DOM rule with firstDay as the start date
dayOfMonth = firstDay;
}
} else {
// Check if BYMONTH + BYMONTHDAY + BYDAY rule with multiple RRULE lines.
// Otherwise, not supported.
if (month == -1 || dayOfWeek == 0 || dayOfMonth == 0) {
// This is not the case
return null;
}
// Parse the rest of rules if number of rules is not exceeding 7.
// We can only support 7 continuous days starting from a day of month.
if (dates.size() > 7) {
return null;
}
// Note: To check valid date range across multiple rule is a little
// bit complicated. For now, this code is not doing strict range
// checking across month boundary
int earliestMonth = month;
int daysCount = ruleFields.length - 3;
int earliestDay = 31;
for (int i = 0; i < daysCount; i++) {
int dom = ruleFields[3 + i];
dom = dom > 0 ? dom : MONTHLENGTH[month] + dom + 1;
earliestDay = dom < earliestDay ? dom : earliestDay;
}
int anotherMonth = -1;
for (int i = 1; i < dates.size(); i++) {
rrule = (String)dates.get(i);
long[] unt = new long[1];
int[] fields = parseRRULE(rrule, unt);
// If UNTIL is newer than previous one, use the one
if (unt[0] > until[0]) {
until = unt;
}
// Check if BYMONTH + BYMONTHDAY + BYDAY rule
if (fields[0] == -1 || fields[1] == 0 || fields[3] == 0) {
return null;
}
// Count number of BYMONTHDAY
int count = fields.length - 3;
if (daysCount + count > 7) {
// We cannot support BYMONTHDAY more than 7
return null;
}
// Check if the same BYDAY is used. Otherwise, we cannot
// support the rule
if (fields[1] != dayOfWeek) {
return null;
}
// Check if the month is same or right next to the primary month
if (fields[0] != month) {
if (anotherMonth == -1) {
int diff = fields[0] - month;
if (diff == -11 || diff == -1) {
// Previous month
anotherMonth = fields[0];
earliestMonth = anotherMonth;
// Reset earliest day
earliestDay = 31;
} else if (diff == 11 || diff == 1) {
// Next month
anotherMonth = fields[0];
} else {
// The day range cannot exceed more than 2 months
return null;
}
} else if (fields[0] != month && fields[0] != anotherMonth) {
// The day range cannot exceed more than 2 months
return null;
}
}
// If ealier month, go through days to find the earliest day
if (fields[0] == earliestMonth) {
for (int j = 0; j < count; j++) {
int dom = fields[3 + j];
dom = dom > 0 ? dom : MONTHLENGTH[fields[0]] + dom + 1;
earliestDay = dom < earliestDay ? dom : earliestDay;
}
}
daysCount += count;
}
if (daysCount != 7) {
// Number of BYMONTHDAY entries must be 7
return null;
}
month = earliestMonth;
dayOfMonth = earliestDay;
}
// Calculate start/end year and missing fields
int[] dfields = Grego.timeToFields(start + fromOffset, null);
int startYear = dfields[0];
if (month == -1) {
// If MYMONTH is not set, use the month of DTSTART
month = dfields[1];
}
if (dayOfWeek == 0 && nthDayOfWeek == 0 && dayOfMonth == 0) {
// If only YEARLY is set, use the day of DTSTART as BYMONTHDAY
dayOfMonth = dfields[2];
}
int timeInDay = dfields[5];
int endYear = AnnualTimeZoneRule.MAX_YEAR;
if (until[0] != MIN_TIME) {
Grego.timeToFields(until[0], dfields);
endYear = dfields[0];
}
// Create the AnnualDateTimeRule
DateTimeRule adtr = null;
if (dayOfWeek == 0 && nthDayOfWeek == 0 && dayOfMonth != 0) {
// Day in month rule, for example, 15th day in the month
adtr = new DateTimeRule(month, dayOfMonth, timeInDay, DateTimeRule.WALL_TIME);
} else if (dayOfWeek != 0 && nthDayOfWeek != 0 && dayOfMonth == 0) {
// Nth day of week rule, for example, last Sunday
adtr = new DateTimeRule(month, nthDayOfWeek, dayOfWeek, timeInDay, DateTimeRule.WALL_TIME);
} else if (dayOfWeek != 0 && nthDayOfWeek == 0 && dayOfMonth != 0) {
// First day of week after day of month rule, for example,
// first Sunday after 15th day in the month
adtr = new DateTimeRule(month, dayOfMonth, dayOfWeek, true, timeInDay, DateTimeRule.WALL_TIME);
} else {
// RRULE attributes are insufficient
return null;
}
return new AnnualTimeZoneRule(tzname, rawOffset, dstSavings, adtr, startYear, endYear);
}
/*
* Parse individual RRULE
*
* On return -
*
* int[0] month calculated by BYMONTH - 1, or -1 when not found
* int[1] day of week in BYDAY, or 0 when not found
* int[2] day of week ordinal number in BYDAY, or 0 when not found
* int[i >= 3] day of month, which could be multiple values, or 0 when not found
*
* or
*
* null on any error cases, for exmaple, FREQ=YEARLY is not available
*
* When UNTIL attribute is available, the time will be set to until[0],
* otherwise, MIN_TIME
*/
private static int[] parseRRULE(String rrule, long[] until) {
int month = -1;
int dayOfWeek = 0;
int nthDayOfWeek = 0;
int[] dayOfMonth = null;
long untilTime = MIN_TIME;
boolean yearly = false;
boolean parseError = false;
StringTokenizer st= new StringTokenizer(rrule, SEMICOLON);
while (st.hasMoreTokens()) {
String attr, value;
String prop = st.nextToken();
int sep = prop.indexOf(EQUALS_SIGN);
if (sep != -1) {
attr = prop.substring(0, sep);
value = prop.substring(sep + 1);
} else {
parseError = true;
break;
}
if (attr.equals(ICAL_FREQ)) {
// only support YEARLY frequency type
if (value.equals(ICAL_YEARLY)) {
yearly = true;
} else {
parseError = true;
break;
}
} else if (attr.equals(ICAL_UNTIL)) {
// ISO8601 UTC format, for example, "20060315T020000Z"
try {
untilTime = parseDateTimeString(value, 0);
} catch (IllegalArgumentException iae) {
parseError = true;
break;
}
} else if (attr.equals(ICAL_BYMONTH)) {
// Note: BYMONTH may contain multiple months, but only single month make sense for
// VTIMEZONE property.
if (value.length() > 2) {
parseError = true;
break;
}
try {
month = Integer.parseInt(value) - 1;
if (month < 0 || month >= 12) {
parseError = true;
break;
}
} catch (NumberFormatException nfe) {
parseError = true;
break;
}
} else if (attr.equals(ICAL_BYDAY)) {
// Note: BYDAY may contain multiple day of week separated by comma. It is unlikely used for
// VTIMEZONE property. We do not support the case.
// 2-letter format is used just for representing a day of week, for example, "SU" for Sunday
// 3 or 4-letter format is used for represeinging Nth day of week, for example, "-1SA" for last Saturday
int length = value.length();
if (length < 2 || length > 4) {
parseError = true;
break;
}
if (length > 2) {
// Nth day of week
int sign = 1;
if (value.charAt(0) == '+') {
sign = 1;
} else if (value.charAt(0) == '-') {
sign = -1;
} else if (length == 4) {
parseError = true;
break;
}
try {
int n = Integer.parseInt(value.substring(length - 3, length - 2));
if (n == 0 || n > 4) {
parseError = true;
break;
}
nthDayOfWeek = n * sign;
} catch(NumberFormatException nfe) {
parseError = true;
break;
}
value = value.substring(length - 2);
}
int wday;
for (wday = 0; wday < ICAL_DOW_NAMES.length; wday++) {
if (value.equals(ICAL_DOW_NAMES[wday])) {
break;
}
}
if (wday < ICAL_DOW_NAMES.length) {
// Sunday(1) - Saturday(7)
dayOfWeek = wday + 1;
} else {
parseError = true;
break;
}
} else if (attr.equals(ICAL_BYMONTHDAY)) {
// Note: BYMONTHDAY may contain multiple days delimited by comma
//
// A value of BYMONTHDAY could be negative, for example, -1 means
// the last day in a month
StringTokenizer days = new StringTokenizer(value, COMMA);
int count = days.countTokens();
dayOfMonth = new int[count];
int index = 0;
while(days.hasMoreTokens()) {
try {
dayOfMonth[index++] = Integer.parseInt(days.nextToken());
} catch (NumberFormatException nfe) {
parseError = true;
break;
}
}
}
}
if (parseError) {
return null;
}
if (!yearly) {
// FREQ=YEARLY must be set
return null;
}
until[0] = untilTime;
int[] results;
if (dayOfMonth == null) {
results = new int[4];
results[3] = 0;
} else {
results = new int[3 + dayOfMonth.length];
for (int i = 0; i < dayOfMonth.length; i++) {
results[3 + i] = dayOfMonth[i];
}
}
results[0] = month;
results[1] = dayOfWeek;
results[2] = nthDayOfWeek;
return results;
}
/*
* Create a TimeZoneRule by the RDATE definition
*/
private static TimeZoneRule createRuleByRDATE(String tzname,
int rawOffset, int dstSavings, long start, List dates, int fromOffset) {
// Create an array of transition times
long[] times;
if (dates == null || dates.size() == 0) {
// When no RDATE line is provided, use start (DTSTART)
// as the transition time
times = new long[1];
times[0] = start;
} else {
times = new long[dates.size()];
Iterator it = dates.iterator();
int idx = 0;
try {
while(it.hasNext()) {
times[idx++] = parseDateTimeString((String)it.next(), fromOffset);
}
} catch (IllegalArgumentException iae) {
return null;
}
}
return new TimeArrayTimeZoneRule(tzname, rawOffset, dstSavings, times, DateTimeRule.UTC_TIME);
}
/*
* Write the time zone rules in RFC2445 VTIMEZONE format
*/
private void writeZone(Writer w, BasicTimeZone basictz, String[] customProperties) throws IOException {
// Write the header
writeHeader(w);
if (customProperties != null && customProperties.length > 0) {
for (int i = 0; i < customProperties.length; i++) {
if (customProperties[i] != null) {
w.write(customProperties[i]);
w.write(NEWLINE);
}
}
}
long t = MIN_TIME;
String dstName = null;
int dstFromOffset = 0;
int dstFromDSTSavings = 0;
int dstToOffset = 0;
int dstStartYear = 0;
int dstMonth = 0;
int dstDayOfWeek = 0;
int dstWeekInMonth = 0;
int dstMillisInDay = 0;
long dstStartTime = 0;
long dstUntilTime = 0;
int dstCount = 0;
AnnualTimeZoneRule finalDstRule = null;
String stdName = null;
int stdFromOffset = 0;
int stdFromDSTSavings = 0;
int stdToOffset = 0;
int stdStartYear = 0;
int stdMonth = 0;
int stdDayOfWeek = 0;
int stdWeekInMonth = 0;
int stdMillisInDay = 0;
long stdStartTime = 0;
long stdUntilTime = 0;
int stdCount = 0;
AnnualTimeZoneRule finalStdRule = null;
int[] dtfields = new int[6];
boolean hasTransitions = false;
// Going through all transitions
while(true) {
TimeZoneTransition tzt = basictz.getNextTransition(t, false);
if (tzt == null) {
break;
}
hasTransitions = true;
t = tzt.getTime();
String name = tzt.getTo().getName();
boolean isDst = (tzt.getTo().getDSTSavings() != 0);
int fromOffset = tzt.getFrom().getRawOffset() + tzt.getFrom().getDSTSavings();
int fromDSTSavings = tzt.getFrom().getDSTSavings();
int toOffset = tzt.getTo().getRawOffset() + tzt.getTo().getDSTSavings();
Grego.timeToFields(tzt.getTime() + fromOffset, dtfields);
int weekInMonth = Grego.getDayOfWeekInMonth(dtfields[0], dtfields[1], dtfields[2]);
int year = dtfields[0];
boolean sameRule = false;
if (isDst) {
if (finalDstRule == null && tzt.getTo() instanceof AnnualTimeZoneRule) {
if (((AnnualTimeZoneRule)tzt.getTo()).getEndYear() == AnnualTimeZoneRule.MAX_YEAR) {
finalDstRule = (AnnualTimeZoneRule)tzt.getTo();
}
}
if (dstCount > 0) {
if (year == dstStartYear + dstCount
&& name.equals(dstName)
&& dstFromOffset == fromOffset
&& dstToOffset == toOffset
&& dstMonth == dtfields[1]
&& dstDayOfWeek == dtfields[3]
&& dstWeekInMonth == weekInMonth
&& dstMillisInDay == dtfields[5]) {
// Update until time
dstUntilTime = t;
dstCount++;
sameRule = true;
}
if (!sameRule) {
if (dstCount == 1) {
writeZonePropsByTime(w, true, dstName, dstFromOffset, dstToOffset,
dstStartTime, true);
} else {
writeZonePropsByDOW(w, true, dstName, dstFromOffset, dstToOffset,
dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime);
}
}
}
if (!sameRule) {
// Reset this DST information
dstName = name;
dstFromOffset = fromOffset;
dstFromDSTSavings = fromDSTSavings;
dstToOffset = toOffset;
dstStartYear = year;
dstMonth = dtfields[1];
dstDayOfWeek = dtfields[3];
dstWeekInMonth = weekInMonth;
dstMillisInDay = dtfields[5];
dstStartTime = dstUntilTime = t;
dstCount = 1;
}
if (finalStdRule != null && finalDstRule != null) {
break;
}
} else {
if (finalStdRule == null && tzt.getTo() instanceof AnnualTimeZoneRule) {
if (((AnnualTimeZoneRule)tzt.getTo()).getEndYear() == AnnualTimeZoneRule.MAX_YEAR) {
finalStdRule = (AnnualTimeZoneRule)tzt.getTo();
}
}
if (stdCount > 0) {
if (year == stdStartYear + stdCount
&& name.equals(stdName)
&& stdFromOffset == fromOffset
&& stdToOffset == toOffset
&& stdMonth == dtfields[1]
&& stdDayOfWeek == dtfields[3]
&& stdWeekInMonth == weekInMonth
&& stdMillisInDay == dtfields[5]) {
// Update until time
stdUntilTime = t;
stdCount++;
sameRule = true;
}
if (!sameRule) {
if (stdCount == 1) {
writeZonePropsByTime(w, false, stdName, stdFromOffset, stdToOffset,
stdStartTime, true);
} else {
writeZonePropsByDOW(w, false, stdName, stdFromOffset, stdToOffset,
stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime);
}
}
}
if (!sameRule) {
// Reset this STD information
stdName = name;
stdFromOffset = fromOffset;
stdFromDSTSavings = fromDSTSavings;
stdToOffset = toOffset;
stdStartYear = year;
stdMonth = dtfields[1];
stdDayOfWeek = dtfields[3];
stdWeekInMonth = weekInMonth;
stdMillisInDay = dtfields[5];
stdStartTime = stdUntilTime = t;
stdCount = 1;
}
if (finalStdRule != null && finalDstRule != null) {
break;
}
}
}
if (!hasTransitions) {
// No transition - put a single non transition RDATE
int offset = basictz.getOffset(0 /* any time */);
boolean isDst = (offset != basictz.getRawOffset());
writeZonePropsByTime(w, isDst, getDefaultTZName(basictz.getID(), isDst),
offset, offset, DEF_TZSTARTTIME - offset, false);
} else {
if (dstCount > 0) {
if (finalDstRule == null) {
if (dstCount == 1) {
writeZonePropsByTime(w, true, dstName, dstFromOffset, dstToOffset,
dstStartTime, true);
} else {
writeZonePropsByDOW(w, true, dstName, dstFromOffset, dstToOffset,
dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime);
}
} else {
if (dstCount == 1) {
writeFinalRule(w, true, finalDstRule,
dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, dstStartTime);
} else {
// Use a single rule if possible
if (isEquivalentDateRule(dstMonth, dstWeekInMonth, dstDayOfWeek, finalDstRule.getRule())) {
writeZonePropsByDOW(w, true, dstName, dstFromOffset, dstToOffset,
dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, MAX_TIME);
} else {
// Not equivalent rule - write out two different rules
writeZonePropsByDOW(w, true, dstName, dstFromOffset, dstToOffset,
dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime);
writeFinalRule(w, true, finalDstRule,
dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, dstStartTime);
}
}
}
}
if (stdCount > 0) {
if (finalStdRule == null) {
if (stdCount == 1) {
writeZonePropsByTime(w, false, stdName, stdFromOffset, stdToOffset,
stdStartTime, true);
} else {
writeZonePropsByDOW(w, false, stdName, stdFromOffset, stdToOffset,
stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime);
}
} else {
if (stdCount == 1) {
writeFinalRule(w, false, finalStdRule,
stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, stdStartTime);
} else {
// Use a single rule if possible
if (isEquivalentDateRule(stdMonth, stdWeekInMonth, stdDayOfWeek, finalStdRule.getRule())) {
writeZonePropsByDOW(w, false, stdName, stdFromOffset, stdToOffset,
stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, MAX_TIME);
} else {
// Not equivalent rule - write out two different rules
writeZonePropsByDOW(w, false, stdName, stdFromOffset, stdToOffset,
stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime);
writeFinalRule(w, false, finalStdRule,
stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, stdStartTime);
}
}
}
}
}
writeFooter(w);
}
/*
* Check if the DOW rule specified by month, weekInMonth and dayOfWeek is equivalent
* to the DateTimerule.
*/
private static boolean isEquivalentDateRule(int month, int weekInMonth, int dayOfWeek, DateTimeRule dtrule) {
if (month != dtrule.getRuleMonth() || dayOfWeek != dtrule.getRuleDayOfWeek()) {
return false;
}
if (dtrule.getTimeRuleType() != DateTimeRule.WALL_TIME) {
// Do not try to do more intelligent comparison for now.
return false;
}
if (dtrule.getDateRuleType() == DateTimeRule.DOW
&& dtrule.getRuleWeekInMonth() == weekInMonth) {
return true;
}
int ruleDOM = dtrule.getRuleDayOfMonth();
if (dtrule.getDateRuleType() == DateTimeRule.DOW_GEQ_DOM) {
if (ruleDOM%7 == 1 && (ruleDOM + 6)/7 == weekInMonth) {
return true;
}
if (month != Calendar.FEBRUARY && (MONTHLENGTH[month] - ruleDOM)%7 == 6
&& weekInMonth == -1*((MONTHLENGTH[month]-ruleDOM+1)/7)) {
return true;
}
}
if (dtrule.getDateRuleType() == DateTimeRule.DOW_LEQ_DOM) {
if (ruleDOM%7 == 0 && ruleDOM/7 == weekInMonth) {
return true;
}
if (month != Calendar.FEBRUARY && (MONTHLENGTH[month] - ruleDOM)%7 == 0
&& weekInMonth == -1*((MONTHLENGTH[month] - ruleDOM)/7 + 1)) {
return true;
}
}
return false;
}
/*
* Write a single start time
*/
private static void writeZonePropsByTime(Writer writer, boolean isDst, String tzname,
int fromOffset, int toOffset, long time, boolean withRDATE) throws IOException {
beginZoneProps(writer, isDst, tzname, fromOffset, toOffset, time);
if (withRDATE) {
writer.write(ICAL_RDATE);
writer.write(COLON);
writer.write(getDateTimeString(time + fromOffset));
writer.write(NEWLINE);
}
endZoneProps(writer, isDst);
}
/*
* Write start times defined by a DOM rule using VTIMEZONE RRULE
*/
private static void writeZonePropsByDOM(Writer writer, boolean isDst, String tzname, int fromOffset, int toOffset,
int month, int dayOfMonth, long startTime, long untilTime) throws IOException {
beginZoneProps(writer, isDst, tzname, fromOffset, toOffset, startTime);
beginRRULE(writer, month);
writer.write(ICAL_BYMONTHDAY);
writer.write(EQUALS_SIGN);
writer.write(Integer.toString(dayOfMonth));
if (untilTime != MAX_TIME) {
appendUNTIL(writer, getDateTimeString(untilTime + fromOffset));
}
writer.write(NEWLINE);
endZoneProps(writer, isDst);
}
/*
* Write start times defined by a DOW rule using VTIMEZONE RRULE
*/
private static void writeZonePropsByDOW(Writer writer, boolean isDst, String tzname, int fromOffset, int toOffset,
int month, int weekInMonth, int dayOfWeek, long startTime, long untilTime) throws IOException {
beginZoneProps(writer, isDst, tzname, fromOffset, toOffset, startTime);
beginRRULE(writer, month);
writer.write(ICAL_BYDAY);
writer.write(EQUALS_SIGN);
writer.write(Integer.toString(weekInMonth)); // -4, -3, -2, -1, 1, 2, 3, 4
writer.write(ICAL_DOW_NAMES[dayOfWeek - 1]); // SU, MO, TU...
if (untilTime != MAX_TIME) {
appendUNTIL(writer, getDateTimeString(untilTime + fromOffset));
}
writer.write(NEWLINE);
endZoneProps(writer, isDst);
}
/*
* Write start times defined by a DOW_GEQ_DOM rule using VTIMEZONE RRULE
*/
private static void writeZonePropsByDOW_GEQ_DOM(Writer writer, boolean isDst, String tzname, int fromOffset, int toOffset,
int month, int dayOfMonth, int dayOfWeek, long startTime, long untilTime) throws IOException {
// Check if this rule can be converted to DOW rule
if (dayOfMonth%7 == 1) {
// Can be represented by DOW rule
writeZonePropsByDOW(writer, isDst, tzname, fromOffset, toOffset,
month, (dayOfMonth + 6)/7, dayOfWeek, startTime, untilTime);
} else if (month != Calendar.FEBRUARY && (MONTHLENGTH[month] - dayOfMonth)%7 == 6) {
// Can be represented by DOW rule with negative week number
writeZonePropsByDOW(writer, isDst, tzname, fromOffset, toOffset,
month, -1*((MONTHLENGTH[month] - dayOfMonth + 1)/7), dayOfWeek, startTime, untilTime);
} else {
// Otherwise, use BYMONTHDAY to include all possible dates
beginZoneProps(writer, isDst, tzname, fromOffset, toOffset, startTime);
// Check if all days are in the same month
int startDay = dayOfMonth;
int currentMonthDays = 7;
if (dayOfMonth <= 0) {
// The start day is in previous month
int prevMonthDays = 1 - dayOfMonth;
currentMonthDays -= prevMonthDays;
int prevMonth = (month - 1) < 0 ? 11 : month - 1;
// Note: When a rule is separated into two, UNTIL attribute needs to be
// calculated for each of them. For now, we skip this, because we basically use this method
// only for final rules, which does not have the UNTIL attribute
writeZonePropsByDOW_GEQ_DOM_sub(writer, prevMonth, -prevMonthDays, dayOfWeek, prevMonthDays, MAX_TIME /* Do not use UNTIL */, fromOffset);
// Start from 1 for the rest
startDay = 1;
} else if (dayOfMonth + 6 > MONTHLENGTH[month]) {
// Note: This code does not actually work well in February. For now, days in month in
// non-leap year.
int nextMonthDays = dayOfMonth + 6 - MONTHLENGTH[month];
currentMonthDays -= nextMonthDays;
int nextMonth = (month + 1) > 11 ? 0 : month + 1;
writeZonePropsByDOW_GEQ_DOM_sub(writer, nextMonth, 1, dayOfWeek, nextMonthDays, MAX_TIME /* Do not use UNTIL */, fromOffset);
}
writeZonePropsByDOW_GEQ_DOM_sub(writer, month, startDay, dayOfWeek, currentMonthDays, untilTime, fromOffset);
endZoneProps(writer, isDst);
}
}
/*
* Called from writeZonePropsByDOW_GEQ_DOM
*/
private static void writeZonePropsByDOW_GEQ_DOM_sub(Writer writer, int month,
int dayOfMonth, int dayOfWeek, int numDays, long untilTime, int fromOffset) throws IOException {
int startDayNum = dayOfMonth;
boolean isFeb = (month == Calendar.FEBRUARY);
if (dayOfMonth < 0 && !isFeb) {
// Use positive number if possible
startDayNum = MONTHLENGTH[month] + dayOfMonth + 1;
}
beginRRULE(writer, month);
writer.write(ICAL_BYDAY);
writer.write(EQUALS_SIGN);
writer.write(ICAL_DOW_NAMES[dayOfWeek - 1]); // SU, MO, TU...
writer.write(SEMICOLON);
writer.write(ICAL_BYMONTHDAY);
writer.write(EQUALS_SIGN);
writer.write(Integer.toString(startDayNum));
for (int i = 1; i < numDays; i++) {
writer.write(COMMA);
writer.write(Integer.toString(startDayNum + i));
}
if (untilTime != MAX_TIME) {
appendUNTIL(writer, getDateTimeString(untilTime + fromOffset));
}
writer.write(NEWLINE);
}
/*
* Write start times defined by a DOW_LEQ_DOM rule using VTIMEZONE RRULE
*/
private static void writeZonePropsByDOW_LEQ_DOM(Writer writer, boolean isDst, String tzname, int fromOffset, int toOffset,
int month, int dayOfMonth, int dayOfWeek, long startTime, long untilTime) throws IOException {
// Check if this rule can be converted to DOW rule
if (dayOfMonth%7 == 0) {
// Can be represented by DOW rule
writeZonePropsByDOW(writer, isDst, tzname, fromOffset, toOffset,
month, dayOfMonth/7, dayOfWeek, startTime, untilTime);
} else if (month != Calendar.FEBRUARY && (MONTHLENGTH[month] - dayOfMonth)%7 == 0){
// Can be represented by DOW rule with negative week number
writeZonePropsByDOW(writer, isDst, tzname, fromOffset, toOffset,
month, -1*((MONTHLENGTH[month] - dayOfMonth)/7 + 1), dayOfWeek, startTime, untilTime);
} else if (month == Calendar.FEBRUARY && dayOfMonth == 29) {
// Specical case for February
writeZonePropsByDOW(writer, isDst, tzname, fromOffset, toOffset,
Calendar.FEBRUARY, -1, dayOfWeek, startTime, untilTime);
} else {
// Otherwise, convert this to DOW_GEQ_DOM rule
writeZonePropsByDOW_GEQ_DOM(writer, isDst, tzname, fromOffset, toOffset,
month, dayOfMonth - 6, dayOfWeek, startTime, untilTime);
}
}
/*
* Write the final time zone rule using RRULE, with no UNTIL attribute
*/
private static void writeFinalRule(Writer writer, boolean isDst, AnnualTimeZoneRule rule,
int fromRawOffset, int fromDSTSavings, long startTime) throws IOException{
DateTimeRule dtrule = toWallTimeRule(rule.getRule(), fromRawOffset, fromDSTSavings);
int toOffset = rule.getRawOffset() + rule.getDSTSavings();
switch (dtrule.getDateRuleType()) {
case DateTimeRule.DOM:
writeZonePropsByDOM(writer, isDst, rule.getName(), fromRawOffset + fromDSTSavings, toOffset,
dtrule.getRuleMonth(), dtrule.getRuleDayOfMonth(), startTime, MAX_TIME);
break;
case DateTimeRule.DOW:
writeZonePropsByDOW(writer, isDst, rule.getName(), fromRawOffset + fromDSTSavings, toOffset,
dtrule.getRuleMonth(), dtrule.getRuleWeekInMonth(), dtrule.getRuleDayOfWeek(), startTime, MAX_TIME);
break;
case DateTimeRule.DOW_GEQ_DOM:
writeZonePropsByDOW_GEQ_DOM(writer, isDst, rule.getName(), fromRawOffset + fromDSTSavings, toOffset,
dtrule.getRuleMonth(), dtrule.getRuleDayOfMonth(), dtrule.getRuleDayOfWeek(), startTime, MAX_TIME);
break;
case DateTimeRule.DOW_LEQ_DOM:
writeZonePropsByDOW_LEQ_DOM(writer, isDst, rule.getName(), fromRawOffset + fromDSTSavings, toOffset,
dtrule.getRuleMonth(), dtrule.getRuleDayOfMonth(), dtrule.getRuleDayOfWeek(), startTime, MAX_TIME);
break;
}
}
/*
* Convert the rule to its equivalent rule using WALL_TIME mode
*/
private static DateTimeRule toWallTimeRule(DateTimeRule rule, int rawOffset, int dstSavings) {
if (rule.getTimeRuleType() == DateTimeRule.WALL_TIME) {
return rule;
}
int wallt = rule.getRuleMillisInDay();
if (rule.getTimeRuleType() == DateTimeRule.UTC_TIME) {
wallt += (rawOffset + dstSavings);
} else if (rule.getTimeRuleType() == DateTimeRule.STANDARD_TIME) {
wallt += dstSavings;
}
int month = -1, dom = 0, dow = 0, dtype = -1;
int dshift = 0;
if (wallt < 0) {
dshift = -1;
wallt += Grego.MILLIS_PER_DAY;
} else if (wallt >= Grego.MILLIS_PER_DAY) {
dshift = 1;
wallt -= Grego.MILLIS_PER_DAY;
}
month = rule.getRuleMonth();
dom = rule.getRuleDayOfMonth();
dow = rule.getRuleDayOfWeek();
dtype = rule.getDateRuleType();
if (dshift != 0) {
if (dtype == DateTimeRule.DOW) {
// Convert to DOW_GEW_DOM or DOW_LEQ_DOM rule first
int wim = rule.getRuleWeekInMonth();
if (wim > 0) {
dtype = DateTimeRule.DOW_GEQ_DOM;
dom = 7 * (wim - 1) + 1;
} else {
dtype = DateTimeRule.DOW_LEQ_DOM;
dom = MONTHLENGTH[month] + 7 * (wim + 1);
}
}
// Shift one day before or after
dom += dshift;
if (dom == 0) {
month--;
month = month < Calendar.JANUARY ? Calendar.DECEMBER : month;
dom = MONTHLENGTH[month];
} else if (dom > MONTHLENGTH[month]) {
month++;
month = month > Calendar.DECEMBER ? Calendar.JANUARY : month;
dom = 1;
}
if (dtype != DateTimeRule.DOM) {
// Adjust day of week
dow += dshift;
if (dow < Calendar.SUNDAY) {
dow = Calendar.SATURDAY;
} else if (dow > Calendar.SATURDAY) {
dow = Calendar.SUNDAY;
}
}
}
// Create a new rule
DateTimeRule modifiedRule;
if (dtype == DateTimeRule.DOM) {
modifiedRule = new DateTimeRule(month, dom, wallt, DateTimeRule.WALL_TIME);
} else {
modifiedRule = new DateTimeRule(month, dom, dow,
(dtype == DateTimeRule.DOW_GEQ_DOM), wallt, DateTimeRule.WALL_TIME);
}
return modifiedRule;
}
/*
* Write the opening section of zone properties
*/
private static void beginZoneProps(Writer writer, boolean isDst, String tzname, int fromOffset, int toOffset, long startTime) throws IOException {
writer.write(ICAL_BEGIN);
writer.write(COLON);
if (isDst) {
writer.write(ICAL_DAYLIGHT);
} else {
writer.write(ICAL_STANDARD);
}
writer.write(NEWLINE);
// TZOFFSETTO
writer.write(ICAL_TZOFFSETTO);
writer.write(COLON);
writer.write(millisToOffset(toOffset));
writer.write(NEWLINE);
// TZOFFSETFROM
writer.write(ICAL_TZOFFSETFROM);
writer.write(COLON);
writer.write(millisToOffset(fromOffset));
writer.write(NEWLINE);
// TZNAME
writer.write(ICAL_TZNAME);
writer.write(COLON);
writer.write(tzname);
writer.write(NEWLINE);
// DTSTART
writer.write(ICAL_DTSTART);
writer.write(COLON);
writer.write(getDateTimeString(startTime + fromOffset));
writer.write(NEWLINE);
}
/*
* Writes the closing section of zone properties
*/
private static void endZoneProps(Writer writer, boolean isDst) throws IOException{
// END:STANDARD or END:DAYLIGHT
writer.write(ICAL_END);
writer.write(COLON);
if (isDst) {
writer.write(ICAL_DAYLIGHT);
} else {
writer.write(ICAL_STANDARD);
}
writer.write(NEWLINE);
}
/*
* Write the beginning part of RRULE line
*/
private static void beginRRULE(Writer writer, int month) throws IOException {
writer.write(ICAL_RRULE);
writer.write(COLON);
writer.write(ICAL_FREQ);
writer.write(EQUALS_SIGN);
writer.write(ICAL_YEARLY);
writer.write(SEMICOLON);
writer.write(ICAL_BYMONTH);
writer.write(EQUALS_SIGN);
writer.write(Integer.toString(month + 1));
writer.write(SEMICOLON);
}
/*
* Append the UNTIL attribute after RRULE line
*/
private static void appendUNTIL(Writer writer, String until) throws IOException {
if (until != null) {
writer.write(SEMICOLON);
writer.write(ICAL_UNTIL);
writer.write(EQUALS_SIGN);
writer.write(until);
}
}
/*
* Write the opening section of the VTIMEZONE block
*/
private void writeHeader(Writer writer)throws IOException {
writer.write(ICAL_BEGIN);
writer.write(COLON);
writer.write(ICAL_VTIMEZONE);
writer.write(NEWLINE);
writer.write(ICAL_TZID);
writer.write(COLON);
writer.write(tz.getID());
writer.write(NEWLINE);
if (tzurl != null) {
writer.write(ICAL_TZURL);
writer.write(COLON);
writer.write(tzurl);
writer.write(NEWLINE);
}
if (lastmod != null) {
writer.write(ICAL_LASTMOD);
writer.write(COLON);
writer.write(getUTCDateTimeString(lastmod.getTime()));
writer.write(NEWLINE);
}
}
/*
* Write the closing section of the VTIMEZONE definition block
*/
private static void writeFooter(Writer writer) throws IOException {
writer.write(ICAL_END);
writer.write(COLON);
writer.write(ICAL_VTIMEZONE);
writer.write(NEWLINE);
}
/*
* Convert date/time to RFC2445 Date-Time form #1 DATE WITH LOCAL TIME
*/
private static String getDateTimeString(long time) {
int[] fields = Grego.timeToFields(time, null);
StringBuffer sb = new StringBuffer(15);
sb.append(numToString(fields[0], 4));
sb.append(numToString(fields[1] + 1, 2));
sb.append(numToString(fields[2], 2));
sb.append('T');
int t = fields[5];
int hour = t / Grego.MILLIS_PER_HOUR;
t %= Grego.MILLIS_PER_HOUR;
int min = t / Grego.MILLIS_PER_MINUTE;
t %= Grego.MILLIS_PER_MINUTE;
int sec = t / Grego.MILLIS_PER_SECOND;
sb.append(numToString(hour, 2));
sb.append(numToString(min, 2));
sb.append(numToString(sec, 2));
return sb.toString();
}
/*
* Convert date/time to RFC2445 Date-Time form #2 DATE WITH UTC TIME
*/
private static String getUTCDateTimeString(long time) {
return getDateTimeString(time) + "Z";
}
/*
* Parse RFC2445 Date-Time form #1 DATE WITH LOCAL TIME and
* #2 DATE WITH UTC TIME
*/
private static long parseDateTimeString(String str, int offset) {
int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0;
boolean isUTC = false;
boolean isValid = false;
do {
if (str == null) {
break;
}
int length = str.length();
if (length != 15 && length != 16) {
// FORM#1 15 characters, such as "20060317T142115"
// FORM#2 16 characters, such as "20060317T142115Z"
break;
}
if (str.charAt(8) != 'T') {
// charcter "T" must be used for separating date and time
break;
}
if (length == 16) {
if (str.charAt(15) != 'Z') {
// invalid format
break;
}
isUTC = true;
}
try {
year = Integer.parseInt(str.substring(0, 4));
month = Integer.parseInt(str.substring(4, 6)) - 1; // 0-based
day = Integer.parseInt(str.substring(6, 8));
hour = Integer.parseInt(str.substring(9, 11));
min = Integer.parseInt(str.substring(11, 13));
sec = Integer.parseInt(str.substring(13, 15));
} catch (NumberFormatException nfe) {
break;
}
// check valid range
int maxDayOfMonth = Grego.monthLength(year, month);
if (year < 0 || month < 0 || month > 11 || day < 1 || day > maxDayOfMonth ||
hour < 0 || hour >= 24 || min < 0 || min >= 60 || sec < 0 || sec >= 60) {
break;
}
isValid = true;
} while(false);
if (!isValid) {
throw new IllegalArgumentException("Invalid date time string format");
}
// Calculate the time
long time = Grego.fieldsToDay(year, month, day) * Grego.MILLIS_PER_DAY;
time += (hour*Grego.MILLIS_PER_HOUR + min*Grego.MILLIS_PER_MINUTE + sec*Grego.MILLIS_PER_SECOND);
if (!isUTC) {
time -= offset;
}
return time;
}
/*
* Convert RFC2445 utc-offset string to milliseconds
*/
private static int offsetStrToMillis(String str) {
boolean isValid = false;
int sign = 0, hour = 0, min = 0, sec = 0;
do {
if (str == null) {
break;
}
int length = str.length();
if (length != 5 && length != 7) {
// utf-offset must be 5 or 7 characters
break;
}
// sign
char s = str.charAt(0);
if (s == '+') {
sign = 1;
} else if (s == '-') {
sign = -1;
} else {
// utf-offset must start with "+" or "-"
break;
}
try {
hour = Integer.parseInt(str.substring(1, 3));
min = Integer.parseInt(str.substring(3, 5));
if (length == 7) {
sec = Integer.parseInt(str.substring(5, 7));
}
} catch (NumberFormatException nfe) {
break;
}
isValid = true;
} while(false);
if (!isValid) {
throw new IllegalArgumentException("Bad offset string");
}
int millis = sign * ((hour * 60 + min) * 60 + sec) * 1000;
return millis;
}
/*
* Convert milliseconds to RFC2445 utc-offset string
*/
private static String millisToOffset(int millis) {
StringBuffer sb = new StringBuffer(7);
if (millis >= 0) {
sb.append('+');
} else {
sb.append('-');
millis = -millis;
}
int hour, min, sec;
int t = millis / 1000;
sec = t % 60;
t = (t - sec) / 60;
min = t % 60;
hour = t / 60;
sb.append(numToString(hour, 2));
sb.append(numToString(min, 2));
sb.append(numToString(sec, 2));
return sb.toString();
}
/*
* Format integer number
*/
private static String numToString(int num, int width) {
String str = Integer.toString(num);
int len = str.length();
if (len >= width) {
return str.substring(len - width, len);
}
StringBuffer sb = new StringBuffer(width);
for (int i = len; i < width; i++) {
sb.append('0');
}
sb.append(str);
return sb.toString();
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/Measure.java 0000644 0001750 0001750 00000006515 11157614653 020766 0 ustar twerner twerner /*
**********************************************************************
* Copyright (c) 2004-2009, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Author: Alan Liu
* Created: April 20, 2004
* Since: ICU 3.0
**********************************************************************
*/
package com.ibm.icu.util;
import java.lang.Number;
/**
* An amount of a specified unit, consisting of a Number and a Unit.
* For example, a length measure consists of a Number and a length
* unit, such as feet or meters. This is an abstract class.
* Subclasses specify a concrete Unit type.
*
* Measure objects are parsed and formatted by subclasses of * MeasureFormat. * *
Measure objects are immutable. * * @see java.lang.Number * @see com.ibm.icu.util.MeasureUnit * @see com.ibm.icu.text.MeasureFormat * @author Alan Liu * @stable ICU 3.0 */ public abstract class Measure { private Number number; private MeasureUnit unit; /** * Constructs a new object given a number and a unit. * @param number the number * @param unit the unit * @stable ICU 3.0 */ protected Measure(Number number, MeasureUnit unit) { if (number == null || unit == null) { throw new NullPointerException(); } this.number = number; this.unit = unit; } /** * Returns true if the given object is equal to this object. * @return true if this object is equal to the given object * @stable ICU 3.0 */ public boolean equals(Object obj) { if (obj == null) return false; if (obj == this) return true; try { Measure m = (Measure) obj; return unit.equals(m.unit) && numbersEqual(number, m.number); } catch (ClassCastException e) { return false; } } /* * See if two numbers are identical or have the same double value. * @param a A number * @param b Another number to be compared with * @return Returns true if two numbers are identical or have the same double value. */ // TODO improve this to catch more cases (two different longs that have same double values, BigDecimals, etc) private static boolean numbersEqual(Number a, Number b) { if (a.equals(b)) { return true; } if (a.doubleValue() == b.doubleValue()) { return true; } return false; } /** * Returns a hashcode for this object. * @return a 32-bit hash * @stable ICU 3.0 */ public int hashCode() { return number.hashCode() ^ unit.hashCode(); } /** * Returns a string representation of this object. * @return a string representation consisting of the ISO currency * code together with the numeric amount * @stable ICU 3.0 */ public String toString() { return number.toString() + ' ' + unit.toString(); } /** * Returns the numeric value of this object. * @return this object's Number * @stable ICU 3.0 */ public Number getNumber() { return number; } /** * Returns the unit of this object. * @return this object's Unit * @stable ICU 3.0 */ public MeasureUnit getUnit() { return unit; } } icu4j-4.2.1.1/src/com/ibm/icu/util/UResourceTypeMismatchException.java 0000644 0001750 0001750 00000001630 10501435666 025476 0 ustar twerner twerner /* ****************************************************************************** * Copyright (C) 2004-2006, International Business Machines Corporation and * * others. All Rights Reserved. * ****************************************************************************** */ package com.ibm.icu.util; /** * Exception thrown when the requested resource type * is not the same type as the available resource * @author ram * @stable ICU 3.0 */ public class UResourceTypeMismatchException extends RuntimeException { // Generated by serialver from JDK 1.4.1_01 static final long serialVersionUID = 1286569061095434541L; /** * Constuct the exception with the given message * @param msg the error message for this exception * @stable ICU 3.0 */ public UResourceTypeMismatchException(String msg){ super(msg); } } icu4j-4.2.1.1/src/com/ibm/icu/util/CopticCalendar.java 0000644 0001750 0001750 00000024134 11015072544 022223 0 ustar twerner twerner /* ******************************************************************************* * Copyright (C) 2005-2008, International Business Machines Corporation and * * others. All Rights Reserved. * ******************************************************************************* */ package com.ibm.icu.util; import java.util.Date; import java.util.Locale; /** * Implement the Coptic calendar system. *
* CopticCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a ULocale
* with the tag "@calendar=coptic".
CopticCalendar using the current time
* in the default time zone with the default locale.
* @stable ICU 3.4
*/
public CopticCalendar() {
super();
}
/**
* Constructs a CopticCalendar based on the current time
* in the given time zone with the default locale.
*
* @param zone The time zone for the new calendar.
* @stable ICU 3.4
*/
public CopticCalendar(TimeZone zone) {
super(zone);
}
/**
* Constructs a CopticCalendar based on the current time
* in the default time zone with the given locale.
*
* @param aLocale The locale for the new calendar.
* @stable ICU 3.4
*/
public CopticCalendar(Locale aLocale) {
super(aLocale);
}
/**
* Constructs a CopticCalendar based on the current time
* in the default time zone with the given locale.
*
* @param locale The icu locale for the new calendar.
* @stable ICU 3.4
*/
public CopticCalendar(ULocale locale) {
super(locale);
}
/**
* Constructs a CopticCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone The time zone for the new calendar.
* @param aLocale The locale for the new calendar.
* @stable ICU 3.4
*/
public CopticCalendar(TimeZone zone, Locale aLocale) {
super(zone, aLocale);
}
/**
* Constructs a CopticCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone The time zone for the new calendar.
* @param locale The icu locale for the new calendar.
* @stable ICU 3.4
*/
public CopticCalendar(TimeZone zone, ULocale locale) {
super(zone, locale);
}
/**
* Constructs a CopticCalendar with the given date set
* in the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for Tout.
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @stable ICU 3.4
*/
public CopticCalendar(int year, int month, int date) {
super(year, month, date);
}
/**
* Constructs a CopticCalendar with the given date set
* in the default time zone with the default locale.
*
* @param date The date to which the new calendar is set.
* @stable ICU 3.4
*/
public CopticCalendar(Date date) {
super(date);
}
/**
* Constructs a CopticCalendar with the given date
* and time set for the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for Tout.
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @param hour The value used to set the calendar's {@link #HOUR_OF_DAY HOUR_OF_DAY} time field.
* @param minute The value used to set the calendar's {@link #MINUTE MINUTE} time field.
* @param second The value used to set the calendar's {@link #SECOND SECOND} time field.
* @stable ICU 3.4
*/
public CopticCalendar(int year, int month, int date, int hour,
int minute, int second) {
super(year, month, date, hour, minute, second);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public String getType() {
return "coptic";
}
/**
* {@inheritDoc}
* @internal
* @deprecated This API is ICU internal only.
*/
protected int handleGetExtendedYear() {
int eyear;
if (newerField(EXTENDED_YEAR, YEAR) == EXTENDED_YEAR) {
eyear = internalGet(EXTENDED_YEAR, 1); // Default to year 1
} else {
// The year defaults to the epoch start, the era to AD
int era = internalGet(ERA, CE);
if (era == BCE) {
eyear = 1 - internalGet(YEAR, 1); // Convert to extended year
} else {
eyear = internalGet(YEAR, 1); // Default to year 1
}
}
return eyear;
}
/**
* {@inheritDoc}
* @internal
* @deprecated This API is ICU internal only.
*/
protected void handleComputeFields(int julianDay) {
int era, year;
int[] fields = new int[3];
jdToCE(julianDay, getJDEpochOffset(), fields);
// fields[0] eyear
// fields[1] month
// fields[2] day
if (fields[0] <= 0) {
era = BCE;
year = 1 - fields[0];
} else {
era = CE;
year = fields[0];
}
internalSet(EXTENDED_YEAR, fields[0]);
internalSet(ERA, era);
internalSet(YEAR, year);
internalSet(MONTH, fields[1]);
internalSet(DAY_OF_MONTH, fields[2]);
internalSet(DAY_OF_YEAR, (30 * fields[1]) + fields[2]);
}
/**
* {@inheritDoc}
* @internal
* @deprecated This API is ICU internal only.
*/
protected int getJDEpochOffset() {
return JD_EPOCH_OFFSET;
}
/**
* Convert an Coptic year, month, and day to a Julian day.
*
* @param year the year
* @param month the month
* @param date the day
* @draft ICU 3.4 (retain)
* @provisional This API might change or be removed in a future release.
*/
// The equivalent operation can be done by public Calendar API.
// This API was accidentally marked as @draft, but we have no good
// reason to keep this. For now, we leave it as is, but may be
// removed in future. 2008-03-21 yoshito
public static int copticToJD(long year, int month, int date) {
return ceToJD(year, month, date, JD_EPOCH_OFFSET);
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/VersionInfo.java 0000644 0001750 0001750 00000036522 11335042151 021611 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2010, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.HashMap;
/**
* Class to store version numbers of the form major.minor.milli.micro.
* @author synwee
* @stable ICU 2.6
*/
public final class VersionInfo implements Comparable
{
// public data members -------------------------------------------------
/**
* Unicode 1.0 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_1_0;
/**
* Unicode 1.0.1 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_1_0_1;
/**
* Unicode 1.1.0 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_1_1_0;
/**
* Unicode 1.1.5 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_1_1_5;
/**
* Unicode 2.0 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_2_0;
/**
* Unicode 2.1.2 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_2_1_2;
/**
* Unicode 2.1.5 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_2_1_5;
/**
* Unicode 2.1.8 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_2_1_8;
/**
* Unicode 2.1.9 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_2_1_9;
/**
* Unicode 3.0 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_3_0;
/**
* Unicode 3.0.1 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_3_0_1;
/**
* Unicode 3.1.0 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_3_1_0;
/**
* Unicode 3.1.1 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_3_1_1;
/**
* Unicode 3.2 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_3_2;
/**
* Unicode 4.0 version
* @stable ICU 2.6
*/
public static final VersionInfo UNICODE_4_0;
/**
* Unicode 4.0.1 version
* @stable ICU 3.4
*/
public static final VersionInfo UNICODE_4_0_1;
/**
* Unicode 4.1 version
* @stable ICU 3.4
*/
public static final VersionInfo UNICODE_4_1;
/**
* Unicode 5.0 version
* @stable ICU 3.4
*/
public static final VersionInfo UNICODE_5_0;
/**
* Unicode 5.1 version
* @stable ICU 4.2
*/
public static final VersionInfo UNICODE_5_1;
/**
* ICU4J current release version
* @stable ICU 2.8
*/
public static final VersionInfo ICU_VERSION;
/**
* Data version string for ICU's internal data
* @internal
* @deprecated This API is ICU internal only.
*/
public static final String ICU_DATA_VERSION = "42b";
/**
* ICU4J collator runtime version
* @stable ICU 2.8
*/
public static final VersionInfo UCOL_RUNTIME_VERSION;
/**
* ICU4J collator builder version
* @stable ICU 2.8
*/
public static final VersionInfo UCOL_BUILDER_VERSION;
/**
* ICU4J collator tailorings version
* @stable ICU 2.8
*/
public static final VersionInfo UCOL_TAILORINGS_VERSION;
// public methods ------------------------------------------------------
/**
* Returns an instance of VersionInfo with the argument version.
* @param version version String in the format of "major.minor.milli.micro"
* or "major.minor.milli" or "major.minor" or "major",
* where major, minor, milli, micro are non-negative numbers
* <= 255. If the trailing version numbers are
* not specified they are taken as 0s. E.g. Version "3.1" is
* equivalent to "3.1.0.0".
* @return an instance of VersionInfo with the argument version.
* @exception throws an IllegalArgumentException when the argument version
* is not in the right format
* @stable ICU 2.6
*/
public static VersionInfo getInstance(String version)
{
int length = version.length();
int array[] = {0, 0, 0, 0};
int count = 0;
int index = 0;
while (count < 4 && index < length) {
char c = version.charAt(index);
if (c == '.') {
count ++;
}
else {
c -= '0';
if (c < 0 || c > 9) {
throw new IllegalArgumentException(INVALID_VERSION_NUMBER_);
}
array[count] *= 10;
array[count] += c;
}
index ++;
}
if (index != length) {
throw new IllegalArgumentException(
"Invalid version number: String '" + version + "' exceeds version format");
}
for (int i = 0; i < 4; i ++) {
if (array[i] < 0 || array[i] > 255) {
throw new IllegalArgumentException(INVALID_VERSION_NUMBER_);
}
}
return getInstance(array[0], array[1], array[2], array[3]);
}
/**
* Returns an instance of VersionInfo with the argument version.
* @param major major version, non-negative number <= 255.
* @param minor minor version, non-negative number <= 255.
* @param milli milli version, non-negative number <= 255.
* @param micro micro version, non-negative number <= 255.
* @exception throws an IllegalArgumentException when either arguments are
* negative or > 255
* @stable ICU 2.6
*/
public static VersionInfo getInstance(int major, int minor, int milli,
int micro)
{
// checks if it is in the hashmap
// else
if (major < 0 || major > 255 || minor < 0 || minor > 255 ||
milli < 0 || milli > 255 || micro < 0 || micro > 255) {
throw new IllegalArgumentException(INVALID_VERSION_NUMBER_);
}
int version = getInt(major, minor, milli, micro);
Integer key = new Integer(version);
Object result = MAP_.get(key);
if (result == null) {
result = new VersionInfo(version);
MAP_.put(key, result);
}
return (VersionInfo)result;
}
/**
* Returns an instance of VersionInfo with the argument version.
* Equivalent to getInstance(major, minor, milli, 0).
* @param major major version, non-negative number <= 255.
* @param minor minor version, non-negative number <= 255.
* @param milli milli version, non-negative number <= 255.
* @exception throws an IllegalArgumentException when either arguments are
* negative or > 255
* @stable ICU 2.6
*/
public static VersionInfo getInstance(int major, int minor, int milli)
{
return getInstance(major, minor, milli, 0);
}
/**
* Returns an instance of VersionInfo with the argument version.
* Equivalent to getInstance(major, minor, 0, 0).
* @param major major version, non-negative number <= 255.
* @param minor minor version, non-negative number <= 255.
* @exception throws an IllegalArgumentException when either arguments are
* negative or > 255
* @stable ICU 2.6
*/
public static VersionInfo getInstance(int major, int minor)
{
return getInstance(major, minor, 0, 0);
}
/**
* Returns an instance of VersionInfo with the argument version.
* Equivalent to getInstance(major, 0, 0, 0).
* @param major major version, non-negative number <= 255.
* @exception throws an IllegalArgumentException when either arguments are
* negative or > 255
* @stable ICU 2.6
*/
public static VersionInfo getInstance(int major)
{
return getInstance(major, 0, 0, 0);
}
private static VersionInfo javaVersion;
/**
* @internal
* @deprecated This API is ICU internal only.
*/
public static VersionInfo javaVersion() {
if (javaVersion == null) {
String s = System.getProperty("java.version");
// clean string
// preserve only digits, separated by single '.'
// ignore over 4 digit sequences
// does not test < 255, very odd...
char[] chars = s.toCharArray();
int r = 0, w = 0, count = 0;
boolean numeric = false; // ignore leading non-numerics
while (r < chars.length) {
char c = chars[r++];
if (c < '0' || c > '9') {
if (numeric) {
if (count == 3) {
// only four digit strings allowed
break;
}
numeric = false;
chars[w++] = '.';
++count;
}
} else {
numeric = true;
chars[w++] = c;
}
}
while (w > 0 && chars[w-1] == '.') {
--w;
}
String vs = new String(chars, 0, w);
javaVersion = VersionInfo.getInstance(vs);
}
return javaVersion;
}
/**
* Returns the String representative of VersionInfo in the format of
* "major.minor.milli.micro"
* @return String representative of VersionInfo
* @stable ICU 2.6
*/
public String toString()
{
StringBuffer result = new StringBuffer(7);
result.append(getMajor());
result.append('.');
result.append(getMinor());
result.append('.');
result.append(getMilli());
result.append('.');
result.append(getMicro());
return result.toString();
}
/**
* Returns the major version number
* @return the major version number
* @stable ICU 2.6
*/
public int getMajor()
{
return (m_version_ >> 24) & LAST_BYTE_MASK_ ;
}
/**
* Returns the minor version number
* @return the minor version number
* @stable ICU 2.6
*/
public int getMinor()
{
return (m_version_ >> 16) & LAST_BYTE_MASK_ ;
}
/**
* Returns the milli version number
* @return the milli version number
* @stable ICU 2.6
*/
public int getMilli()
{
return (m_version_ >> 8) & LAST_BYTE_MASK_ ;
}
/**
* Returns the micro version number
* @return the micro version number
* @stable ICU 2.6
*/
public int getMicro()
{
return m_version_ & LAST_BYTE_MASK_ ;
}
/**
* Checks if this version information is equals to the argument version
* @param other object to be compared
* @return true if other is equals to this object's version information,
* false otherwise
* @stable ICU 2.6
*/
public boolean equals(Object other)
{
return other == this;
}
/**
* Compares other with this VersionInfo.
* @param other VersionInfo to be compared
* @return 0 if the argument is a VersionInfo object that has version
* information equals to this object.
* Less than 0 if the argument is a VersionInfo object that has
* version information greater than this object.
* Greater than 0 if the argument is a VersionInfo object that
* has version information less than this object.
* @stable ICU 2.6
*/
public int compareTo(VersionInfo other)
{
return m_version_ - other.m_version_;
}
/**
* Compares other with this VersionInfo.
* @param other VersionInfo to be compared. Throws ClassCastException if not a VersionInfo.
* @return 0 if the argument is a VersionInfo object that has version
* information equals to this object.
* Less than 0 if the argument is a VersionInfo object that has
* version information greater than this object.
* Greater than 0 if the argument is a VersionInfo object that
* has version information less than this object.
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public int compareTo(Object other) {
return compareTo((VersionInfo)other);
}
// private data members ----------------------------------------------
/**
* Version number stored as a byte for each of the major, minor, milli and
* micro numbers in the 32 bit int.
* Most significant for the major and the least significant contains the
* micro numbers.
*/
private int m_version_;
/**
* Map of singletons
*/
private static final HashMap MAP_ = new HashMap();
/**
* Last byte mask
*/
private static final int LAST_BYTE_MASK_ = 0xFF;
/**
* Error statement string
*/
private static final String INVALID_VERSION_NUMBER_ =
"Invalid version number: Version number may be negative or greater than 255";
// static declaration ------------------------------------------------
/**
* Initialize versions only after MAP_ has been created
*/
static {
UNICODE_1_0 = getInstance(1, 0, 0, 0);
UNICODE_1_0_1 = getInstance(1, 0, 1, 0);
UNICODE_1_1_0 = getInstance(1, 1, 0, 0);
UNICODE_1_1_5 = getInstance(1, 1, 5, 0);
UNICODE_2_0 = getInstance(2, 0, 0, 0);
UNICODE_2_1_2 = getInstance(2, 1, 2, 0);
UNICODE_2_1_5 = getInstance(2, 1, 5, 0);
UNICODE_2_1_8 = getInstance(2, 1, 8, 0);
UNICODE_2_1_9 = getInstance(2, 1, 9, 0);
UNICODE_3_0 = getInstance(3, 0, 0, 0);
UNICODE_3_0_1 = getInstance(3, 0, 1, 0);
UNICODE_3_1_0 = getInstance(3, 1, 0, 0);
UNICODE_3_1_1 = getInstance(3, 1, 1, 0);
UNICODE_3_2 = getInstance(3, 2, 0, 0);
UNICODE_4_0 = getInstance(4, 0, 0, 0);
UNICODE_4_0_1 = getInstance(4, 0, 1, 0);
UNICODE_4_1 = getInstance(4, 1, 0, 0);
UNICODE_5_0 = getInstance(5, 0, 0, 0);
UNICODE_5_1 = getInstance(5, 1, 0, 0);
ICU_VERSION = getInstance(4, 2, 1, 1);
UCOL_RUNTIME_VERSION = getInstance(6);
UCOL_BUILDER_VERSION = getInstance(7);
UCOL_TAILORINGS_VERSION = getInstance(1);
}
// private constructor -----------------------------------------------
/**
* Constructor with int
* @param compactversion a 32 bit int with each byte representing a number
*/
private VersionInfo(int compactversion)
{
m_version_ = compactversion;
}
/**
* Gets the int from the version numbers
* @param major non-negative version number
* @param minor non-negativeversion number
* @param milli non-negativeversion number
* @param micro non-negativeversion number
*/
private static int getInt(int major, int minor, int milli, int micro)
{
return (major << 24) | (minor << 16) | (milli << 8) | micro;
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/JapaneseCalendar.java 0000644 0001750 0001750 00000060055 11157074147 022542 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2009, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import com.ibm.icu.util.TimeZone;
import java.util.Date;
import java.util.Locale;
/**
* JapaneseCalendar is a subclass of GregorianCalendar
* that numbers years and eras based on the reigns of the Japanese emperors.
* The Japanese calendar is identical to the Gregorian calendar in all respects
* except for the year and era. The ascension of each emperor to the throne
* begins a new era, and the years of that era are numbered starting with the
* year of ascension as year 1.
* * Note that in the year of an imperial ascension, there are two possible sets * of year and era values: that for the old era and for the new. For example, a * new era began on January 7, 1989 AD. Strictly speaking, the first six days * of that year were in the Showa era, e.g. "January 6, 64 Showa", while the rest * of the year was in the Heisei era, e.g. "January 7, 1 Heisei". This class * handles this distinction correctly when computing dates. However, in lenient * mode either form of date is acceptable as input. *
* In modern times, eras have started on January 8, 1868 AD, Gregorian (Meiji),
* July 30, 1912 (Taisho), December 25, 1926 (Showa), and January 7, 1989 (Heisei). Constants
* for these eras, suitable for use in the ERA field, are provided
* in this class. Note that the number used for each era is more or
* less arbitrary. Currently, the era starting in 1053 AD is era #0; however this
* may change in the future as we add more historical data. Use the predefined
* constants rather than using actual, absolute numbers.
*
* This class should not be subclassed.
*
* JapaneseCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a ULocale
* with the tag "@calendar=japanese".
JapaneseCalendar using the current time
* in the default time zone with the default locale.
* @stable ICU 2.8
*/
public JapaneseCalendar() {
super();
}
/**
* Constructs a JapaneseCalendar based on the current time
* in the given time zone with the default locale.
* @param zone the given time zone.
* @stable ICU 2.8
*/
public JapaneseCalendar(TimeZone zone) {
super(zone);
}
/**
* Constructs a JapaneseCalendar based on the current time
* in the default time zone with the given locale.
* @param aLocale the given locale.
* @stable ICU 2.8
*/
public JapaneseCalendar(Locale aLocale) {
super(aLocale);
}
/**
* Constructs a JapaneseCalendar based on the current time
* in the default time zone with the given locale.
* @param locale the given ulocale.
* @stable ICU 3.2
*/
public JapaneseCalendar(ULocale locale) {
super(locale);
}
/**
* Constructs a JapaneseCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone the given time zone.
*
* @param aLocale the given locale.
* @stable ICU 2.8
*/
public JapaneseCalendar(TimeZone zone, Locale aLocale) {
super(zone, aLocale);
}
/**
* Constructs a JapaneseCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone the given time zone.
*
* @param locale the given ulocale.
* @stable ICU 3.2
*/
public JapaneseCalendar(TimeZone zone, ULocale locale) {
super(zone, locale);
}
/**
* Constructs a JapaneseCalendar with the given date set
* in the default time zone with the default locale.
*
* @param date The date to which the new calendar is set.
* @stable ICU 2.8
*/
public JapaneseCalendar(Date date) {
this();
setTime(date);
}
/**
* Constructs a JapaneseCalendar with the given date set
* in the default time zone with the default locale.
*
* @param era The imperial era used to set the calendar's {@link #ERA ERA} field.
* Eras are numbered starting with the Tenki era, which
* began in 1053 AD Gregorian, as era zero. Recent
* eras can be specified using the constants
* {@link #MEIJI} (which started in 1868 AD),
* {@link #TAISHO} (1912 AD),
* {@link #SHOWA} (1926 AD), and
* {@link #HEISEI} (1989 AD).
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} field,
* in terms of the era.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} field.
* The value is 0-based. e.g., 0 for January.
*
* @param date The value used to set the calendar's DATE field.
* @stable ICU 2.8
*/
public JapaneseCalendar(int era, int year, int month, int date) {
super(year, month, date);
set(ERA, era);
}
/**
* Constructs a JapaneseCalendar with the given date set
* in the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} field,
* in the era Heisei, the most current at the time this
* class was last updated.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} field.
* The value is 0-based. e.g., 0 for January.
*
* @param date The value used to set the calendar's {@link #DATE DATE} field.
* @stable ICU 2.8
*/
public JapaneseCalendar(int year, int month, int date) {
super(year, month, date);
set(ERA, CURRENT_ERA);
}
/**
* Constructs a JapaneseCalendar with the given date
* and time set for the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field,
* in the era Heisei, the most current at the time of this
* writing.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for January.
*
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
*
* @param hour The value used to set the calendar's {@link #HOUR_OF_DAY HOUR_OF_DAY} time field.
*
* @param minute The value used to set the calendar's {@link #MINUTE MINUTE} time field.
*
* @param second The value used to set the calendar's {@link #SECOND SECOND} time field.
* @stable ICU 2.8
*/
public JapaneseCalendar(int year, int month, int date, int hour,
int minute, int second)
{
super(year, month, date, hour, minute, second);
set(ERA, CURRENT_ERA);
}
//-------------------------------------------------------------------------
// Use 1970 as the default value of EXTENDED_YEAR
private static final int GREGORIAN_EPOCH = 1970;
/**
* @stable ICU 2.8
*/
protected int handleGetExtendedYear() {
// EXTENDED_YEAR in JapaneseCalendar is a Gregorian year
// The default value of EXTENDED_YEAR is 1970 (Showa 45)
int year;
if (newerField(EXTENDED_YEAR, YEAR) == EXTENDED_YEAR &&
newerField(EXTENDED_YEAR, ERA) == EXTENDED_YEAR) {
year = internalGet(EXTENDED_YEAR, GREGORIAN_EPOCH);
} else {
// extended year is a gregorian year, where 1 = 1AD, 0 = 1BC, -1 = 2BC, etc
year = internalGet(YEAR, 1) // pin to minimum of year 1 (first year)
+ ERAS[internalGet(ERA, CURRENT_ERA) * 3] // add gregorian starting year
- 1; // Subtract one because year starts at 1
}
return year;
}
/**
* Called by handleComputeJulianDay. Returns the default month (0-based) for the year,
* taking year and era into account. Defaults to 0 (JANUARY) for Gregorian.
* @param extendedYear the extendedYear, as returned by handleGetExtendedYear
* @return the default month
* @provisional ICU 3.6
* @draft ICU 3.6 (retain)
* @see #MONTH
*/
protected int getDefaultMonthInYear(int extendedYear)
{
int era = internalGet(ERA, CURRENT_ERA);
//computeFields(status); // No need to compute fields here - expect the caller already did so.
// Find out if we are at the edge of an era
if(extendedYear == ERAS[era*3]) {
return ERAS[(era*3)+1] // month..
-1; // return 0-based month
} else {
return super.getDefaultMonthInYear(extendedYear);
}
}
/**
* Called by handleComputeJulianDay. Returns the default day (1-based) for the month,
* taking currently-set year and era into account. Defaults to 1 for Gregorian.
* @param extendedYear the extendedYear, as returned by handleGetExtendedYear
* @param month the month, as returned by getDefaultMonthInYear
* @return the default day of the month
* @draft ICU 3.6 (retain)
* @provisional ICU 3.6
* @see #DAY_OF_MONTH
*/
protected int getDefaultDayInMonth(int extendedYear, int month) {
int era = internalGet(ERA, CURRENT_ERA);
if(extendedYear == ERAS[era*3]) { // if it is year 1..
if(month == ((ERAS[(era*3)+1])-1)) { // if it is the emperor's first month..
return ERAS[(era*3)+2]; // return the D_O_M of acession
}
}
return super.getDefaultDayInMonth(extendedYear, month);
}
/**
* @stable ICU 2.8
*/
protected void handleComputeFields(int julianDay) {
super.handleComputeFields(julianDay);
int year = internalGet(EXTENDED_YEAR);
int low = 0;
// Short circuit for recent years. Most modern computations will
// occur in the current era and won't require the binary search.
// Note that if the year is == the current era year, then we use
// the binary search to handle the month/dom comparison.
if (year > ERAS[ERAS.length - 3]) {
low = CURRENT_ERA;
} else {
// Binary search
int high = ERAS.length / 3;
while (low < high - 1) {
int i = (low + high) / 2;
int diff = year - ERAS[i*3];
// If years are the same, then compare the months, and if those
// are the same, compare days of month. In the ERAS array
// months are 1-based for easier maintenance.
if (diff == 0) {
diff = internalGet(MONTH) - (ERAS[i*3 + 1] - 1);
if (diff == 0) {
diff = internalGet(DAY_OF_MONTH) - ERAS[i*3 + 2];
}
}
if (diff >= 0) {
low = i;
} else {
high = i;
}
}
}
// Now we've found the last era that starts before this date, so
// adjust the year to count from the start of that era. Note that
// all dates before the first era will fall into the first era by
// the algorithm.
internalSet(ERA, low);
internalSet(YEAR, year - ERAS[low*3] + 1);
}
private static final int[] ERAS = {
// Gregorian date of each emperor's ascension
// Years are AD, months are 1-based.
// Year Month Day
645, 6, 19, // Taika
650, 2, 15, // Hakuchi
672, 1, 1, // Hakuho
686, 7, 20, // Shucho
701, 3, 21, // Taiho
704, 5, 10, // Keiun
708, 1, 11, // Wado
715, 9, 2, // Reiki
717, 11, 17, // Yoro
724, 2, 4, // Jinki
729, 8, 5, // Tempyo
749, 4, 14, // Tempyo-kampo
749, 7, 2, // Tempyo-shoho
757, 8, 18, // Tempyo-hoji
765, 1, 7, // Tempho-jingo
767, 8, 16, // Jingo-keiun
770, 10, 1, // Hoki
781, 1, 1, // Ten-o
782, 8, 19, // Enryaku
806, 5, 18, // Daido
810, 9, 19, // Konin
824, 1, 5, // Tencho
834, 1, 3, // Showa
848, 6, 13, // Kajo
851, 4, 28, // Ninju
854, 11, 30, // Saiko
857, 2, 21, // Tennan
859, 4, 15, // Jogan
877, 4, 16, // Genkei
885, 2, 21, // Ninna
889, 4, 27, // Kampyo
898, 4, 26, // Shotai
901, 7, 15, // Engi
923, 4, 11, // Encho
931, 4, 26, // Shohei
938, 5, 22, // Tengyo
947, 4, 22, // Tenryaku
957, 10, 27, // Tentoku
961, 2, 16, // Owa
964, 7, 10, // Koho
968, 8, 13, // Anna
970, 3, 25, // Tenroku
973, 12, 20, // Ten-en
976, 7, 13, // Jogen
978, 11, 29, // Tengen
983, 4, 15, // Eikan
985, 4, 27, // Kanna
987, 4, 5, // Ei-en
989, 8, 8, // Eiso
990, 11, 7, // Shoryaku
995, 2, 22, // Chotoku
999, 1, 13, // Choho
1004, 7, 20, // Kanko
1012, 12, 25, // Chowa
1017, 4, 23, // Kannin
1021, 2, 2, // Jian
1024, 7, 13, // Manju
1028, 7, 25, // Chogen
1037, 4, 21, // Choryaku
1040, 11, 10, // Chokyu
1044, 11, 24, // Kantoku
1046, 4, 14, // Eisho
1053, 1, 11, // Tengi
1058, 8, 29, // Kohei
1065, 8, 2, // Jiryaku
1069, 4, 13, // Enkyu
1074, 8, 23, // Shoho
1077, 11, 17, // Shoryaku
1081, 2, 10, // Eiho
1084, 2, 7, // Otoku
1087, 4, 7, // Kanji
1094, 12, 15, // Kaho
1096, 12, 17, // Eicho
1097, 11, 21, // Shotoku
1099, 8, 28, // Kowa
1104, 2, 10, // Choji
1106, 4, 9, // Kasho
1108, 8, 3, // Tennin
1110, 7, 13, // Ten-ei
1113, 7, 13, // Eikyu
1118, 4, 3, // Gen-ei
1120, 4, 10, // Hoan
1124, 4, 3, // Tenji
1126, 1, 22, // Daiji
1131, 1, 29, // Tensho
1132, 8, 11, // Chosho
1135, 4, 27, // Hoen
1141, 7, 10, // Eiji
1142, 4, 28, // Koji
1144, 2, 23, // Tenyo
1145, 7, 22, // Kyuan
1151, 1, 26, // Ninpei
1154, 10, 28, // Kyuju
1156, 4, 27, // Hogen
1159, 4, 20, // Heiji
1160, 1, 10, // Eiryaku
1161, 9, 4, // Oho
1163, 3, 29, // Chokan
1165, 6, 5, // Eiman
1166, 8, 27, // Nin-an
1169, 4, 8, // Kao
1171, 4, 21, // Shoan
1175, 7, 28, // Angen
1177, 8, 4, // Jisho
1181, 7, 14, // Yowa
1182, 5, 27, // Juei
1184, 4, 16, // Genryuku
1185, 8, 14, // Bunji
1190, 4, 11, // Kenkyu
1199, 4, 27, // Shoji
1201, 2, 13, // Kennin
1204, 2, 20, // Genkyu
1206, 4, 27, // Ken-ei
1207, 10, 25, // Shogen
1211, 3, 9, // Kenryaku
1213, 12, 6, // Kenpo
1219, 4, 12, // Shokyu
1222, 4, 13, // Joo
1224, 11, 20, // Gennin
1225, 4, 20, // Karoku
1227, 12, 10, // Antei
1229, 3, 5, // Kanki
1232, 4, 2, // Joei
1233, 4, 15, // Tempuku
1234, 11, 5, // Bunryaku
1235, 9, 19, // Katei
1238, 11, 23, // Ryakunin
1239, 2, 7, // En-o
1240, 7, 16, // Ninji
1243, 2, 26, // Kangen
1247, 2, 28, // Hoji
1249, 3, 18, // Kencho
1256, 10, 5, // Kogen
1257, 3, 14, // Shoka
1259, 3, 26, // Shogen
1260, 4, 13, // Bun-o
1261, 2, 20, // Kocho
1264, 2, 28, // Bun-ei
1275, 4, 25, // Kenji
1278, 2, 29, // Koan
1288, 4, 28, // Shoo
1293, 8, 55, // Einin
1299, 4, 25, // Shoan
1302, 11, 21, // Kengen
1303, 8, 5, // Kagen
1306, 12, 14, // Tokuji
1308, 10, 9, // Enkei
1311, 4, 28, // Ocho
1312, 3, 20, // Showa
1317, 2, 3, // Bunpo
1319, 4, 28, // Geno
1321, 2, 23, // Genkyo
1324, 12, 9, // Shochu
1326, 4, 26, // Kareki
1329, 8, 29, // Gentoku
1331, 8, 9, // Genko
1334, 1, 29, // Kemmu
1336, 2, 29, // Engen
1340, 4, 28, // Kokoku
1346, 12, 8, // Shohei
1370, 7, 24, // Kentoku
1372, 4, 1, // Bunch\u0169
1375, 5, 27, // Tenju
1379, 3, 22, // Koryaku
1381, 2, 10, // Kowa
1384, 4, 28, // Gench\u0169
1384, 2, 27, // Meitoku
1387, 8, 23, // Kakei
1389, 2, 9, // Koo
1390, 3, 26, // Meitoku
1394, 7, 5, // Oei
1428, 4, 27, // Shocho
1429, 9, 5, // Eikyo
1441, 2, 17, // Kakitsu
1444, 2, 5, // Bun-an
1449, 7, 28, // Hotoku
1452, 7, 25, // Kyotoku
1455, 7, 25, // Kosho
1457, 9, 28, // Choroku
1460, 12, 21, // Kansho
1466, 2, 28, // Bunsho
1467, 3, 3, // Onin
1469, 4, 28, // Bunmei
1487, 7, 29, // Chokyo
1489, 8, 21, // Entoku
1492, 7, 19, // Meio
1501, 2, 29, // Bunki
1504, 2, 30, // Eisho
1521, 8, 23, // Taiei
1528, 8, 20, // Kyoroku
1532, 7, 29, // Tenmon
1555, 10, 23, // Koji
1558, 2, 28, // Eiroku
1570, 4, 23, // Genki
1573, 7, 28, // Tensho
1592, 12, 8, // Bunroku
1596, 10, 27, // Keicho
1615, 7, 13, // Genwa
1624, 2, 30, // Kan-ei
1644, 12, 16, // Shoho
1648, 2, 15, // Keian
1652, 9, 18, // Shoo
1655, 4, 13, // Meiryaku
1658, 7, 23, // Manji
1661, 4, 25, // Kanbun
1673, 9, 21, // Enpo
1681, 9, 29, // Tenwa
1684, 2, 21, // Jokyo
1688, 9, 30, // Genroku
1704, 3, 13, // Hoei
1711, 4, 25, // Shotoku
1716, 6, 22, // Kyoho
1736, 4, 28, // Genbun
1741, 2, 27, // Kanpo
1744, 2, 21, // Enkyo
1748, 7, 12, // Kan-en
1751, 10, 27, // Horyaku
1764, 6, 2, // Meiwa
1772, 11, 16, // An-ei
1781, 4, 2, // Tenmei
1789, 1, 25, // Kansei
1801, 2, 5, // Kyowa
1804, 2, 11, // Bunka
1818, 4, 22, // Bunsei
1830, 12, 10, // Tenpo
1844, 12, 2, // Koka
1848, 2, 28, // Kaei
1854, 11, 27, // Ansei
1860, 3, 18, // Man-en
1861, 2, 19, // Bunkyu
1864, 2, 20, // Genji
1865, 4, 7, // Keio
1868, 9, 8, // Meiji
1912, 7, 30, // Taisho
1926, 12, 25, // Showa
1989, 1, 8, // Heisei
};
//-------------------------------------------------------------------------
// Public constants for some of the recent eras that folks might use...
//-------------------------------------------------------------------------
// Constant for the current era. This must be regularly updated.
/**
* @stable ICU 2.8
*/
static public final int CURRENT_ERA = (ERAS.length / 3) - 1;
/**
* Constant for the era starting on Sept. 8, 1868 AD.
* @stable ICU 2.8
*/
static public final int MEIJI = CURRENT_ERA - 3;
/**
* Constant for the era starting on July 30, 1912 AD.
* @stable ICU 2.8
*/
static public final int TAISHO = CURRENT_ERA - 2;
/**
* Constant for the era starting on Dec. 25, 1926 AD.
* @stable ICU 2.8
*/
static public final int SHOWA = CURRENT_ERA - 1;
/**
* Constant for the era starting on Jan. 7, 1989 AD.
* @stable ICU 2.8
*/
static public final int HEISEI = CURRENT_ERA;
/**
* Override GregorianCalendar. We should really handle YEAR_WOY and
* EXTENDED_YEAR here too to implement the 1..5000000 range, but it's
* not critical.
* @stable ICU 2.8
*/
protected int handleGetLimit(int field, int limitType) {
switch (field) {
case ERA:
if (limitType == MINIMUM || limitType == GREATEST_MINIMUM) {
return 1;
}
return CURRENT_ERA;
case YEAR:
{
switch (limitType) {
case MINIMUM:
case GREATEST_MINIMUM:
return 1;
case LEAST_MAXIMUM:
return 1;
case MAXIMUM:
return super.handleGetLimit(field, MAXIMUM) - ERAS[CURRENT_ERA*3];
}
}
default:
return super.handleGetLimit(field, limitType);
}
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public String getType() {
return "japanese";
}
/**
* {@inheritDoc}
* @stable ICU 4.0
*/
public int getActualMaximum(int field) {
if (field == YEAR) {
int era = get(Calendar.ERA);
if (era == CURRENT_ERA) {
// TODO: Investigate what value should be used here - revisit after 4.0.
return handleGetLimit(YEAR, MAXIMUM);
} else {
int nextEraYear = ERAS[(era+1)*3];
int nextEraMonth = ERAS[(era+1)*3 + 1];
int nextEraDate = ERAS[(era+1)*3 + 2];
int maxYear = nextEraYear - ERAS[era*3] + 1; // 1-base
if (nextEraMonth == 1 && nextEraDate == 1) {
// Substract 1, because the next era starts at Jan 1
maxYear--;
}
return maxYear;
}
}
return super.getActualMaximum(field);
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/IllformedLocaleException.java 0000644 0001750 0001750 00000003547 11156630077 024300 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2009, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
/**
* Thrown by methods in Locale class to indicate that a locale string
* is illformed.
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public class IllformedLocaleException extends IllegalArgumentException {
private static final long serialVersionUID = 1L;
private int _errIdx = -1;
/**
* Constructs a new IllformedLocaleException with
* the detail message.
* @param msg the detail message
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public IllformedLocaleException(String msg) {
this(msg, -1);
}
/**
* Constructs a new IllformedLocaleException with
* the detail message and the error index.
* @param msg the detail message
* @param errIdx the index where the error is found in a locale string
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public IllformedLocaleException(String msg, int errIdx) {
super(msg + ((errIdx == -1) ? "" : " [at index " + errIdx + "]"));
_errIdx = errIdx;
}
/**
* Returns the index where the error is found in a locale string
* @return the index where the error is found in a locale string or
* -1 if unknown.
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public int getErrorIndex() {
return _errIdx;
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/EasterHoliday.java 0000644 0001750 0001750 00000024124 10666355147 022122 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2006, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.Date;
/**
* A Holiday subclass which represents holidays that occur
* a fixed number of days before or after Easter. Supports both the
* Western and Orthodox methods for calculating Easter.
* @draft ICU 2.8 (retainAll)
* @provisional This API might change or be removed in a future release.
*/
public class EasterHoliday extends Holiday
{
/**
* Construct a holiday that falls on Easter Sunday every year
*
* @param name The name of the holiday
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public EasterHoliday(String name)
{
super(name, new EasterRule(0, false));
}
/**
* Construct a holiday that falls a specified number of days before
* or after Easter Sunday each year.
*
* @param daysAfter The number of days before (-) or after (+) Easter
* @param name The name of the holiday
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public EasterHoliday(int daysAfter, String name)
{
super(name, new EasterRule(daysAfter, false));
}
/**
* Construct a holiday that falls a specified number of days before
* or after Easter Sunday each year, using either the Western
* or Orthodox calendar.
*
* @param daysAfter The number of days before (-) or after (+) Easter
* @param orthodox Use the Orthodox calendar?
* @param name The name of the holiday
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public EasterHoliday(int daysAfter, boolean orthodox, String name)
{
super(name, new EasterRule(daysAfter, orthodox));
}
/**
* Shrove Tuesday, aka Mardi Gras, 48 days before Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday SHROVE_TUESDAY = new EasterHoliday(-48, "Shrove Tuesday");
/**
* Ash Wednesday, start of Lent, 47 days before Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday ASH_WEDNESDAY = new EasterHoliday(-47, "Ash Wednesday");
/**
* Palm Sunday, 7 days before Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday PALM_SUNDAY = new EasterHoliday( -7, "Palm Sunday");
/**
* Maundy Thursday, 3 days before Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday MAUNDY_THURSDAY = new EasterHoliday( -3, "Maundy Thursday");
/**
* Good Friday, 2 days before Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday GOOD_FRIDAY = new EasterHoliday( -2, "Good Friday");
/**
* Easter Sunday
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday EASTER_SUNDAY = new EasterHoliday( 0, "Easter Sunday");
/**
* Easter Monday, 1 day after Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday EASTER_MONDAY = new EasterHoliday( 1, "Easter Monday");
/**
* Ascension, 39 days after Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday ASCENSION = new EasterHoliday( 39, "Ascension");
/**
* Pentecost (aka Whit Sunday), 49 days after Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday PENTECOST = new EasterHoliday( 49, "Pentecost");
/**
* Whit Sunday (aka Pentecost), 49 days after Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday WHIT_SUNDAY = new EasterHoliday( 49, "Whit Sunday");
/**
* Whit Monday, 50 days after Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday WHIT_MONDAY = new EasterHoliday( 50, "Whit Monday");
/**
* Corpus Christi, 60 days after Easter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
static public final EasterHoliday CORPUS_CHRISTI = new EasterHoliday( 60, "Corpus Christi");
}
class EasterRule implements DateRule {
public EasterRule(int daysAfterEaster, boolean isOrthodox) {
this.daysAfterEaster = daysAfterEaster;
if (isOrthodox) {
orthodox.setGregorianChange(new Date(Long.MAX_VALUE));
calendar = orthodox;
}
}
/**
* Return the first occurrance of this rule on or after the given date
*/
public Date firstAfter(Date start)
{
return doFirstBetween(start, null);
}
/**
* Return the first occurrance of this rule on or after
* the given start date and before the given end date.
*/
public Date firstBetween(Date start, Date end)
{
return doFirstBetween(start, end);
}
/**
* Return true if the given Date is on the same day as Easter
*/
public boolean isOn(Date date)
{
synchronized(calendar) {
calendar.setTime(date);
int dayOfYear = calendar.get(Calendar.DAY_OF_YEAR);
calendar.setTime(computeInYear(calendar.getTime(), calendar));
return calendar.get(Calendar.DAY_OF_YEAR) == dayOfYear;
}
}
/**
* Return true if Easter occurs between the two dates given
*/
public boolean isBetween(Date start, Date end)
{
return firstBetween(start, end) != null; // TODO: optimize?
}
private Date doFirstBetween(Date start, Date end)
{
//System.out.println("doFirstBetween: start = " + start.toString());
//System.out.println("doFirstBetween: end = " + end.toString());
synchronized(calendar) {
// Figure out when this holiday lands in the given year
Date result = computeInYear(start, calendar);
//System.out.println(" result = " + result.toString());
// We might have gotten a date that's in the same year as "start", but
// earlier in the year. If so, go to next year
if (result.before(start))
{
calendar.setTime(start);
calendar.get(Calendar.YEAR); // JDK 1.1.2 bug workaround
calendar.add(Calendar.YEAR, 1);
//System.out.println(" Result before start, going to next year: "
// + calendar.getTime().toString());
result = computeInYear(calendar.getTime(), calendar);
//System.out.println(" result = " + result.toString());
}
if (end != null && result.after(end)) {
//System.out.println("Result after end, returning null");
return null;
}
return result;
}
}
/**
* Compute the month and date on which this holiday falls in the year
* containing the date "date". First figure out which date Easter
* lands on in this year, and then add the offset for this holiday to get
* the right date.
* * The algorithm here is taken from the * Calendar FAQ. */ private Date computeInYear(Date date, GregorianCalendar cal) { if (cal == null) cal = calendar; synchronized(cal) { cal.setTime(date); int year = cal.get(Calendar.YEAR); int g = year % 19; // "Golden Number" of year - 1 int i = 0; // # of days from 3/21 to the Paschal full moon int j = 0; // Weekday (0-based) of Paschal full moon if (cal.getTime().after( cal.getGregorianChange())) { // We're past the Gregorian switchover, so use the Gregorian rules. int c = year / 100; int h = (c - c/4 - (8*c+13)/25 + 19*g + 15) % 30; i = h - (h/28)*(1 - (h/28)*(29/(h+1))*((21-g)/11)); j = (year + year/4 + i + 2 - c + c/4) % 7; } else { // Use the old Julian rules. i = (19*g + 15) % 30; j = (year + year/4 + i) % 7; } int l = i - j; int m = 3 + (l+40)/44; // 1-based month in which Easter falls int d = l + 28 - 31*(m/4); // Date of Easter within that month cal.clear(); cal.set(Calendar.ERA, GregorianCalendar.AD); cal.set(Calendar.YEAR, year); cal.set(Calendar.MONTH, m-1); // 0-based cal.set(Calendar.DATE, d); cal.getTime(); // JDK 1.1.2 bug workaround cal.add(Calendar.DATE, daysAfterEaster); return cal.getTime(); } } private static GregorianCalendar gregorian = new GregorianCalendar(/* new SimpleTimeZone(0, "UTC") */); private static GregorianCalendar orthodox = new GregorianCalendar(/* new SimpleTimeZone(0, "UTC") */); private int daysAfterEaster; private GregorianCalendar calendar = gregorian; } icu4j-4.2.1.1/src/com/ibm/icu/util/package.html 0000644 0001750 0001750 00000000432 10666355147 020777 0 ustar twerner twerner
International calendars and other utility classes. icu4j-4.2.1.1/src/com/ibm/icu/util/UniversalTimeScale.java 0000644 0001750 0001750 00000054011 11015072544 023104 0 ustar twerner twerner /* ********************************************************************************* * Copyright (C) 2004-2008, International Business Machines Corporation and * * others. All Rights Reserved. * ********************************************************************************* * */ package com.ibm.icu.util; import com.ibm.icu.math.BigDecimal; import java.lang.IllegalArgumentException; /** * There are quite a few different conventions for binary datetime, depending on different * platforms and protocols. Some of these have severe drawbacks. For example, people using * Unix time (seconds since Jan 1, 1970, usually in a 32-bit integer) * think that they are safe until near the year 2038. * But cases can and do arise where arithmetic manipulations causes serious problems. Consider * the computation of the average of two datetimes, for example: if one calculates them with *averageTime = (time1 + time2)/2, there will be overflow even with dates
* beginning in 2004. Moreover, even if these problems don't occur, there is the issue of
* conversion back and forth between different systems.
*
* Binary datetimes differ in a number of ways: the datatype, the unit, * and the epoch (origin). We refer to these as time scales.
* *ICU implements a universal time scale that is similar to the * .NET framework's System.DateTime. The universal time scale is a * 64-bit integer that holds ticks since midnight, January 1st, 0001. * (One tick is 100 nanoseconds.) * Negative values are supported. This has enough range to guarantee that * calculations involving dates around the present are safe.
* *The universal time scale always measures time according to the * proleptic Gregorian calendar. That is, the Gregorian calendar's * leap year rules are used for all times, even before 1582 when it was * introduced. (This is different from the default ICU calendar which * switches from the Julian to the Gregorian calendar in 1582. * See GregorianCalendar.setGregorianChange() and ucal_setGregorianChange().)
* * ICU provides conversion functions to and from all other major time * scales, allowing datetimes in any time scale to be converted to the * universal time scale, safely manipulated, and converted back to any other * datetime time scale. * *For more details and background, see the * Universal Time Scale * chapter in the ICU User Guide.
* * @stable ICU 3.2 */ public final class UniversalTimeScale { /** * Used in the JDK. Data is along. Value
* is milliseconds since January 1, 1970.
*
* @stable ICU 3.2
*/
public static final int JAVA_TIME = 0;
/**
* Used in Unix systems. Data is an int or a long. Value
* is seconds since January 1, 1970.
*
* @stable ICU 3.2
*/
public static final int UNIX_TIME = 1;
/**
* Used in the ICU4C. Data is a double. Value
* is milliseconds since January 1, 1970.
*
* @stable ICU 3.2
*/
public static final int ICU4C_TIME = 2;
/**
* Used in Windows for file times. Data is a long. Value
* is ticks (1 tick == 100 nanoseconds) since January 1, 1601.
*
* @stable ICU 3.2
*/
public static final int WINDOWS_FILE_TIME = 3;
/**
* Used in the .NET framework's System.DateTime structure.
* Data is a long. Value is ticks (1 tick == 100 nanoseconds) since January 1, 0001.
*
* @stable ICU 3.2
*/
public static final int DOTNET_DATE_TIME = 4;
/**
* Used in older Macintosh systems. Data is an int. Value
* is seconds since January 1, 1904.
*
* @stable ICU 3.2
*/
public static final int MAC_OLD_TIME = 5;
/**
* Used in the JDK. Data is a double. Value
* is milliseconds since January 1, 2001.
*
* @stable ICU 3.2
*/
public static final int MAC_TIME = 6;
/**
* Used in Excel. Data is a ?unknown?. Value
* is days since December 31, 1899.
*
* @stable ICU 3.2
*/
public static final int EXCEL_TIME = 7;
/**
* Used in DB2. Data is a ?unknown?. Value
* is days since December 31, 1899.
*
* @stable ICU 3.2
*/
public static final int DB2_TIME = 8;
/**
* Data is a long. Value is microseconds since January 1, 1970.
* Similar to Unix time (linear value from 1970) and struct timeval
* (microseconds resolution).
*
* @stable ICU 3.8
*/
public static final int UNIX_MICROSECONDS_TIME = 9;
/**
* This is the first unused time scale value.
*
* @stable ICU 3.2
*/
public static final int MAX_SCALE = 10;
/**
* The constant used to select the units value
* for a time scale.
*
*
* @stable ICU 3.2
*/
public static final int UNITS_VALUE = 0;
/**
* The constant used to select the epoch offset value
* for a time scale.
*
* @see #getTimeScaleValue
*
* @stable ICU 3.2
*/
public static final int EPOCH_OFFSET_VALUE = 1;
/**
* The constant used to select the minimum from value
* for a time scale.
*
* @see #getTimeScaleValue
*
* @stable ICU 3.2
*/
public static final int FROM_MIN_VALUE = 2;
/**
* The constant used to select the maximum from value
* for a time scale.
*
* @see #getTimeScaleValue
*
* @stable ICU 3.2
*/
public static final int FROM_MAX_VALUE = 3;
/**
* The constant used to select the minimum to value
* for a time scale.
*
* @see #getTimeScaleValue
*
* @stable ICU 3.2
*/
public static final int TO_MIN_VALUE = 4;
/**
* The constant used to select the maximum to value
* for a time scale.
*
* @see #getTimeScaleValue
*
* @stable ICU 3.2
*/
public static final int TO_MAX_VALUE = 5;
/**
* The constant used to select the epoch plus one value
* for a time scale.
*
* NOTE: This is an internal value. DO NOT USE IT. May not
* actually be equal to the epoch offset value plus one.
*
* @see #getTimeScaleValue
*
* @stable ICU 3.2
*/
public static final int EPOCH_OFFSET_PLUS_1_VALUE = 6;
/**
* The constant used to select the epoch offset minus one value
* for a time scale.
*
* NOTE: This is an internal value. DO NOT USE IT. May not
* actually be equal to the epoch offset value minus one.
*
* @see #getTimeScaleValue
*
* @internal
* @deprecated This API is ICU internal only.
*/
public static final int EPOCH_OFFSET_MINUS_1_VALUE = 7;
/**
* The constant used to select the units round value
* for a time scale.
*
* NOTE: This is an internal value. DO NOT USE IT.
*
* @see #getTimeScaleValue
*
* @internal
* @deprecated This API is ICU internal only.
*/
public static final int UNITS_ROUND_VALUE = 8;
/**
* The constant used to select the minimum safe rounding value
* for a time scale.
*
* NOTE: This is an internal value. DO NOT USE IT.
*
* @see #getTimeScaleValue
*
* @internal
* @deprecated This API is ICU internal only.
*/
public static final int MIN_ROUND_VALUE = 9;
/**
* The constant used to select the maximum safe rounding value
* for a time scale.
*
* NOTE: This is an internal value. DO NOT USE IT.
*
* @see #getTimeScaleValue
*
* @internal
* @deprecated This API is ICU internal only.
*/
public static final int MAX_ROUND_VALUE = 10;
/**
* The number of time scale values.
*
* NOTE: This is an internal value. DO NOT USE IT.
*
* @see #getTimeScaleValue
*
* @internal
* @deprecated This API is ICU internal only.
*/
public static final int MAX_SCALE_VALUE = 11;
private static final long ticks = 1;
private static final long microseconds = ticks * 10;
private static final long milliseconds = microseconds * 1000;
private static final long seconds = milliseconds * 1000;
private static final long minutes = seconds * 60;
private static final long hours = minutes * 60;
private static final long days = hours * 24;
/**
* This class holds the data that describes a particular
* time scale.
*
* @internal
* @deprecated This API is ICU internal only.
*/
private static final class TimeScaleData
{
TimeScaleData(long theUnits, long theEpochOffset,
long theToMin, long theToMax,
long theFromMin, long theFromMax)
{
units = theUnits;
unitsRound = theUnits / 2;
minRound = Long.MIN_VALUE + unitsRound;
maxRound = Long.MAX_VALUE - unitsRound;
epochOffset = theEpochOffset / theUnits;
if (theUnits == 1) {
epochOffsetP1 = epochOffsetM1 = epochOffset;
} else {
epochOffsetP1 = epochOffset + 1;
epochOffsetM1 = epochOffset - 1;
}
toMin = theToMin;
toMax = theToMax;
fromMin = theFromMin;
fromMax = theFromMax;
}
long units;
long epochOffset;
long fromMin;
long fromMax;
long toMin;
long toMax;
long epochOffsetP1;
long epochOffsetM1;
long unitsRound;
long minRound;
long maxRound;
}
private static final TimeScaleData[] timeScaleTable = {
new TimeScaleData(milliseconds, 621355968000000000L, -9223372036854774999L, 9223372036854774999L, -984472800485477L, 860201606885477L), // JAVA_TIME
new TimeScaleData(seconds, 621355968000000000L, -9223372036854775808L, 9223372036854775807L, -984472800485L, 860201606885L), // UNIX_TIME
new TimeScaleData(milliseconds, 621355968000000000L, -9223372036854774999L, 9223372036854774999L, -984472800485477L, 860201606885477L), // ICU4C_TIME
new TimeScaleData(ticks, 504911232000000000L, -8718460804854775808L, 9223372036854775807L, -9223372036854775808L, 8718460804854775807L), // WINDOWS_FILE_TIME
new TimeScaleData(ticks, 000000000000000000L, -9223372036854775808L, 9223372036854775807L, -9223372036854775808L, 9223372036854775807L), // DOTNET_DATE_TIME
new TimeScaleData(seconds, 600527520000000000L, -9223372036854775808L, 9223372036854775807L, -982389955685L, 862284451685L), // MAC_OLD_TIME
new TimeScaleData(seconds, 631139040000000000L, -9223372036854775808L, 9223372036854775807L, -985451107685L, 859223299685L), // MAC_TIME
new TimeScaleData(days, 599265216000000000L, -9223372036854775808L, 9223372036854775807L, -11368793L, 9981605L), // EXCEL_TIME
new TimeScaleData(days, 599265216000000000L, -9223372036854775808L, 9223372036854775807L, -11368793L, 9981605L), // DB2_TIME
new TimeScaleData(microseconds, 621355968000000000L, -9223372036854775804L, 9223372036854775804L, -984472800485477580L, 860201606885477580L) // UNIX_MICROSECONDS_TIME
};
/*
* Prevent construction of this class.
*/
///CLOVER:OFF
private UniversalTimeScale()
{
// nothing to do
}
///CLOVER:ON
/**
* Convert a long datetime from the given time scale to the universal time scale.
*
* @param otherTime The long datetime
* @param timeScale The time scale to convert from
*
* @return The datetime converted to the universal time scale
*
* @stable ICU 3.2
*/
public static long from(long otherTime, int timeScale)
{
TimeScaleData data = fromRangeCheck(otherTime, timeScale);
return (otherTime + data.epochOffset) * data.units;
}
/**
* Convert a double datetime from the given time scale to the universal time scale.
* All calculations are done using BigDecimal to guarantee that the value
* does not go out of range.
*
* @param otherTime The double datetime
* @param timeScale The time scale to convert from
*
* @return The datetime converted to the universal time scale
*
* @stable ICU 3.2
*/
public static BigDecimal bigDecimalFrom(double otherTime, int timeScale)
{
TimeScaleData data = getTimeScaleData(timeScale);
BigDecimal other = new BigDecimal(String.valueOf(otherTime));
BigDecimal units = new BigDecimal(data.units);
BigDecimal epochOffset = new BigDecimal(data.epochOffset);
return other.add(epochOffset).multiply(units);
}
/**
* Convert a long datetime from the given time scale to the universal time scale.
* All calculations are done using BigDecimal to guarantee that the value
* does not go out of range.
*
* @param otherTime The long datetime
* @param timeScale The time scale to convert from
*
* @return The datetime converted to the universal time scale
*
* @stable ICU 3.2
*/
public static BigDecimal bigDecimalFrom(long otherTime, int timeScale)
{
TimeScaleData data = getTimeScaleData(timeScale);
BigDecimal other = new BigDecimal(otherTime);
BigDecimal units = new BigDecimal(data.units);
BigDecimal epochOffset = new BigDecimal(data.epochOffset);
return other.add(epochOffset).multiply(units);
}
/**
* Convert a BigDecimal datetime from the given time scale to the universal time scale.
* All calculations are done using BigDecimal to guarantee that the value
* does not go out of range.
*
* @param otherTime The BigDecimal datetime
* @param timeScale The time scale to convert from
*
* @return The datetime converted to the universal time scale
*
* @stable ICU 3.2
*/
public static BigDecimal bigDecimalFrom(BigDecimal otherTime, int timeScale)
{
TimeScaleData data = getTimeScaleData(timeScale);
BigDecimal units = new BigDecimal(data.units);
BigDecimal epochOffset = new BigDecimal(data.epochOffset);
return otherTime.add(epochOffset).multiply(units);
}
/**
* Convert a datetime from the universal time scale stored as a BigDecimal to a
* long in the given time scale.
*
* Since this calculation requires a divide, we must round. The straight forward
* way to round by adding half of the divisor will push the sum out of range for values
* within have the divisor of the limits of the precision of a long. To get around this, we do
* the rounding like this:
*
*
* (universalTime - units + units/2) / units + 1
*
*
*
* (i.e. we subtract units first to guarantee that we'll still be in range when we
* add units/2. We then need to add one to the quotent to make up for the extra subtraction.
* This simplifies to:
*
*
* (universalTime - units/2) / units - 1
*
*
*
* For negative values to round away from zero, we need to flip the signs: * *
* (universalTime + units/2) / units + 1
*
*
*
* Since we also need to subtract the epochOffset, we fold the +/- 1
* into the offset value. (i.e. epochOffsetP1, epochOffsetM1.)
*
* @param universalTime The datetime in the universal time scale
* @param timeScale The time scale to convert to
*
* @return The datetime converted to the given time scale
*
* @stable ICU 3.2
*/
public static long toLong(long universalTime, int timeScale)
{
TimeScaleData data = toRangeCheck(universalTime, timeScale);
if (universalTime < 0) {
if (universalTime < data.minRound) {
return (universalTime + data.unitsRound) / data.units - data.epochOffsetP1;
}
return (universalTime - data.unitsRound) / data.units - data.epochOffset;
}
if (universalTime > data.maxRound) {
return (universalTime - data.unitsRound) / data.units - data.epochOffsetM1;
}
return (universalTime + data.unitsRound) / data.units - data.epochOffset;
}
/**
* Convert a datetime from the universal time scale to a BigDecimal in the given time scale.
*
* @param universalTime The datetime in the universal time scale
* @param timeScale The time scale to convert to
*
* @return The datetime converted to the given time scale
*
* @stable ICU 3.2
*/
public static BigDecimal toBigDecimal(long universalTime, int timeScale)
{
TimeScaleData data = getTimeScaleData(timeScale);
BigDecimal universal = new BigDecimal(universalTime);
BigDecimal units = new BigDecimal(data.units);
BigDecimal epochOffset = new BigDecimal(data.epochOffset);
return universal.divide(units, BigDecimal.ROUND_HALF_UP).subtract(epochOffset);
}
/**
* Convert a datetime from the universal time scale to a BigDecimal in the given time scale.
*
* @param universalTime The datetime in the universal time scale
* @param timeScale The time scale to convert to
*
* @return The datetime converted to the given time scale
*
* @stable ICU 3.2
*/
public static BigDecimal toBigDecimal(BigDecimal universalTime, int timeScale)
{
TimeScaleData data = getTimeScaleData(timeScale);
BigDecimal units = new BigDecimal(data.units);
BigDecimal epochOffset = new BigDecimal(data.epochOffset);
return universalTime.divide(units, BigDecimal.ROUND_HALF_UP).subtract(epochOffset);
}
/**
* Return the TimeScaleData object for the given time
* scale.
*
* @param scale - the time scale
*
* @return the TimeScaleData object for the given time scale
*
* @internal
* @deprecated This API is ICU internal only.
*/
private static TimeScaleData getTimeScaleData(int scale)
{
if (scale < 0 || scale >= MAX_SCALE) {
throw new IllegalArgumentException("scale out of range: " + scale);
}
return timeScaleTable[scale];
}
/**
* Get a value associated with a particular time scale.
*
* @param scale - the time scale
* @param value - a constant representing the value to get
*
* @return - the value.
*
* @stable ICU 3.2
*/
public static long getTimeScaleValue(int scale, int value)
{
TimeScaleData data = getTimeScaleData(scale);
switch (value)
{
case UNITS_VALUE:
return data.units;
case EPOCH_OFFSET_VALUE:
return data.epochOffset;
case FROM_MIN_VALUE:
return data.fromMin;
case FROM_MAX_VALUE:
return data.fromMax;
case TO_MIN_VALUE:
return data.toMin;
case TO_MAX_VALUE:
return data.toMax;
case EPOCH_OFFSET_PLUS_1_VALUE:
return data.epochOffsetP1;
case EPOCH_OFFSET_MINUS_1_VALUE:
return data.epochOffsetM1;
case UNITS_ROUND_VALUE:
return data.unitsRound;
case MIN_ROUND_VALUE:
return data.minRound;
case MAX_ROUND_VALUE:
return data.maxRound;
default:
throw new IllegalArgumentException("value out of range: " + value);
}
}
private static TimeScaleData toRangeCheck(long universalTime, int scale)
{
TimeScaleData data = getTimeScaleData(scale);
if (universalTime >= data.toMin && universalTime <= data.toMax) {
return data;
}
throw new IllegalArgumentException("universalTime out of range:" + universalTime);
}
private static TimeScaleData fromRangeCheck(long otherTime, int scale)
{
TimeScaleData data = getTimeScaleData(scale);
if (otherTime >= data.fromMin && otherTime <= data.fromMax) {
return data;
}
throw new IllegalArgumentException("otherTime out of range:" + otherTime);
}
/**
* Convert a time in the Universal Time Scale into another time
* scale. The division used to do the conversion rounds down.
*
* NOTE: This is an internal routine used by the tool that
* generates the to and from limits. Use it at your own risk.
*
* @param universalTime the time in the Universal Time scale
* @param timeScale the time scale to convert to
* @return the time in the given time scale
*
* @internal
* @deprecated This API is ICU internal only.
*/
public static BigDecimal toBigDecimalTrunc(BigDecimal universalTime, int timeScale)
{
TimeScaleData data = getTimeScaleData(timeScale);
BigDecimal units = new BigDecimal(data.units);
BigDecimal epochOffset = new BigDecimal(data.epochOffset);
return universalTime.divide(units, BigDecimal.ROUND_DOWN).subtract(epochOffset);
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/DateTimeRule.java 0000644 0001750 0001750 00000023066 11017153155 021677 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2007-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.io.Serializable;
/**
* DateTimeRule is a class representing a time in a year by
* a rule specified by month, day of month, day of week and
* time in the day.
*
* @stable ICU 3.8
*/
public class DateTimeRule implements Serializable {
private static final long serialVersionUID = 2183055795738051443L;
/**
* Date rule type defined by exact day of month.
* For example, March 14.
*
* @stable ICU 3.8
*/
public static final int DOM = 0;
/**
* Date rule type defined by day of week in month.
* For example, 2nd Sunday in March.
*
* @stable ICU 3.8
*/
public static final int DOW = 1;
/**
* Date rule type defined by first day of week on or
* after exact day of month.
* For example, 1st Monday on or after March 15.
*
* @stable ICU 3.8
*/
public static final int DOW_GEQ_DOM = 2;
/**
* Date rule type defined by last day of week on or
* before exact day of month.
* For example, last Saturday on or before March 15.
*
* @stable ICU 3.8
*/
public static final int DOW_LEQ_DOM = 3;
/**
* Time rule type for local wall time.
*
* @stable ICU 3.8
*/
public static final int WALL_TIME = 0;
/**
* Time rule type for local standard time.
*
* @stable ICU 3.8
*/
public static final int STANDARD_TIME = 1;
/**
* Time rule type for coordinated universal time.
*
* @stable ICU 3.8
*/
public static final int UTC_TIME = 2;
// private stuff
private final int dateRuleType;
private final int month;
private final int dayOfMonth;
private final int dayOfWeek;
private final int weekInMonth;
private final int timeRuleType;
private final int millisInDay;
/**
* Constructs a DateTimeRule by the day of month and
* the time rule. The date rule type for an instance created by
* this constructor is DOM.
*
* @param month The rule month, for example, Calendar.JANUARY
* @param dayOfMonth The day of month, 1-based.
* @param millisInDay The milliseconds in the rule date.
* @param timeType The time type, WALL_TIME or STANDARD_TIME
* or UTC_TIME.
*
* @stable ICU 3.8
*/
public DateTimeRule(int month, int dayOfMonth,
int millisInDay, int timeType) {
dateRuleType = DOM;
this.month = month;
this.dayOfMonth = dayOfMonth;
this.millisInDay = millisInDay;
this.timeRuleType = timeType;
// not used by this rule type
this.dayOfWeek = 0;
this.weekInMonth = 0;
}
/**
* Constructs a DateTimeRule by the day of week and its oridinal
* number and the time rule. The date rule type for an instance created
* by this constructor is DOW.
*
* @param month The rule month, for example, Calendar.JANUARY.
* @param weekInMonth The ordinal number of the day of week. Negative number
* may be used for specifying a rule date counted from the
* end of the rule month.
* @param dayOfWeek The day of week, for example, Calendar.SUNDAY.
* @param millisInDay The milliseconds in the rule date.
* @param timeType The time type, WALL_TIME or STANDARD_TIME
* or UTC_TIME.
*
* @stable ICU 3.8
*/
public DateTimeRule(int month, int weekInMonth, int dayOfWeek,
int millisInDay, int timeType) {
dateRuleType = DOW;
this.month = month;
this.weekInMonth = weekInMonth;
this.dayOfWeek = dayOfWeek;
this.millisInDay = millisInDay;
this.timeRuleType = timeType;
// not used by this rule type
this.dayOfMonth = 0;
}
/**
* Constructs a DateTimeRule by the first/last day of week
* on or after/before the day of month and the time rule. The date rule
* type for an instance created by this constructor is either
* DOM_GEQ_DOM or DOM_LEQ_DOM.
*
* @param month The rule month, for example, Calendar.JANUARY
* @param dayOfMonth The day of month, 1-based.
* @param dayOfWeek The day of week, for example, Calendar.SUNDAY.
* @param after true if the rule date is on or after the day of month.
* @param millisInDay The milliseconds in the rule date.
* @param timeType The time type, WALL_TIME or STANDARD_TIME
* or UTC_TIME.
*
* @stable ICU 3.8
*/
public DateTimeRule(int month, int dayOfMonth, int dayOfWeek, boolean after,
int millisInDay, int timeType) {
this.dateRuleType = after ? DOW_GEQ_DOM : DOW_LEQ_DOM;
this.month = month;
this.dayOfMonth = dayOfMonth;
this.dayOfWeek = dayOfWeek;
this.millisInDay = millisInDay;
this.timeRuleType = timeType;
// not used by this rule type
this.weekInMonth = 0;
}
/**
* Gets the date rule type, such as DOM
*
* @return The date rule type.
*
* @stable ICU 3.8
*/
public int getDateRuleType() {
return dateRuleType;
}
/**
* Gets the rule month.
*
* @return The rule month.
*
* @stable ICU 3.8
*/
public int getRuleMonth() {
return month;
}
/**
* Gets the rule day of month. When the date rule type
* is DOW, the value is always 0.
*
* @return The rule day of month
*
* @stable ICU 3.8
*/
public int getRuleDayOfMonth() {
return dayOfMonth;
}
/**
* Gets the rule day of week. When the date rule type
* is DOM, the value is always 0.
*
* @return The rule day of week.
*
* @stable ICU 3.8
*/
public int getRuleDayOfWeek() {
return dayOfWeek;
}
/**
* Gets the rule day of week ordinal number in the month.
* When the date rule type is not DOW, the value is
* always 0.
*
* @return The rule day of week ordinal number in the month.
*
* @stable ICU 3.8
*/
public int getRuleWeekInMonth() {
return weekInMonth;
}
/**
* Gets the time rule type
*
* @return The time rule type, either WALL_TIME or STANDARD_TIME
* or UTC_TIME.
*
* @stable ICU 3.8
*/
public int getTimeRuleType() {
return timeRuleType;
}
/**
* Gets the rule time in the rule day.
*
* @return The time in the rule day in milliseconds.
*
* @stable ICU 3.8
*/
public int getRuleMillisInDay() {
return millisInDay;
}
private static final String[] DOWSTR = {"", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
private static final String[] MONSTR = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
/**
* Returns a String representation of this DateTimeRule object.
* This method is used for debugging purpose only. The string representation can be changed
* in future version of ICU without any notice.
*
* @stable ICU 3.8
*/
public String toString() {
String sDate = null;
String sTimeRuleType = null;
switch (dateRuleType) {
case DOM:
sDate = Integer.toString(dayOfMonth);
break;
case DOW:
sDate = Integer.toString(weekInMonth) + DOWSTR[dayOfWeek];
break;
case DOW_GEQ_DOM:
sDate = DOWSTR[dayOfWeek] + ">=" + Integer.toString(dayOfMonth);
break;
case DOW_LEQ_DOM:
sDate = DOWSTR[dayOfWeek] + "<=" + Integer.toString(dayOfMonth);
break;
}
switch (timeRuleType) {
case WALL_TIME:
sTimeRuleType = "WALL";
break;
case STANDARD_TIME:
sTimeRuleType = "STD";
break;
case UTC_TIME:
sTimeRuleType = "UTC";
break;
}
int time = millisInDay;
int millis = time % 1000;
time /= 1000;
int secs = time % 60;
time /= 60;
int mins = time % 60;
int hours = time / 60;
StringBuffer buf = new StringBuffer();
buf.append("month=");
buf.append(MONSTR[month]);
buf.append(", date=");
buf.append(sDate);
buf.append(", time=");
buf.append(hours);
buf.append(":");
buf.append(mins/10);
buf.append(mins%10);
buf.append(":");
buf.append(secs/10);
buf.append(secs%10);
buf.append(".");
buf.append(millis/100);
buf.append((millis/10)%10);
buf.append(millis%10);
buf.append("(");
buf.append(sTimeRuleType);
buf.append(")");
return buf.toString();
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/TaiwanCalendar.java 0000644 0001750 0001750 00000020055 11015072544 022223 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import com.ibm.icu.util.TimeZone;
import java.util.Date;
import java.util.Locale;
/**
* TaiwanCalendar is a subclass of GregorianCalendar
* that numbers years since 1912.
*
* The Taiwan calendar is identical to the Gregorian calendar in all respects * except for the year and era. Years are numbered since 1912 AD (Gregorian). *
* The Taiwan Calendar has one era: MINGUO.
*
* This class should not be subclassed.
*
* TaiwanCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a ULocale
* with the tag "@calendar=roc".
TaiwanCalendar using the current time
* in the default time zone with the default locale.
* @stable ICU 3.8
*/
public TaiwanCalendar() {
super();
}
/**
* Constructs a TaiwanCalendar based on the current time
* in the given time zone with the default locale.
*
* @param zone the given time zone.
* @stable ICU 3.8
*/
public TaiwanCalendar(TimeZone zone) {
super(zone);
}
/**
* Constructs a TaiwanCalendar based on the current time
* in the default time zone with the given locale.
*
* @param aLocale the given locale.
* @stable ICU 3.8
*/
public TaiwanCalendar(Locale aLocale) {
super(aLocale);
}
/**
* Constructs a TaiwanCalendar based on the current time
* in the default time zone with the given locale.
*
* @param locale the given ulocale.
* @stable ICU 3.8
*/
public TaiwanCalendar(ULocale locale) {
super(locale);
}
/**
* Constructs a TaiwanCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone the given time zone.
*
* @stable ICU 3.8
*/
public TaiwanCalendar(TimeZone zone, Locale aLocale) {
super(zone, aLocale);
}
/**
* Constructs a TaiwanCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone the given time zone.
* @param locale the given ulocale.
* @stable ICU 3.8
*/
public TaiwanCalendar(TimeZone zone, ULocale locale) {
super(zone, locale);
}
/**
* Constructs a TaiwanCalendar with the given date set
* in the default time zone with the default locale.
*
* @param date The date to which the new calendar is set.
* @stable ICU 3.8
*/
public TaiwanCalendar(Date date) {
this();
setTime(date);
}
/**
* Constructs a TaiwanCalendar with the given date set
* in the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for January.
*
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @stable ICU 3.8
*/
public TaiwanCalendar(int year, int month, int date) {
super(year, month, date);
}
/**
* Constructs a TaiwanCalendar with the given date
* and time set for the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for January.
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @param hour The value used to set the calendar's {@link #HOUR_OF_DAY HOUR_OF_DAY} time field.
* @param minute The value used to set the calendar's {@link #MINUTE MINUTE} time field.
* @param second The value used to set the calendar's {@link #SECOND SECOND} time field.
* @stable ICU 3.8
*/
public TaiwanCalendar(int year, int month, int date, int hour,
int minute, int second)
{
super(year, month, date, hour, minute, second);
}
//-------------------------------------------------------------------------
// The only practical difference from a Gregorian calendar is that years
// are numbered since 1912, inclusive. A couple of overrides will
// take care of that....
//-------------------------------------------------------------------------
private static final int Taiwan_ERA_START = 1911; // 0=1911, 1=1912
// Use 1970 as the default value of EXTENDED_YEAR
private static final int GREGORIAN_EPOCH = 1970;
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
protected int handleGetExtendedYear() {
// EXTENDED_YEAR in TaiwanCalendar is a Gregorian year
// The default value of EXTENDED_YEAR is 1970 (Minguo 59)
int year = GREGORIAN_EPOCH;
if (newerField(EXTENDED_YEAR, YEAR) == EXTENDED_YEAR
&& newerField(EXTENDED_YEAR, ERA) == EXTENDED_YEAR) {
year = internalGet(EXTENDED_YEAR, GREGORIAN_EPOCH);
} else {
int era = internalGet(ERA, MINGUO);
if (era == MINGUO) {
year = internalGet(YEAR, 1) + Taiwan_ERA_START;
} else {
year = 1 - internalGet(YEAR, 1) + Taiwan_ERA_START;
}
}
return year;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
protected void handleComputeFields(int julianDay) {
super.handleComputeFields(julianDay);
int y = internalGet(EXTENDED_YEAR) - Taiwan_ERA_START;
if (y > 0) {
internalSet(ERA, MINGUO);
internalSet(YEAR, y);
} else {
internalSet(ERA, BEFORE_MINGUO);
internalSet(YEAR, 1- y);
}
}
/**
* Override GregorianCalendar. There is only one Taiwan ERA. We
* should really handle YEAR, YEAR_WOY, and EXTENDED_YEAR here too to
* implement the 1..5000000 range, but it's not critical.
* @stable ICU 3.8
*/
protected int handleGetLimit(int field, int limitType) {
if (field == ERA) {
if (limitType == MINIMUM || limitType == GREATEST_MINIMUM) {
return BEFORE_MINGUO;
} else {
return MINGUO;
}
}
return super.handleGetLimit(field, limitType);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public String getType() {
return "roc";
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/RangeValueIterator.java 0000644 0001750 0001750 00000007452 10666355147 023135 0 ustar twerner twerner /*
******************************************************************************
* Copyright (C) 1996-2004, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
package com.ibm.icu.util;
/**
* Interface for enabling iteration over sets of
The result for each iteration is the consecutive range of
*
* Hence value(start) = value(start + 1) = .... = value(start + n) = .... = * value(limit - 1). However value(start -1) != value(start) and * value(limit) != value(start). *
*Most implementations will be created by factory methods, such as the * character type iterator in UCharacter.getTypeIterator. See example below. *
* Example of use:
* RangeValueIterator iterator = UCharacter.getTypeIterator();
* RangeValueIterator.Element result = new RangeValueIterator.Element();
* while (iterator.next(result)) {
* System.out.println("Codepoint \\u" +
* Integer.toHexString(result.start) +
* " to codepoint \\u" +
* Integer.toHexString(result.limit - 1) +
* " has the character type " + result.value);
* }
*
* @author synwee
* @stable ICU 2.6
*/
public interface RangeValueIterator
{
// public inner class ---------------------------------------------
/**
* Return result wrapper for com.ibm.icu.util.RangeValueIterator.
* Stores the start and limit of the continous result range and the
* common value all integers between [start, limit - 1] has.
* @stable ICU 2.6
*/
public class Element
{
// public data member ---------------------------------------------
/**
* Starting integer of the continuous result range that has the same
* value
* @stable ICU 2.6
*/
public int start;
/**
* (End + 1) integer of continuous result range that has the same
* value
* @stable ICU 2.6
*/
public int limit;
/**
* Gets the common value of the continous result range
* @stable ICU 2.6
*/
public int value;
// public constructor --------------------------------------------
/**
* Empty default constructor to make javadoc happy
* @stable ICU 2.4
*/
public Element()
{
}
}
// public methods -------------------------------------------------
/**
* Gets the next maximal result range with a common value and returns * true if we are not at the end of the iteration, false otherwise.
*If the return boolean is a false, the contents of elements will not * be updated.
* @param element for storing the result range and value * @return true if we are not at the end of the iteration, false otherwise. * @see Element * @stable ICU 2.6 */ public boolean next(Element element); /** * Resets the iterator to the beginning of the iteration. * @stable ICU 2.6 */ public void reset(); } icu4j-4.2.1.1/src/com/ibm/icu/util/InitialTimeZoneRule.java 0000644 0001750 0001750 00000006042 11017153155 023242 0 ustar twerner twerner /* ******************************************************************************* * Copyright (C) 2007-2008, International Business Machines Corporation and * * others. All Rights Reserved. * ******************************************************************************* */ package com.ibm.icu.util; import java.util.Date; /** *InitialTimeZoneRule represents a time zone rule
* representing a time zone effective from the beginning and
* has no actual start times.
*
* @stable ICU 3.8
*/
public class InitialTimeZoneRule extends TimeZoneRule {
private static final long serialVersionUID = 1876594993064051206L;
/**
* Constructs a InitialTimeZoneRule with the name, the GMT offset of its
* standard time and the amount of daylight saving offset adjustment.
*
* @param name The time zone name.
* @param rawOffset The UTC offset of its standard time in milliseconds.
* @param dstSavings The amount of daylight saving offset adjustment in milliseconds.
* If this ia a rule for standard time, the value of this argument is 0.
*
* @stable ICU 3.8
*/
public InitialTimeZoneRule(String name, int rawOffset, int dstSavings) {
super(name, rawOffset, dstSavings);
}
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public boolean isEquivalentTo(TimeZoneRule other) {
if (other instanceof InitialTimeZoneRule) {
return super.isEquivalentTo(other);
}
return false;
}
/**
* {@inheritDoc}InitialTimeZoneRule always returns null.
*
* @stable ICU 3.8
*/
public Date getFinalStart(int prevRawOffset, int prevDSTSavings) {
// No start time available
return null;
}
/**
* {@inheritDoc}InitialTimeZoneRule always returns null.
*
* @stable ICU 3.8
*/
public Date getFirstStart(int prevRawOffset, int prevDSTSavings) {
// No start time available
return null;
}
/**
* {@inheritDoc}InitialTimeZoneRule always returns null.
*
* @stable ICU 3.8
*/
public Date getNextStart(long base, int prevRawOffset, int prevDSTSavings,
boolean inclusive) {
// No start time available
return null;
}
/**
* {@inheritDoc}InitialTimeZoneRule always returns null.
*
* @stable ICU 3.8
*/
public Date getPreviousStart(long base, int prevRawOffset,
int prevDSTSavings, boolean inclusive) {
// No start time available
return null;
}
/**
* {@inheritDoc}InitialTimeZoneRule always returns false.
* @stable ICU 3.8
*/
public boolean isTransitionRule() {
return false;
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/ValueIterator.java 0000644 0001750 0001750 00000007647 10057260417 022153 0 ustar twerner twerner /*
******************************************************************************
* Copyright (C) 1996-2004, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
package com.ibm.icu.util;
/**
* Interface for enabling iteration over sets of
The ValueIterator allows iterations over integer indexes in the range * of Integer.MIN_VALUE to Integer.MAX_VALUE inclusive. Implementations of * ValueIterator should specify their own maximum subrange within the above * range that is meaningful to its applications.
*Most implementations will be created by factory methods, such as the * character name iterator in UCharacter.getNameIterator. See example below. *
* Example of use:
* ValueIterator iterator = UCharacter.getNameIterator();
* ValueIterator.Element result = new ValueIterator.Element();
* iterator.setRange(UCharacter.MIN_VALUE, UCharacter.MAX_VALUE);
* while (iterator.next(result)) {
* System.out.println("Codepoint \\u" +
* Integer.toHexString(result.integer) +
* " has the character name " + (String)result.value);
* }
*
* @author synwee
* @stable ICU 2.6
*/
public interface ValueIterator
{
// public inner class ---------------------------------------------
/**
* The return result container of each iteration. Stores the next * integer index and its associated value Object.
* @stable ICU 2.6 */ public static final class Element { // public data members ---------------------------------------- /** * Integer index of the current iteration * @stable ICU 2.6 */ public int integer; /** * Gets the Object value associated with the integer index. * @stable ICU 2.6 */ public Object value; // public constructor ------------------------------------------ /** * Empty default constructor to make javadoc happy * @stable ICU 2.4 */ public Element() { } } // public methods ------------------------------------------------- /** *Gets the next result for this iteration and returns * true if we are not at the end of the iteration, false otherwise.
*If the return boolean is a false, the contents of elements will not * be updated.
* @param element for storing the result index and value * @return true if we are not at the end of the iteration, false otherwise. * @see Element * @stable ICU 2.6 */ public boolean next(Element element); /** *Resets the iterator to start iterating from the integer index * Integer.MIN_VALUE or X if a setRange(X, Y) has been called previously. *
* @stable ICU 2.6 */ public void reset(); /** *Restricts the range of integers to iterate and resets the iteration * to begin at the index argument start.
*If setRange(start, end) is not performed before next(element) is * called, the iteration will start from the integer index * Integer.MIN_VALUE and end at Integer.MAX_VALUE.
** If this range is set outside the meaningful range specified by the * implementation, next(element) will always return false. *
* @param start first integer in the range to iterate * @param limit one more than the last integer in the range * @exception IllegalArgumentException thrown when attempting to set an * illegal range. E.g limit <= start * @stable ICU 2.6 */ public void setRange(int start, int limit); } icu4j-4.2.1.1/src/com/ibm/icu/util/TimeArrayTimeZoneRule.java 0000644 0001750 0001750 00000014102 11017153155 023542 0 ustar twerner twerner /* ******************************************************************************* * Copyright (C) 2007-2008, International Business Machines Corporation and * * others. All Rights Reserved. * ******************************************************************************* */ package com.ibm.icu.util; import java.util.Arrays; import java.util.Date; /** *TimeArrayTimeZoneRule represents a time zone rule whose start times are
* defined by an array of milliseconds since the standard base time.
*
* @stable ICU 3.8
*/
public class TimeArrayTimeZoneRule extends TimeZoneRule {
private static final long serialVersionUID = -1117109130077415245L;
private final long[] startTimes;
private final int timeType;
/**
* Constructs a TimeArrayTimeZoneRule with the name, the GMT offset of its
* standard time, the amount of daylight saving offset adjustment and
* the array of times when this rule takes effect.
*
* @param name The time zone name.
* @param rawOffset The UTC offset of its standard time in milliseconds.
* @param dstSavings The amount of daylight saving offset adjustment in
* milliseconds. If this ia a rule for standard time,
* the value of this argument is 0.
* @param startTimes The start times in milliseconds since the base time
* (January 1, 1970, 00:00:00).
* @param timeType The time type of the start times, which is one of
* DataTimeRule.WALL_TIME, STANDARD_TIME
* and UTC_TIME.
*
* @stable ICU 3.8
*/
public TimeArrayTimeZoneRule(String name, int rawOffset, int dstSavings, long[] startTimes, int timeType) {
super(name, rawOffset, dstSavings);
if (startTimes == null || startTimes.length == 0) {
throw new IllegalArgumentException("No start times are specified.");
} else {
this.startTimes = (long[])startTimes.clone();
Arrays.sort(this.startTimes);
}
this.timeType = timeType;
}
/**
* Gets the array of start times used by this rule.
*
* @return An array of the start times in milliseconds since the base time
* (January 1, 1970, 00:00:00 GMT).
* @stable ICU 3.8
*/
public long[] getStartTimes() {
return (long[])startTimes.clone();
}
/**
* Gets the time type of the start times used by this rule. The return value
* is either DateTimeRule.WALL_TIME or DateTimeRule.STANDARD_TIME
* or DateTimeRule.UTC_TIME.
*
* @return The time type used of the start times used by this rule.
* @stable ICU 3.8
*/
public int getTimeType() {
return timeType;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public Date getFirstStart(int prevRawOffset, int prevDSTSavings) {
return new Date(getUTC(startTimes[0], prevRawOffset, prevDSTSavings));
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public Date getFinalStart(int prevRawOffset, int prevDSTSavings) {
return new Date(getUTC(startTimes[startTimes.length - 1], prevRawOffset, prevDSTSavings));
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public Date getNextStart(long base, int prevOffset, int prevDSTSavings, boolean inclusive) {
int i = startTimes.length - 1;
for (; i >= 0; i--) {
long time = getUTC(startTimes[i], prevOffset, prevDSTSavings);
if (time < base || (!inclusive && time == base)) {
break;
}
}
if (i == startTimes.length - 1) {
return null;
}
return new Date(getUTC(startTimes[i + 1], prevOffset, prevDSTSavings));
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public Date getPreviousStart(long base, int prevOffset, int prevDSTSavings, boolean inclusive) {
int i = startTimes.length - 1;
for (; i >= 0; i--) {
long time = getUTC(startTimes[i], prevOffset, prevDSTSavings);
if (time < base || (inclusive && time == base)) {
return new Date(time);
}
}
return null;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public boolean isEquivalentTo(TimeZoneRule other) {
if (!(other instanceof TimeArrayTimeZoneRule)) {
return false;
}
if (timeType == ((TimeArrayTimeZoneRule)other).timeType
&& Arrays.equals(startTimes, ((TimeArrayTimeZoneRule)other).startTimes)) {
return super.isEquivalentTo(other);
}
return false;
}
/**
* {@inheritDoc}TimeArrayTimeZoneRule always returns true.
* @stable ICU 3.8
*/
public boolean isTransitionRule() {
return true;
}
/* Get UTC of the time with the raw/dst offset */
private long getUTC(long time, int raw, int dst) {
if (timeType != DateTimeRule.UTC_TIME) {
time -= raw;
}
if (timeType == DateTimeRule.WALL_TIME) {
time -= dst;
}
return time;
}
/**
* Returns a String representation of this TimeArrayTimeZoneRule object.
* This method is used for debugging purpose only. The string representation can be changed
* in future version of ICU without any notice.
*
* @stable ICU 3.8
*/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append(super.toString());
buf.append(", timeType=");
buf.append(timeType);
buf.append(", startTimes=[");
for (int i = 0; i < startTimes.length; i++) {
if (i != 0) {
buf.append(", ");
}
buf.append(Long.toString(startTimes[i]));
}
buf.append("]");
return buf.toString();
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/ULocale.java 0000644 0001750 0001750 00000537667 11173261237 020724 0 ustar twerner twerner /*
******************************************************************************
* Copyright (C) 2003-2009, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
package com.ibm.icu.util;
import java.io.Serializable;
import java.text.ParseException;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Set;
import java.util.TreeMap;
import com.ibm.icu.impl.ICUCache;
import com.ibm.icu.impl.ICUResourceBundle;
import com.ibm.icu.impl.LocaleUtility;
import com.ibm.icu.impl.SimpleCache;
import com.ibm.icu.impl.Utility;
import com.ibm.icu.impl.locale.AsciiUtil;
import com.ibm.icu.impl.locale.BaseLocale;
import com.ibm.icu.impl.locale.InternalLocaleBuilder;
import com.ibm.icu.impl.locale.LanguageTag;
import com.ibm.icu.impl.locale.LocaleExtensions;
import com.ibm.icu.impl.locale.LocaleSyntaxException;
import com.ibm.icu.impl.locale.LanguageTag.Extension;
/**
* A class analogous to {@link java.util.Locale} that provides additional
* support for ICU protocol. In ICU 3.0 this class is enhanced to support
* RFC 3066 language identifiers.
*
* Many classes and services in ICU follow a factory idiom, in * which a factory method or object responds to a client request with * an object. The request includes a locale (the requested * locale), and the returned object is constructed using data for that * locale. The system may lack data for the requested locale, in * which case the locale fallback mechanism will be invoked until a * populated locale is found (the valid locale). Furthermore, * even when a populated locale is found (the valid locale), * further fallback may be required to reach a locale containing the * specific data required by the service (the actual locale). * *
ULocale performs 'normalization' and 'canonicalization' of locale ids. * Normalization 'cleans up' ICU locale ids as follows: *
canonicalize can be called to convert the id
* to canonical form, or the canonicalInstance factory method
* can be called.
*
* This class provides selectors {@link #VALID_LOCALE} and {@link * #ACTUAL_LOCALE} intended for use in methods named * getLocale(). These methods exist in several ICU classes, * including {@link com.ibm.icu.util.Calendar}, {@link * com.ibm.icu.util.Currency}, {@link com.ibm.icu.text.UFormat}, * {@link com.ibm.icu.text.BreakIterator}, {@link * com.ibm.icu.text.Collator}, {@link * com.ibm.icu.text.DateFormatSymbols}, and {@link * com.ibm.icu.text.DecimalFormatSymbols} and their subclasses, if * any. Once an object of one of these classes has been created, * getLocale() may be called on it to determine the valid and * actual locale arrived at during the object's construction. * *
Note: The getLocale() method will be implemented in ICU
* 3.0; ICU 2.8 contains a partial preview implementation. The
* actual locale is returned correctly, but the valid
* locale is not, in most cases.
*
* @see java.util.Locale
* @author weiv
* @author Alan Liu
* @author Ram Viswanadha
* @stable ICU 2.8
*/
public final class ULocale implements Serializable {
// using serialver from jdk1.4.2_05
private static final long serialVersionUID = 3715177670352309217L;
/**
* Useful constant for language.
* @stable ICU 3.0
*/
public static final ULocale ENGLISH = new ULocale("en", Locale.ENGLISH);
/**
* Useful constant for language.
* @stable ICU 3.0
*/
public static final ULocale FRENCH = new ULocale("fr", Locale.FRENCH);
/**
* Useful constant for language.
* @stable ICU 3.0
*/
public static final ULocale GERMAN = new ULocale("de", Locale.GERMAN);
/**
* Useful constant for language.
* @stable ICU 3.0
*/
public static final ULocale ITALIAN = new ULocale("it", Locale.ITALIAN);
/**
* Useful constant for language.
* @stable ICU 3.0
*/
public static final ULocale JAPANESE = new ULocale("ja", Locale.JAPANESE);
/**
* Useful constant for language.
* @stable ICU 3.0
*/
public static final ULocale KOREAN = new ULocale("ko", Locale.KOREAN);
/**
* Useful constant for language.
* @stable ICU 3.0
*/
public static final ULocale CHINESE = new ULocale("zh", Locale.CHINESE);
/**
* Useful constant for language.
* @stable ICU 3.0
*/
public static final ULocale SIMPLIFIED_CHINESE = new ULocale("zh_Hans", Locale.CHINESE);
/**
* Useful constant for language.
* @stable ICU 3.0
*/
public static final ULocale TRADITIONAL_CHINESE = new ULocale("zh_Hant", Locale.CHINESE);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale FRANCE = new ULocale("fr_FR", Locale.FRANCE);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale GERMANY = new ULocale("de_DE", Locale.GERMANY);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale ITALY = new ULocale("it_IT", Locale.ITALY);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale JAPAN = new ULocale("ja_JP", Locale.JAPAN);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale KOREA = new ULocale("ko_KR", Locale.KOREA);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale CHINA = new ULocale("zh_Hans_CN", Locale.CHINA);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale PRC = CHINA;
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale TAIWAN = new ULocale("zh_Hant_TW", Locale.TAIWAN);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale UK = new ULocale("en_GB", Locale.UK);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale US = new ULocale("en_US", Locale.US);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale CANADA = new ULocale("en_CA", Locale.CANADA);
/**
* Useful constant for country/region.
* @stable ICU 3.0
*/
public static final ULocale CANADA_FRENCH = new ULocale("fr_CA", Locale.CANADA_FRENCH);
/**
* Handy constant.
*/
private static final String EMPTY_STRING = "";
// Used in both ULocale and IDParser, so moved up here.
private static final char UNDERSCORE = '_';
// default empty locale
private static final Locale EMPTY_LOCALE = new Locale("", "");
/**
* The root ULocale.
* @stable ICU 2.8
*/
public static final ULocale ROOT = new ULocale("root", EMPTY_LOCALE);
private static final SimpleCache CACHE = new SimpleCache();
/**
* Cache the locale.
*/
private transient Locale locale;
/**
* The raw localeID that we were passed in.
*/
private String localeID;
/**
* Tables used in normalizing portions of the id.
*/
/* tables updated per http://lcweb.loc.gov/standards/iso639-2/
to include the revisions up to 2001/7/27 *CWB*/
/* The 3 character codes are the terminology codes like RFC 3066.
This is compatible with prior ICU codes */
/* "in" "iw" "ji" "jw" & "sh" have been withdrawn but are still in
the table but now at the end of the table because
3 character codes are duplicates. This avoids bad searches
going from 3 to 2 character codes.*/
/* The range qaa-qtz is reserved for local use. */
private static String[] _languages;
private static String[] _replacementLanguages;
private static String[] _obsoleteLanguages;
private static String[] _languages3;
private static String[] _obsoleteLanguages3;
// Avoid initializing languages tables unless we have to.
private static void initLanguageTables() {
if (_languages == null) {
/* This list MUST be in sorted order, and MUST contain the two-letter codes
if one exists otherwise use the three letter code */
String[] tempLanguages = {
"aa", "ab", "ace", "ach", "ada", "ady", "ae", "af", "afa",
"afh", "ak", "akk", "ale", "alg", "am", "an", "ang", "apa",
"ar", "arc", "arn", "arp", "art", "arw", "as", "ast",
"ath", "aus", "av", "awa", "ay", "az", "ba", "bad",
"bai", "bal", "ban", "bas", "bat", "be", "bej",
"bem", "ber", "bg", "bh", "bho", "bi", "bik", "bin",
"bla", "bm", "bn", "bnt", "bo", "br", "bra", "bs",
"btk", "bua", "bug", "byn", "ca", "cad", "cai", "car", "cau",
"ce", "ceb", "cel", "ch", "chb", "chg", "chk", "chm",
"chn", "cho", "chp", "chr", "chy", "cmc", "co", "cop",
"cpe", "cpf", "cpp", "cr", "crh", "crp", "cs", "csb", "cu", "cus",
"cv", "cy", "da", "dak", "dar", "day", "de", "del", "den",
"dgr", "din", "doi", "dra", "dsb", "dua", "dum", "dv", "dyu",
"dz", "ee", "efi", "egy", "eka", "el", "elx", "en",
"enm", "eo", "es", "et", "eu", "ewo", "fa",
"fan", "fat", "ff", "fi", "fiu", "fj", "fo", "fon",
"fr", "frm", "fro", "fur", "fy", "ga", "gaa", "gay",
"gba", "gd", "gem", "gez", "gil", "gl", "gmh", "gn",
"goh", "gon", "gor", "got", "grb", "grc", "gu", "gv",
"gwi", "ha", "hai", "haw", "he", "hi", "hil", "him",
"hit", "hmn", "ho", "hr", "hsb", "ht", "hu", "hup", "hy", "hz",
"ia", "iba", "id", "ie", "ig", "ii", "ijo", "ik",
"ilo", "inc", "ine", "inh", "io", "ira", "iro", "is", "it",
"iu", "ja", "jbo", "jpr", "jrb", "jv", "ka", "kaa", "kab",
"kac", "kam", "kar", "kaw", "kbd", "kg", "kha", "khi",
"kho", "ki", "kj", "kk", "kl", "km", "kmb", "kn",
"ko", "kok", "kos", "kpe", "kr", "krc", "kro", "kru", "ks",
"ku", "kum", "kut", "kv", "kw", "ky", "la", "lad",
"lah", "lam", "lb", "lez", "lg", "li", "ln", "lo", "lol",
"loz", "lt", "lu", "lua", "lui", "lun", "luo", "lus",
"lv", "mad", "mag", "mai", "mak", "man", "map", "mas",
"mdf", "mdr", "men", "mg", "mga", "mh", "mi", "mic", "min",
"mis", "mk", "mkh", "ml", "mn", "mnc", "mni", "mno",
"mo", "moh", "mos", "mr", "ms", "mt", "mul", "mun",
"mus", "mwr", "my", "myn", "myv", "na", "nah", "nai", "nap",
"nb", "nd", "nds", "ne", "new", "ng", "nia", "nic",
"niu", "nl", "nn", "no", "nog", "non", "nr", "nso", "nub",
"nv", "nwc", "ny", "nym", "nyn", "nyo", "nzi", "oc", "oj",
"om", "or", "os", "osa", "ota", "oto", "pa", "paa",
"pag", "pal", "pam", "pap", "pau", "peo", "phi", "phn",
"pi", "pl", "pon", "pra", "pro", "ps", "pt", "qu",
"raj", "rap", "rar", "rm", "rn", "ro", "roa", "rom",
"ru", "rup", "rw", "sa", "sad", "sah", "sai", "sal", "sam",
"sas", "sat", "sc", "sco", "sd", "se", "sel", "sem",
"sg", "sga", "sgn", "shn", "si", "sid", "sio", "sit",
"sk", "sl", "sla", "sm", "sma", "smi", "smj", "smn",
"sms", "sn", "snk", "so", "sog", "son", "sq", "sr",
"srr", "ss", "ssa", "st", "su", "suk", "sus", "sux",
"sv", "sw", "syr", "ta", "tai", "te", "tem", "ter",
"tet", "tg", "th", "ti", "tig", "tiv", "tk", "tkl",
"tl", "tlh", "tli", "tmh", "tn", "to", "tog", "tpi", "tr",
"ts", "tsi", "tt", "tum", "tup", "tut", "tvl", "tw",
"ty", "tyv", "udm", "ug", "uga", "uk", "umb", "und", "ur",
"uz", "vai", "ve", "vi", "vo", "vot", "wa", "wak",
"wal", "war", "was", "wen", "wo", "xal", "xh", "yao", "yap",
"yi", "yo", "ypk", "za", "zap", "zen", "zh", "znd",
"zu", "zun",
};
String[] tempReplacementLanguages = {
"id", "he", "yi", "jv", "sr", "nb",/* replacement language codes */
};
String[] tempObsoleteLanguages = {
"in", "iw", "ji", "jw", "sh", "no", /* obsolete language codes */
};
/* This list MUST contain a three-letter code for every two-letter code in the
list above, and they MUST ne in the same order (i.e., the same language must
be in the same place in both lists)! */
String[] tempLanguages3 = {
/*"aa", "ab", "ace", "ach", "ada", "ady", "ae", "af", "afa", */
"aar", "abk", "ace", "ach", "ada", "ady", "ave", "afr", "afa",
/*"afh", "ak", "akk", "ale", "alg", "am", "an", "ang", "apa", */
"afh", "aka", "akk", "ale", "alg", "amh", "arg", "ang", "apa",
/*"ar", "arc", "arn", "arp", "art", "arw", "as", "ast", */
"ara", "arc", "arn", "arp", "art", "arw", "asm", "ast",
/*"ath", "aus", "av", "awa", "ay", "az", "ba", "bad", */
"ath", "aus", "ava", "awa", "aym", "aze", "bak", "bad",
/*"bai", "bal", "ban", "bas", "bat", "be", "bej", */
"bai", "bal", "ban", "bas", "bat", "bel", "bej",
/*"bem", "ber", "bg", "bh", "bho", "bi", "bik", "bin", */
"bem", "ber", "bul", "bih", "bho", "bis", "bik", "bin",
/*"bla", "bm", "bn", "bnt", "bo", "br", "bra", "bs", */
"bla", "bam", "ben", "bnt", "bod", "bre", "bra", "bos",
/*"btk", "bua", "bug", "byn", "ca", "cad", "cai", "car", "cau", */
"btk", "bua", "bug", "byn", "cat", "cad", "cai", "car", "cau",
/*"ce", "ceb", "cel", "ch", "chb", "chg", "chk", "chm", */
"che", "ceb", "cel", "cha", "chb", "chg", "chk", "chm",
/*"chn", "cho", "chp", "chr", "chy", "cmc", "co", "cop", */
"chn", "cho", "chp", "chr", "chy", "cmc", "cos", "cop",
/*"cpe", "cpf", "cpp", "cr", "crh", "crp", "cs", "csb", "cu", "cus", */
"cpe", "cpf", "cpp", "cre", "crh", "crp", "ces", "csb", "chu", "cus",
/*"cv", "cy", "da", "dak", "dar", "day", "de", "del", "den", */
"chv", "cym", "dan", "dak", "dar", "day", "deu", "del", "den",
/*"dgr", "din", "doi", "dra", "dsb", "dua", "dum", "dv", "dyu", */
"dgr", "din", "doi", "dra", "dsb", "dua", "dum", "div", "dyu",
/*"dz", "ee", "efi", "egy", "eka", "el", "elx", "en", */
"dzo", "ewe", "efi", "egy", "eka", "ell", "elx", "eng",
/*"enm", "eo", "es", "et", "eu", "ewo", "fa", */
"enm", "epo", "spa", "est", "eus", "ewo", "fas",
/*"fan", "fat", "ff", "fi", "fiu", "fj", "fo", "fon", */
"fan", "fat", "ful", "fin", "fiu", "fij", "fao", "fon",
/*"fr", "frm", "fro", "fur", "fy", "ga", "gaa", "gay", */
"fra", "frm", "fro", "fur", "fry", "gle", "gaa", "gay",
/*"gba", "gd", "gem", "gez", "gil", "gl", "gmh", "gn", */
"gba", "gla", "gem", "gez", "gil", "glg", "gmh", "grn",
/*"goh", "gon", "gor", "got", "grb", "grc", "gu", "gv", */
"goh", "gon", "gor", "got", "grb", "grc", "guj", "glv",
/*"gwi", "ha", "hai", "haw", "he", "hi", "hil", "him", */
"gwi", "hau", "hai", "haw", "heb", "hin", "hil", "him",
/*"hit", "hmn", "ho", "hr", "hsb", "ht", "hu", "hup", "hy", "hz", */
"hit", "hmn", "hmo", "hrv", "hsb", "hat", "hun", "hup", "hye", "her",
/*"ia", "iba", "id", "ie", "ig", "ii", "ijo", "ik", */
"ina", "iba", "ind", "ile", "ibo", "iii", "ijo", "ipk",
/*"ilo", "inc", "ine", "inh", "io", "ira", "iro", "is", "it", */
"ilo", "inc", "ine", "inh", "ido", "ira", "iro", "isl", "ita",
/*"iu", "ja", "jbo", "jpr", "jrb", "jv", "ka", "kaa", "kab", */
"iku", "jpn", "jbo", "jpr", "jrb", "jaw", "kat", "kaa", "kab",
/*"kac", "kam", "kar", "kaw", "kbd", "kg", "kha", "khi", */
"kac", "kam", "kar", "kaw", "kbd", "kon", "kha", "khi",
/*"kho", "ki", "kj", "kk", "kl", "km", "kmb", "kn", */
"kho", "kik", "kua", "kaz", "kal", "khm", "kmb", "kan",
/*"ko", "kok", "kos", "kpe", "kr", "krc", "kro", "kru", "ks", */
"kor", "kok", "kos", "kpe", "kau", "krc", "kro", "kru", "kas",
/*"ku", "kum", "kut", "kv", "kw", "ky", "la", "lad", */
"kur", "kum", "kut", "kom", "cor", "kir", "lat", "lad",
/*"lah", "lam", "lb", "lez", "lg", "li", "ln", "lo", "lol", */
"lah", "lam", "ltz", "lez", "lug", "lim", "lin", "lao", "lol",
/*"loz", "lt", "lu", "lua", "lui", "lun", "luo", "lus", */
"loz", "lit", "lub", "lua", "lui", "lun", "luo", "lus",
/*"lv", "mad", "mag", "mai", "mak", "man", "map", "mas", */
"lav", "mad", "mag", "mai", "mak", "man", "map", "mas",
/*"mdf", "mdr", "men", "mg", "mga", "mh", "mi", "mic", "min", */
"mdf", "mdr", "men", "mlg", "mga", "mah", "mri", "mic", "min",
/*"mis", "mk", "mkh", "ml", "mn", "mnc", "mni", "mno", */
"mis", "mkd", "mkh", "mal", "mon", "mnc", "mni", "mno",
/*"mo", "moh", "mos", "mr", "ms", "mt", "mul", "mun", */
"mol", "moh", "mos", "mar", "msa", "mlt", "mul", "mun",
/*"mus", "mwr", "my", "myn", "myv", "na", "nah", "nai", "nap", */
"mus", "mwr", "mya", "myn", "myv", "nau", "nah", "nai", "nap",
/*"nb", "nd", "nds", "ne", "new", "ng", "nia", "nic", */
"nob", "nde", "nds", "nep", "new", "ndo", "nia", "nic",
/*"niu", "nl", "nn", "no", "nog", "non", "nr", "nso", "nub", */
"niu", "nld", "nno", "nor", "nog", "non", "nbl", "nso", "nub",
/*"nv", "nwc", "ny", "nym", "nyn", "nyo", "nzi", "oc", "oj", */
"nav", "nwc", "nya", "nym", "nyn", "nyo", "nzi", "oci", "oji",
/*"om", "or", "os", "osa", "ota", "oto", "pa", "paa", */
"orm", "ori", "oss", "osa", "ota", "oto", "pan", "paa",
/*"pag", "pal", "pam", "pap", "pau", "peo", "phi", "phn", */
"pag", "pal", "pam", "pap", "pau", "peo", "phi", "phn",
/*"pi", "pl", "pon", "pra", "pro", "ps", "pt", "qu", */
"pli", "pol", "pon", "pra", "pro", "pus", "por", "que",
/*"raj", "rap", "rar", "rm", "rn", "ro", "roa", "rom", */
"raj", "rap", "rar", "roh", "run", "ron", "roa", "rom",
/*"ru", "rup", "rw", "sa", "sad", "sah", "sai", "sal", "sam", */
"rus", "rup", "kin", "san", "sad", "sah", "sai", "sal", "sam",
/*"sas", "sat", "sc", "sco", "sd", "se", "sel", "sem", */
"sas", "sat", "srd", "sco", "snd", "sme", "sel", "sem",
/*"sg", "sga", "sgn", "shn", "si", "sid", "sio", "sit", */
"sag", "sga", "sgn", "shn", "sin", "sid", "sio", "sit",
/*"sk", "sl", "sla", "sm", "sma", "smi", "smj", "smn", */
"slk", "slv", "sla", "smo", "sma", "smi", "smj", "smn",
/*"sms", "sn", "snk", "so", "sog", "son", "sq", "sr", */
"sms", "sna", "snk", "som", "sog", "son", "sqi", "srp",
/*"srr", "ss", "ssa", "st", "su", "suk", "sus", "sux", */
"srr", "ssw", "ssa", "sot", "sun", "suk", "sus", "sux",
/*"sv", "sw", "syr", "ta", "tai", "te", "tem", "ter", */
"swe", "swa", "syr", "tam", "tai", "tel", "tem", "ter",
/*"tet", "tg", "th", "ti", "tig", "tiv", "tk", "tkl", */
"tet", "tgk", "tha", "tir", "tig", "tiv", "tuk", "tkl",
/*"tl", "tlh", "tli", "tmh", "tn", "to", "tog", "tpi", "tr", */
"tgl", "tlh", "tli", "tmh", "tsn", "ton", "tog", "tpi", "tur",
/*"ts", "tsi", "tt", "tum", "tup", "tut", "tvl", "tw", */
"tso", "tsi", "tat", "tum", "tup", "tut", "tvl", "twi",
/*"ty", "tyv", "udm", "ug", "uga", "uk", "umb", "und", "ur", */
"tah", "tyv", "udm", "uig", "uga", "ukr", "umb", "und", "urd",
/*"uz", "vai", "ve", "vi", "vo", "vot", "wa", "wak", */
"uzb", "vai", "ven", "vie", "vol", "vot", "wln", "wak",
/*"wal", "war", "was", "wen", "wo", "xal", "xh", "yao", "yap", */
"wal", "war", "was", "wen", "wol", "xal", "xho", "yao", "yap",
/*"yi", "yo", "ypk", "za", "zap", "zen", "zh", "znd", */
"yid", "yor", "ypk", "zha", "zap", "zen", "zho", "znd",
/*"zu", "zun", */
"zul", "zun",
};
String[] tempObsoleteLanguages3 = {
/* "in", "iw", "ji", "jw", "sh", */
"ind", "heb", "yid", "jaw", "srp",
};
synchronized (ULocale.class) {
if (_languages == null) {
_languages = tempLanguages;
_replacementLanguages = tempReplacementLanguages;
_obsoleteLanguages = tempObsoleteLanguages;
_languages3 = tempLanguages3;
_obsoleteLanguages3 = tempObsoleteLanguages3;
}
}
}
}
private static String[] _countries;
private static String[] _deprecatedCountries;
private static String[] _replacementCountries;
private static String[] _obsoleteCountries;
private static String[] _countries3;
private static String[] _obsoleteCountries3;
// Avoid initializing country tables unless we have to.
private static void initCountryTables() {
if (_countries == null) {
/* ZR(ZAR) is now CD(COD) and FX(FXX) is PS(PSE) as per
http://www.evertype.com/standards/iso3166/iso3166-1-en.html
added new codes keeping the old ones for compatibility
updated to include 1999/12/03 revisions *CWB*/
/* RO(ROM) is now RO(ROU) according to
http://www.iso.org/iso/en/prods-services/iso3166ma/03updates-on-iso-3166/nlv3e-rou.html
*/
/* This list MUST be in sorted order, and MUST contain only two-letter codes! */
String[] tempCountries = {
"AD", "AE", "AF", "AG", "AI", "AL", "AM", "AN",
"AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AX", "AZ",
"BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI",
"BJ", "BL", "BM", "BN", "BO", "BR", "BS", "BT", "BV",
"BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG",
"CH", "CI", "CK", "CL", "CM", "CN", "CO", "CR",
"CU", "CV", "CX", "CY", "CZ", "DE", "DJ", "DK",
"DM", "DO", "DZ", "EC", "EE", "EG", "EH", "ER",
"ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR",
"GA", "GB", "GD", "GE", "GF", "GG", "GH", "GI", "GL",
"GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU",
"GW", "GY", "HK", "HM", "HN", "HR", "HT", "HU",
"ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR", "IS",
"IT", "JE", "JM", "JO", "JP", "KE", "KG", "KH", "KI",
"KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA",
"LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU",
"LV", "LY", "MA", "MC", "MD", "ME", "MF", "MG", "MH", "MK",
"ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS",
"MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA",
"NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP",
"NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG",
"PH", "PK", "PL", "PM", "PN", "PR", "PS", "PT",
"PW", "PY", "QA", "RE", "RO", "RS", "RU", "RW", "SA",
"SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ",
"SK", "SL", "SM", "SN", "SO", "SR", "ST", "SV",
"SY", "SZ", "TC", "TD", "TF", "TG", "TH", "TJ",
"TK", "TL", "TM", "TN", "TO", "TR", "TT", "TV",
"TW", "TZ", "UA", "UG", "UM", "US", "UY", "UZ",
"VA", "VC", "VE", "VG", "VI", "VN", "VU", "WF",
"WS", "YE", "YT", "ZA", "ZM", "ZW",
};
/* this table is used for 3 letter codes */
String[] tempObsoleteCountries = {
"FX", "CS", "RO", "TP", "YU", "ZR", /* obsolete country codes */
};
String[] tempDeprecatedCountries = {
"BU", "CS", "DY", "FX", "HV", "NH", "RH", "TP", "YU", "ZR" /* deprecated country list */
};
String[] tempReplacementCountries = {
/* "BU", "CS", "DY", "FX", "HV", "NH", "RH", "TP", "YU", "ZR" */
"MM", "RS", "BJ", "FR", "BF", "VU", "ZW", "TL", "RS", "CD", /* replacement country codes */
};
/* This list MUST contain a three-letter code for every two-letter code in
the above list, and they MUST be listed in the same order! */
String[] tempCountries3 = {
/* "AD", "AE", "AF", "AG", "AI", "AL", "AM", "AN", */
"AND", "ARE", "AFG", "ATG", "AIA", "ALB", "ARM", "ANT",
/* "AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AX", "AZ", */
"AGO", "ATA", "ARG", "ASM", "AUT", "AUS", "ABW", "ALA", "AZE",
/* "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", */
"BIH", "BRB", "BGD", "BEL", "BFA", "BGR", "BHR", "BDI",
/* "BJ", "BL", "BM", "BN", "BO", "BR", "BS", "BT", "BV", */
"BEN", "BLM", "BMU", "BRN", "BOL", "BRA", "BHS", "BTN", "BVT",
/* "BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG", */
"BWA", "BLR", "BLZ", "CAN", "CCK", "COD", "CAF", "COG",
/* "CH", "CI", "CK", "CL", "CM", "CN", "CO", "CR", */
"CHE", "CIV", "COK", "CHL", "CMR", "CHN", "COL", "CRI",
/* "CU", "CV", "CX", "CY", "CZ", "DE", "DJ", "DK", */
"CUB", "CPV", "CXR", "CYP", "CZE", "DEU", "DJI", "DNK",
/* "DM", "DO", "DZ", "EC", "EE", "EG", "EH", "ER", */
"DMA", "DOM", "DZA", "ECU", "EST", "EGY", "ESH", "ERI",
/* "ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR", */
"ESP", "ETH", "FIN", "FJI", "FLK", "FSM", "FRO", "FRA",
/* "GA", "GB", "GD", "GE", "GF", "GG", "GH", "GI", "GL", */
"GAB", "GBR", "GRD", "GEO", "GUF", "GGY", "GHA", "GIB", "GRL",
/* "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", */
"GMB", "GIN", "GLP", "GNQ", "GRC", "SGS", "GTM", "GUM",
/* "GW", "GY", "HK", "HM", "HN", "HR", "HT", "HU", */
"GNB", "GUY", "HKG", "HMD", "HND", "HRV", "HTI", "HUN",
/* "ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR", "IS" */
"IDN", "IRL", "ISR", "IMN", "IND", "IOT", "IRQ", "IRN", "ISL",
/* "IT", "JE", "JM", "JO", "JP", "KE", "KG", "KH", "KI", */
"ITA", "JEY", "JAM", "JOR", "JPN", "KEN", "KGZ", "KHM", "KIR",
/* "KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA", */
"COM", "KNA", "PRK", "KOR", "KWT", "CYM", "KAZ", "LAO",
/* "LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU", */
"LBN", "LCA", "LIE", "LKA", "LBR", "LSO", "LTU", "LUX",
/* "LV", "LY", "MA", "MC", "MD", "ME", "MF", "MG", "MH", "MK", */
"LVA", "LBY", "MAR", "MCO", "MDA", "MNE", "MAF", "MDG", "MHL", "MKD",
/* "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", */
"MLI", "MMR", "MNG", "MAC", "MNP", "MTQ", "MRT", "MSR",
/* "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", */
"MLT", "MUS", "MDV", "MWI", "MEX", "MYS", "MOZ", "NAM",
/* "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP", */
"NCL", "NER", "NFK", "NGA", "NIC", "NLD", "NOR", "NPL",
/* "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", */
"NRU", "NIU", "NZL", "OMN", "PAN", "PER", "PYF", "PNG",
/* "PH", "PK", "PL", "PM", "PN", "PR", "PS", "PT", */
"PHL", "PAK", "POL", "SPM", "PCN", "PRI", "PSE", "PRT",
/* "PW", "PY", "QA", "RE", "RO", "RS", "RU", "RW", "SA", */
"PLW", "PRY", "QAT", "REU", "ROU", "SRB", "RUS", "RWA", "SAU",
/* "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", */
"SLB", "SYC", "SDN", "SWE", "SGP", "SHN", "SVN", "SJM",
/* "SK", "SL", "SM", "SN", "SO", "SR", "ST", "SV", */
"SVK", "SLE", "SMR", "SEN", "SOM", "SUR", "STP", "SLV",
/* "SY", "SZ", "TC", "TD", "TF", "TG", "TH", "TJ", */
"SYR", "SWZ", "TCA", "TCD", "ATF", "TGO", "THA", "TJK",
/* "TK", "TL", "TM", "TN", "TO", "TR", "TT", "TV", */
"TKL", "TLS", "TKM", "TUN", "TON", "TUR", "TTO", "TUV",
/* "TW", "TZ", "UA", "UG", "UM", "US", "UY", "UZ", */
"TWN", "TZA", "UKR", "UGA", "UMI", "USA", "URY", "UZB",
/* "VA", "VC", "VE", "VG", "VI", "VN", "VU", "WF", */
"VAT", "VCT", "VEN", "VGB", "VIR", "VNM", "VUT", "WLF",
/* "WS", "YE", "YT", "ZA", "ZM", "ZW" */
"WSM", "YEM", "MYT", "ZAF", "ZMB", "ZWE",
};
String[] tempObsoleteCountries3 = {
/*"FX", "CS", "RO", "TP", "YU", "ZR", */
"FXX", "SCG", "ROM", "TMP", "YUG", "ZAR",
};
synchronized (ULocale.class) {
if (_countries == null) {
_countries = tempCountries;
_deprecatedCountries = tempDeprecatedCountries;
_replacementCountries = tempReplacementCountries;
_obsoleteCountries = tempObsoleteCountries;
_countries3 = tempCountries3;
_obsoleteCountries3 = tempObsoleteCountries3;
}
}
}
}
private static String[][] CANONICALIZE_MAP;
private static String[][] variantsToKeywords;
private static void initCANONICALIZE_MAP() {
if (CANONICALIZE_MAP == null) {
/**
* This table lists pairs of locale ids for canonicalization. The
* The 1st item is the normalized id. The 2nd item is the
* canonicalized id. The 3rd is the keyword. The 4th is the keyword value.
*/
String[][] tempCANONICALIZE_MAP = {
// { EMPTY_STRING, "en_US_POSIX", null, null }, /* .NET name */
{ "C", "en_US_POSIX", null, null }, /* POSIX name */
{ "art_LOJBAN", "jbo", null, null }, /* registered name */
{ "az_AZ_CYRL", "az_Cyrl_AZ", null, null }, /* .NET name */
{ "az_AZ_LATN", "az_Latn_AZ", null, null }, /* .NET name */
{ "ca_ES_PREEURO", "ca_ES", "currency", "ESP" },
{ "cel_GAULISH", "cel__GAULISH", null, null }, /* registered name */
{ "de_1901", "de__1901", null, null }, /* registered name */
{ "de_1906", "de__1906", null, null }, /* registered name */
{ "de__PHONEBOOK", "de", "collation", "phonebook" }, /* Old ICU name */
{ "de_AT_PREEURO", "de_AT", "currency", "ATS" },
{ "de_DE_PREEURO", "de_DE", "currency", "DEM" },
{ "de_LU_PREEURO", "de_LU", "currency", "EUR" },
{ "el_GR_PREEURO", "el_GR", "currency", "GRD" },
{ "en_BOONT", "en__BOONT", null, null }, /* registered name */
{ "en_SCOUSE", "en__SCOUSE", null, null }, /* registered name */
{ "en_BE_PREEURO", "en_BE", "currency", "BEF" },
{ "en_IE_PREEURO", "en_IE", "currency", "IEP" },
{ "es__TRADITIONAL", "es", "collation", "traditional" }, /* Old ICU name */
{ "es_ES_PREEURO", "es_ES", "currency", "ESP" },
{ "eu_ES_PREEURO", "eu_ES", "currency", "ESP" },
{ "fi_FI_PREEURO", "fi_FI", "currency", "FIM" },
{ "fr_BE_PREEURO", "fr_BE", "currency", "BEF" },
{ "fr_FR_PREEURO", "fr_FR", "currency", "FRF" },
{ "fr_LU_PREEURO", "fr_LU", "currency", "LUF" },
{ "ga_IE_PREEURO", "ga_IE", "currency", "IEP" },
{ "gl_ES_PREEURO", "gl_ES", "currency", "ESP" },
{ "hi__DIRECT", "hi", "collation", "direct" }, /* Old ICU name */
{ "it_IT_PREEURO", "it_IT", "currency", "ITL" },
{ "ja_JP_TRADITIONAL", "ja_JP", "calendar", "japanese" },
// { "nb_NO_NY", "nn_NO", null, null },
{ "nl_BE_PREEURO", "nl_BE", "currency", "BEF" },
{ "nl_NL_PREEURO", "nl_NL", "currency", "NLG" },
{ "pt_PT_PREEURO", "pt_PT", "currency", "PTE" },
{ "sl_ROZAJ", "sl__ROZAJ", null, null }, /* registered name */
{ "sr_SP_CYRL", "sr_Cyrl_RS", null, null }, /* .NET name */
{ "sr_SP_LATN", "sr_Latn_RS", null, null }, /* .NET name */
{ "sr_YU_CYRILLIC", "sr_Cyrl_RS", null, null }, /* Linux name */
{ "th_TH_TRADITIONAL", "th_TH", "calendar", "buddhist" }, /* Old ICU name */
{ "uz_UZ_CYRILLIC", "uz_Cyrl_UZ", null, null }, /* Linux name */
{ "uz_UZ_CYRL", "uz_Cyrl_UZ", null, null }, /* .NET name */
{ "uz_UZ_LATN", "uz_Latn_UZ", null, null }, /* .NET name */
{ "zh_CHS", "zh_Hans", null, null }, /* .NET name */
{ "zh_CHT", "zh_Hant", null, null }, /* .NET name */
{ "zh_GAN", "zh__GAN", null, null }, /* registered name */
{ "zh_GUOYU", "zh", null, null }, /* registered name */
{ "zh_HAKKA", "zh__HAKKA", null, null }, /* registered name */
{ "zh_MIN", "zh__MIN", null, null }, /* registered name */
{ "zh_MIN_NAN", "zh__MINNAN", null, null }, /* registered name */
{ "zh_WUU", "zh__WUU", null, null }, /* registered name */
{ "zh_XIANG", "zh__XIANG", null, null }, /* registered name */
{ "zh_YUE", "zh__YUE", null, null } /* registered name */
};
synchronized (ULocale.class) {
if (CANONICALIZE_MAP == null) {
CANONICALIZE_MAP = tempCANONICALIZE_MAP;
}
}
}
if (variantsToKeywords == null) {
/**
* This table lists pairs of locale ids for canonicalization. The
* The first item is the normalized variant id.
*/
String[][] tempVariantsToKeywords = {
{ "EURO", "currency", "EUR" },
{ "PINYIN", "collation", "pinyin" }, /* Solaris variant */
{ "STROKE", "collation", "stroke" } /* Solaris variant */
};
synchronized (ULocale.class) {
if (variantsToKeywords == null) {
variantsToKeywords = tempVariantsToKeywords;
}
}
}
}
/*
* This table is used for mapping between ICU and special Java
* locales. When an ICU locale matches
* This constructor does not canonicalize the localeID. So, for
* example, "zh__pinyin" remains unchanged instead of converting
* to "zh@collation=pinyin". By default ICU only recognizes the
* latter as specifying pinyin collation. Use {@link #createCanonical}
* or {@link #canonicalize} if you need to canonicalize the localeID.
*
* @param localeID string representation of the locale, e.g:
* "en_US", "sy_Cyrl_YU", "zh__pinyin", "es_ES@currency=EUR;collation=traditional"
* @stable ICU 2.8
*/
public ULocale(String localeID) {
this.localeID = getName(localeID);
}
/**
* Convenience overload of ULocale(String, String, String) for
* compatibility with java.util.Locale.
* @see #ULocale(String, String, String)
* @stable ICU 3.4
*/
public ULocale(String a, String b) {
this(a, b, null);
}
/**
* Construct a ULocale from a localeID constructed from the three 'fields' a, b, and c. These
* fields are concatenated using underscores to form a localeID of
* the form a_b_c, which is then handled like the localeID passed
* to Java locale strings consisting of language, country, and
* variant will be handled by this form, since the country code
* (being shorter than four letters long) will not be interpreted
* as a script code. If a script code is present, the final
* argument ('c') will be interpreted as the country code. It is
* recommended that this constructor only be used to ease porting,
* and that clients instead use the single-argument constructor
* when constructing a ULocale from a localeID.
* @param a first component of the locale id
* @param b second component of the locale id
* @param c third component of the locale id
* @see #ULocale(String)
* @stable ICU 3.0
*/
public ULocale(String a, String b, String c) {
localeID = getName(lscvToID(a, b, c, EMPTY_STRING));
}
/**
* Create a ULocale from the id by first canonicalizing the id.
* @param nonCanonicalID the locale id to canonicalize
* @return the locale created from the canonical version of the ID.
* @stable ICU 3.0
*/
public static ULocale createCanonical(String nonCanonicalID) {
return new ULocale(canonicalize(nonCanonicalID), (Locale)null);
}
private static String lscvToID(String lang, String script, String country, String variant) {
StringBuffer buf = new StringBuffer();
if (lang != null && lang.length() > 0) {
buf.append(lang);
}
if (script != null && script.length() > 0) {
buf.append(UNDERSCORE);
buf.append(script);
}
if (country != null && country.length() > 0) {
buf.append(UNDERSCORE);
buf.append(country);
}
if (variant != null && variant.length() > 0) {
if (country == null || country.length() == 0) {
buf.append(UNDERSCORE);
}
buf.append(UNDERSCORE);
buf.append(variant);
}
return buf.toString();
}
/**
* Convert this ULocale object to a {@link java.util.Locale}.
* @return a JDK locale that either exactly represents this object
* or is the closest approximation.
* @stable ICU 2.8
*/
public Locale toLocale() {
if (locale == null) {
IDParser p = new IDParser(localeID);
String base = p.getBaseName();
for (int i = 0; i < _javaLocaleMap.length; i++) {
if (base.equals(_javaLocaleMap[i][1]) || base.equals(_javaLocaleMap[i][4])) {
if (_javaLocaleMap[i][2] != null) {
String val = p.getKeywordValue(_javaLocaleMap[i][2]);
if (val != null && val.equals(_javaLocaleMap[i][3])) {
p = new IDParser(_javaLocaleMap[i][0]);
break;
}
} else {
p = new IDParser(_javaLocaleMap[i][0]);
break;
}
}
}
String[] names = p.getLanguageScriptCountryVariant();
locale = new Locale(names[0], names[2], names[3]);
}
return locale;
}
private static ICUCache nameCache = new SimpleCache();
/**
* Keep our own default ULocale.
*/
private static Locale defaultLocale = Locale.getDefault();
private static ULocale defaultULocale = new ULocale(defaultLocale);
/**
* Returns the current default ULocale.
* @stable ICU 2.8
*/
public static ULocale getDefault() {
synchronized (ULocale.class) {
Locale currentDefault = Locale.getDefault();
if (!defaultLocale.equals(currentDefault)) {
defaultLocale = currentDefault;
defaultULocale = new ULocale(defaultLocale);
}
return defaultULocale;
}
}
/**
* Sets the default ULocale. This also sets the default Locale.
* If the caller does not have write permission to the
* user.language property, a security exception will be thrown,
* and the default ULocale will remain unchanged.
* @param newLocale the new default locale
* @throws SecurityException
* if a security manager exists and its
* Note: The valid locale will be returned correctly in ICU
* 3.0 or later. In ICU 2.8, it is not returned correctly.
* @draft ICU 2.8 (retain)
* @provisional This API might change or be removed in a future release.
*/
public static Type VALID_LOCALE = new Type();
/**
* Opaque selector enum for getLocale().
* @see com.ibm.icu.util.ULocale
* @see com.ibm.icu.util.ULocale#ACTUAL_LOCALE
* @see com.ibm.icu.util.ULocale#VALID_LOCALE
* @draft ICU 2.8 (retainAll)
* @provisional This API might change or be removed in a future release.
*/
public static final class Type {
private Type() {}
}
/**
* Based on a HTTP formatted list of acceptable locales, determine an available locale for the user.
* NullPointerException is thrown if acceptLanguageList or availableLocales is
* null. If fallback is non-null, it will contain true if a fallback locale (one
* not in the acceptLanguageList) was returned. The value on entry is ignored.
* ULocale will be one of the locales in availableLocales, or the ROOT ULocale if
* if a ROOT locale was used as a fallback (because nothing else in
* availableLocales matched). No ULocale array element should be null; behavior
* is undefined if this is the case.
* @param acceptLanguageList list in HTTP "Accept-Language:" format of acceptable locales
* @param availableLocales list of available locales. One of these will be returned.
* @param fallback if non-null, a 1-element array containing a boolean to be set with the fallback status
* @return one of the locales from the availableLocales list, or null if none match
* @stable ICU 3.4
*/
public static ULocale acceptLanguage(String acceptLanguageList, ULocale[] availableLocales,
boolean[] fallback) {
if (acceptLanguageList == null) {
throw new NullPointerException();
}
ULocale acceptList[] = null;
try {
acceptList = parseAcceptLanguage(acceptLanguageList, true);
} catch (ParseException pe) {
acceptList = null;
}
if (acceptList == null) {
return null;
}
return acceptLanguage(acceptList, availableLocales, fallback);
}
/**
* Based on a list of acceptable locales, determine an available locale for the user.
* NullPointerException is thrown if acceptLanguageList or availableLocales is
* null. If fallback is non-null, it will contain true if a fallback locale (one
* not in the acceptLanguageList) was returned. The value on entry is ignored.
* ULocale will be one of the locales in availableLocales, or the ROOT ULocale if
* if a ROOT locale was used as a fallback (because nothing else in
* availableLocales matched). No ULocale array element should be null; behavior
* is undefined if this is the case.
* @param acceptLanguageList list of acceptable locales
* @param availableLocales list of available locales. One of these will be returned.
* @param fallback if non-null, a 1-element array containing a boolean to be set with the fallback status
* @return one of the locales from the availableLocales list, or null if none match
* @stable ICU 3.4
*/
public static ULocale acceptLanguage(ULocale[] acceptLanguageList, ULocale[]
availableLocales, boolean[] fallback) {
// fallbacklist
int i,j;
if(fallback != null) {
fallback[0]=true;
}
for(i=0;i
* @param key the extension key
* @return the extension, or null if this locale
* defines no extension for the specified key.
* @throws IllegalArgumentException if the key is not valid.
* @see #PRIVATE_USE_EXTENSION
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public String getExtension(char key) {
if (!LocaleExtensions.isValidExtensionKey(key)) {
throw new IllegalArgumentException("Invalid extension key: " + key);
}
return extensions().getExtensionValue(key);
}
/**
* Returns the set of extension keys associated with this locale, or null
* if it has no extensions. The* returned set is immutable.
* @return the set of extension keys, or null if this locale has
* no extensions.
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Set getExtensionKeys() {
return extensions().getExtensionKeys();
}
/**
* Returns the LDML keyword value ('type') associated with
* the specified LDML key for this locale. LDML keywords are specified
* by the 'u' extension and consist of key/type pairs. The key must be
* two alphanumeric characters in length, or an IllegalArgumentException
* is thrown.
* @param key the LDML key
* @return the value ('type') associated with the key, or null if the
* locale does not define a value for the key.
* @throws IllegalArgumentException if the key is not valid.
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public String getLDMLExtensionValue(String key) {
if (!LocaleExtensions.isValidLDMLKey(key)) {
throw new IllegalArgumentException("Invalid LDML key: " + key);
}
return extensions().getLDMLKeywordType(key);
}
/**
* Returns the set of keys for LDML keywords defined by this locale, or
* null if this locale has no locale extension. The returned set is
* immutable.
* @return The set of the LDML keys, or null
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Set getLDMLExtensionKeys() {
return extensions().getLDMLKeywordKeys();
}
/**
* Returns a well-formed language tag representing this locale.
*
* Note: If the language, country, or variant fields do
* not satisfy BCP47 language tag syntax requirements, they are
* omitted from the result. For example, using the constructor it
* is possible to create a Locale instance with digits in the
* language field, or only two characters in the variant field.
* Since these are not well-formed BCP47 language tag syntax, they
* cannot be expressed in BCP47. Since such 'legacy' locales lose
* information when converting to BCP47, it is
* recommended that clients switch to conforming locales.
*
* Note: Underscores in the variant tag are normalized to
* hyphen, and all fields, keys, and values are normalized to
* lower case.
* @return a BCP47 language tag representing the locale.
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public String toLanguageTag() {
return LanguageTag.toLanguageTag(base(), extensions());
}
/**
* Returns a locale for the specified language tag string. If the
* specified language tag contains any ill-formed subtags, the first
* such subtag and all following subtags are ignored.
*
* This implements the 'Language-Tag' production of BCP47, and so supports
* grandfathered (regular and irregular) as well as private use language
* tags. Private use tags are represented as 'und-x-whatever', and
* grandfathered tags are converted to their canonical replacements where
* they exist. Note that a few grandfathered tags have no modern replacement,
* these will be converted using the fallback described in the first paragraph,
* so some information might be lost.
*
* For a list of grandfathered tags, see
*
* RFC4646
* (Currently Draft,
* remove or reference final version before release.)
* @param langtag the language tag
* @return the locale that best represents the language tag
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public static ULocale forLanguageTag(String langtag) {
// ULocale locale = ULocale.ROOT;
ULocale locale = new ULocale("");
LanguageTag tag = null;
while (true) {
try {
tag = LanguageTag.parse(langtag);
Builder bldr = new Builder();
String extlang = tag.getExtlang(0);
String language = (extlang == null) ? tag.getLanguage() : extlang;
// do nothing with language code "und"
if (!language.equals("und")) {
bldr.setLanguage(language);
}
bldr.setScript(tag.getScript())
.setRegion(tag.getRegion()).setVariant(tag.getVariant());
// setExtension may throw an exception if
// it contains malformed LDML keys.
Set exts = tag.getExtensions();
if (exts != null) {
Iterator itr = exts.iterator();
while (itr.hasNext()) {
Extension e = (Extension)itr.next();
bldr.setExtension(e.getSingleton(), e.getValue());
}
}
bldr.setExtension(PRIVATE_USE_EXTENSION, tag.getPrivateUse());
locale = bldr.create();
break;
} catch (LocaleSyntaxException e) {
// this exception was thrown by LanguageTag#parse
// - fall through
} catch (IllformedLocaleException e) {
// this expection was thrown by setExtension with
// malformed LDML keys - fall through
}
// remove the last subtag and try it again
int idx = langtag.lastIndexOf('-');
if (idx == -1) {
// no more subtags
break;
}
langtag = langtag.substring(0, idx);
}
return locale;
}
/**
* Builder is used to build instances of Locale from values
* configured by the setter.
*
* Builder supports the 'langtag' production of RFC 4646.
* Language tags consist of the ASCII digits, upper and lower case
* letters, and hyphen (which appears only as a field separator).
* As a convenience, underscores are accepted and normalized to
* hyphen. Values with any other character are ill-formed. Since
* language tags are case-insensitive, they are normalized
* to lower case, case distinctions are not
* preserved by the builder.
*
* Note that since this implements 'langtag' and not 'Language-Tag',
* grandfathered language tags are not supported by the builder.
* Clients should use {@link #forLanguageTag} instead.
*
* Builders can be reused;
* note:The extension 'u' is used for LDML Keywords.
* Setting the 'u' extension replaces any existing LDML
* keywords with those defined in the extension. To be
* well-formed, a value for the 'u' extension must meet the
* additional constraint that the number of fields be even
* (fields represent key value pairs, where the value is
* mandatory), and that the keys and values be legal locale
* extension keys and values.
* @param key the extension key
* @param value the extension value
* @return this builder
* @throws IllformedLocaleException if
* Note:Setting the 'u' extension replaces all LDML
* keywords with those defined in the extension.
* @param key the LDML extension key
* @param value the LDML extension value
* @return this builder
* @throws IllformedLocaleException if
* The Buddhist calendar is identical to the Gregorian calendar in all respects
* except for the year and era. Years are numbered since the birth of the
* Buddha in 543 BC (Gregorian), so that 1 AD (Gregorian) is equivalent to 544
* BE (Buddhist Era) and 1998 AD is 2541 BE.
*
* The Buddhist Calendar has only one allowable era:
* This class should not be subclassed.
* BuddhistCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a
* Some details of Indian National Calendar (to be implemented) :
* The Months
* Month Length Start date (Gregorian)
* =================================================
* 1 Chaitra 30/31 March 22*
* 2 Vaisakha 31 April 21
* 3 Jyaistha 31 May 22
* 4 Asadha 31 June 22
* 5 Sravana 31 July 23
* 6 Bhadra 31 August 23
* 7 Asvina 30 September 23
* 8 Kartika 30 October 23
* 9 Agrahayana 30 November 22
* 10 Pausa 30 December 22
* 11 Magha 30 January 21
* 12 Phalguna 30 February 20
* In leap years, Chaitra has 31 days and starts on March 21 instead.
* The leap years of Gregorian calendar and Indian National Calendar are in synchornization.
* So When its a leap year in Gregorian calendar then Chaitra has 31 days.
*
* The Years
* Years are counted in the Saka Era, which starts its year 0 in 78AD (by gregorian calendar).
* So for eg. 9th June 2006 by Gregorian Calendar, is same as 19th of Jyaistha in 1928 of Saka
* era by Indian National Calendar.
*
* The Indian Calendar has only one allowable era:
* This class should not be subclassed.
* IndianCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a
* Generally passed as an argument object into a method. The method takes
* responsibility of writing into the internal byte array and increasing its
* size when necessary.
*
* The Hebrew calendar is lunisolar and thus has a number of interesting
* properties that distinguish it from the Gregorian. Months start
* on the day of (an arithmetic approximation of) each new moon. Since the
* solar year (approximately 365.24 days) is not an even multiple of
* the lunar month (approximately 29.53 days) an extra "leap month" is
* inserted in 7 out of every 19 years. To make matters even more
* interesting, the start of a year can be delayed by up to three days
* in order to prevent certain holidays from falling on the Sabbath and
* to prevent certain illegal year lengths. Finally, the lengths of certain
* months can vary depending on the number of days in the year.
*
* The leap month is known as "Adar 1" and is inserted between the
* months of Shevat and Adar in leap years. Since the leap month does
* not come at the end of the year, calculations involving
* month numbers are particularly complex. Users of this class should
* make sure to use the {@link #roll roll} and {@link #add add} methods
* rather than attempting to perform date arithmetic by manipulating
* the fields directly.
*
* Note: In the traditional Hebrew calendar, days start at sunset.
* However, in order to keep the time fields in this class
* synchronized with those of the other calendars and with local clock time,
* we treat days and months as beginning at midnight,
* roughly 6 hours after the corresponding sunset.
*
* If you are interested in more information on the rules behind the Hebrew
* calendar, see one of the following references:
*
* This class should not be subclassed.
* HebrewCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a
* When adding to certain fields, the values of other fields may conflict and
* need to be changed. For example, when adding one to the {@link #MONTH MONTH} field
* for the date "30 Av 5758", the {@link #DAY_OF_MONTH DAY_OF_MONTH} field
* must be adjusted so that the result is "29 Elul 5758" rather than the invalid
* "30 Elul 5758".
*
* This method is able to add to
* all fields except for {@link #ERA ERA}, {@link #DST_OFFSET DST_OFFSET},
* and {@link #ZONE_OFFSET ZONE_OFFSET}.
*
* Note: You should always use {@link #roll roll} and add rather
* than attempting to perform arithmetic operations directly on the fields
* of a HebrewCalendar. Since the {@link #MONTH MONTH} field behaves
* discontinuously in non-leap years, simple arithmetic can give invalid results.
*
* @param field the time field.
* @param amount the amount to add to the field.
*
* @exception IllegalArgumentException if the field is invalid or refers
* to a field that cannot be handled by this method.
* @stable ICU 2.8
*/
public void add(int field, int amount)
{
switch (field) {
case MONTH:
{
// We can't just do a set(MONTH, get(MONTH) + amount). The
// reason is ADAR_1. Suppose amount is +2 and we land in
// ADAR_1 -- then we have to bump to ADAR_2 aka ADAR. But
// if amount is -2 and we land in ADAR_1, then we have to
// bump the other way -- down to SHEVAT. - Alan 11/00
int month = get(MONTH);
int year = get(YEAR);
boolean acrossAdar1;
if (amount > 0) {
acrossAdar1 = (month < ADAR_1); // started before ADAR_1?
month += amount;
for (;;) {
if (acrossAdar1 && month>=ADAR_1 && !isLeapYear(year)) {
++month;
}
if (month <= ELUL) {
break;
}
month -= ELUL+1;
++year;
acrossAdar1 = true;
}
} else {
acrossAdar1 = (month > ADAR_1); // started after ADAR_1?
month += amount;
for (;;) {
if (acrossAdar1 && month<=ADAR_1 && !isLeapYear(year)) {
--month;
}
if (month >= 0) {
break;
}
month += ELUL+1;
--year;
acrossAdar1 = true;
}
}
set(MONTH, month);
set(YEAR, year);
pinField(DAY_OF_MONTH);
break;
}
default:
super.add(field, amount);
break;
}
}
/**
* Rolls (up/down) a specified amount time on the given field. For
* example, to roll the current date up by three days, you can call
*
* When rolling certain fields, the values of other fields may conflict and
* need to be changed. For example, when rolling the {@link #MONTH MONTH} field
* upward by one for the date "30 Av 5758", the {@link #DAY_OF_MONTH DAY_OF_MONTH} field
* must be adjusted so that the result is "29 Elul 5758" rather than the invalid
* "30 Elul".
*
* This method is able to roll
* all fields except for {@link #ERA ERA}, {@link #DST_OFFSET DST_OFFSET},
* and {@link #ZONE_OFFSET ZONE_OFFSET}. Subclasses may, of course, add support for
* additional fields in their overrides of
* Note: You should always use roll and {@link #add add} rather
* than attempting to perform arithmetic operations directly on the fields
* of a HebrewCalendar. Since the {@link #MONTH MONTH} field behaves
* discontinuously in non-leap years, simple arithmetic can give invalid results.
*
* @param field the time field.
* @param amount the amount by which the field should be rolled.
*
* @exception IllegalArgumentException if the field is invalid or refers
* to a field that cannot be handled by this method.
* @stable ICU 2.8
*/
public void roll(int field, int amount)
{
switch (field) {
case MONTH:
{
int month = get(MONTH);
int year = get(YEAR);
boolean leapYear = isLeapYear(year);
int yearLength = monthsInYear(year);
int newMonth = month + (amount % yearLength);
//
// If it's not a leap year and we're rolling past the missing month
// of ADAR_1, we need to roll an extra month to make up for it.
//
if (!leapYear) {
if (amount > 0 && month < ADAR_1 && newMonth >= ADAR_1) {
newMonth++;
} else if (amount < 0 && month > ADAR_1 && newMonth <= ADAR_1) {
newMonth--;
}
}
set(MONTH, (newMonth + 13) % 13);
pinField(DAY_OF_MONTH);
return;
}
default:
super.roll(field, amount);
}
}
//-------------------------------------------------------------------------
// Support methods
//-------------------------------------------------------------------------
// Hebrew date calculations are performed in terms of days, hours, and
// "parts" (or halakim), which are 1/1080 of an hour, or 3 1/3 seconds.
private static final long HOUR_PARTS = 1080;
private static final long DAY_PARTS = 24*HOUR_PARTS;
// An approximate value for the length of a lunar month.
// It is used to calculate the approximate year and month of a given
// absolute date.
static private final int MONTH_DAYS = 29;
static private final long MONTH_FRACT = 12*HOUR_PARTS + 793;
static private final long MONTH_PARTS = MONTH_DAYS*DAY_PARTS + MONTH_FRACT;
// The time of the new moon (in parts) on 1 Tishri, year 1 (the epoch)
// counting from noon on the day before. BAHARAD is an abbreviation of
// Bet (Monday), Hey (5 hours from sunset), Resh-Daled (204).
static private final long BAHARAD = 11*HOUR_PARTS + 204;
/**
* Finds the day # of the first day in the given Hebrew year.
* To do this, we want to calculate the time of the Tishri 1 new moon
* in that year.
*
* The algorithm here is similar to ones described in a number of
* references, including:
* In addition, subclasses should compute any subclass-specific
* fields, that is, fields from BASE_FIELD_COUNT to
* getFieldCount() - 1.
* @stable ICU 2.8
*/
protected void handleComputeFields(int julianDay) {
long d = julianDay - 347997;
long m = (d * DAY_PARTS) / MONTH_PARTS; // Months (approx)
int year = (int)((19 * m + 234) / 235) + 1; // Years (approx)
long ys = startOfYear(year); // 1st day of year
int dayOfYear = (int)(d - ys);
// Because of the postponement rules, it's possible to guess wrong. Fix it.
while (dayOfYear < 1) {
year--;
ys = startOfYear(year);
dayOfYear = (int)(d - ys);
}
// Now figure out which month we're in, and the date within that month
int yearType = yearType(year);
int monthStart[][] = isLeapYear(year) ? LEAP_MONTH_START : MONTH_START;
int month = 0;
while (dayOfYear > monthStart[month][yearType]) {
month++;
}
month--;
int dayOfMonth = dayOfYear - monthStart[month][yearType];
internalSet(ERA, 0);
internalSet(YEAR, year);
internalSet(EXTENDED_YEAR, year);
internalSet(MONTH, month);
internalSet(DAY_OF_MONTH, dayOfMonth);
internalSet(DAY_OF_YEAR, dayOfYear);
}
//-------------------------------------------------------------------------
// Functions for converting from field values to milliseconds
//-------------------------------------------------------------------------
/**
* @stable ICU 2.8
*/
protected int handleGetExtendedYear() {
int year;
if (newerField(EXTENDED_YEAR, YEAR) == EXTENDED_YEAR) {
year = internalGet(EXTENDED_YEAR, 1); // Default to year 1
} else {
year = internalGet(YEAR, 1); // Default to year 1
}
return year;
}
/**
* Return JD of start of given month/year.
* @stable ICU 2.8
*/
protected int handleComputeMonthStart(int eyear, int month, boolean useMonth) {
// Resolve out-of-range months. This is necessary in order to
// obtain the correct year. We correct to
// a 12- or 13-month year (add/subtract 12 or 13, depending
// on the year) but since we _always_ number from 0..12, and
// the leap year determines whether or not month 5 (Adar 1)
// is present, we allow 0..12 in any given year.
while (month < 0) {
month += monthsInYear(--eyear);
}
// Careful: allow 0..12 in all years
while (month > 12) {
month -= monthsInYear(eyear++);
}
long day = startOfYear(eyear);
if (month != 0) {
if (isLeapYear(eyear)) {
day += LEAP_MONTH_START[month][yearType(eyear)];
} else {
day += MONTH_START[month][yearType(eyear)];
}
}
return (int) (day + 347997);
}
/**
* Return the current Calendar type.
* @return type of calendar
* @stable ICU 3.8
*/
public String getType() {
return "hebrew";
}
/*
private static CalendarFactory factory;
public static CalendarFactory factory() {
if (factory == null) {
factory = new CalendarFactory() {
public Calendar create(TimeZone tz, ULocale loc) {
return new HebrewCalendar(tz, loc);
}
public String factoryName() {
return "Hebrew";
}
};
}
return factory;
}
*/
}
icu4j-4.2.1.1/src/com/ibm/icu/util/TimeZoneTransition.java 0000644 0001750 0001750 00000004711 11017153155 023154 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2007-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
/**
* The string tokenizer class allows an application to break a string
* into tokens by performing code point comparison.
* The
* The set of delimiters (the codepoints that separate tokens) may be
* specified either at creation time or on a per-token basis.
*
* An instance of A token is thus either one
* delimiter code point, a maximal sequence of consecutive code points that
* are delimiters, or a maximal sequence of consecutive code
* points that are not delimiters.
*
* A StringTokenizer object internally maintains a current
* position within the string to be tokenized. Some operations advance this
* current position past the code point processed.
*
* A token is returned by taking a substring of the string that was used to
* create the StringTokenizer object.
*
* Example of the use of the default delimiter tokenizer.
*
* prints the following output:
* ULocale(String localeID).
*
* checkPermission method doesn't allow the operation.
* @throws NullPointerException if newLocale is null
* @see SecurityManager#checkPermission(java.security.Permission)
* @see java.util.PropertyPermission
* @stable ICU 3.0
*/
public static synchronized void setDefault(ULocale newLocale){
Locale.setDefault(newLocale.toLocale());
defaultULocale = newLocale;
}
/**
* This is for compatibility with Locale-- in actuality, since ULocale is
* immutable, there is no reason to clone it, so this API returns 'this'.
* @stable ICU 3.0
*/
public Object clone() {
return this;
}
/**
* Returns the hashCode.
* @stable ICU 3.0
*/
public int hashCode() {
return localeID.hashCode();
}
/**
* Returns true if the other object is another ULocale with the
* same full name, or is a String localeID that matches the full name.
* Note that since names are not canonicalized, two ULocales that
* function identically might not compare equal.
*
* @return true if this Locale is equal to the specified object.
* @stable ICU 3.0
*/
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof String) {
return localeID.equals((String)obj);
}
if (obj instanceof ULocale) {
return localeID.equals(((ULocale)obj).localeID);
}
return false;
}
/**
* Returns a list of all installed locales.
* @stable ICU 3.0
*/
public static ULocale[] getAvailableLocales() {
return ICUResourceBundle.getAvailableULocales();
}
private static VersionInfo gCLDRVersion = null;
/**
* Returns the current CLDR version
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public static VersionInfo getCLDRVersion() {
// fetching this data should be idempotent.
if(gCLDRVersion == null) {
// from ZoneMeta.java
UResourceBundle supplementalDataBundle = UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "supplementalData", ICUResourceBundle.ICU_DATA_CLASS_LOADER);
UResourceBundle cldrVersionBundle = supplementalDataBundle.get("cldrVersion");
gCLDRVersion = VersionInfo.getInstance(cldrVersionBundle.getString());
}
return gCLDRVersion;
}
/**
* Returns a list of all 2-letter country codes defined in ISO 3166.
* Can be used to create Locales.
* @stable ICU 3.0
*/
public static String[] getISOCountries() {
initCountryTables();
return (String[])_countries.clone();
}
/**
* Returns a list of all 2-letter language codes defined in ISO 639.
* Can be used to create Locales.
* [NOTE: ISO 639 is not a stable standard-- some languages' codes have changed.
* The list this function returns includes both the new and the old codes for the
* languages whose codes have changed.]
* @stable ICU 3.0
*/
public static String[] getISOLanguages() {
initLanguageTables();
return (String[])_languages.clone();
}
/**
* Returns the language code for this locale, which will either be the empty string
* or a lowercase ISO 639 code.
* @see #getDisplayLanguage()
* @see #getDisplayLanguage(ULocale)
* @stable ICU 3.0
*/
public String getLanguage() {
return getLanguage(localeID);
}
/**
* Returns the language code for the locale ID,
* which will either be the empty string
* or a lowercase ISO 639 code.
* @see #getDisplayLanguage()
* @see #getDisplayLanguage(ULocale)
* @stable ICU 3.0
*/
public static String getLanguage(String localeID) {
return new IDParser(localeID).getLanguage();
}
/**
* Returns the script code for this locale, which might be the empty string.
* @see #getDisplayScript()
* @see #getDisplayScript(ULocale)
* @stable ICU 3.0
*/
public String getScript() {
return getScript(localeID);
}
/**
* Returns the script code for the specified locale, which might be the empty string.
* @see #getDisplayScript()
* @see #getDisplayScript(ULocale)
* @stable ICU 3.0
*/
public static String getScript(String localeID) {
return new IDParser(localeID).getScript();
}
/**
* Returns the country/region code for this locale, which will either be the empty string
* or an uppercase ISO 3166 2-letter code.
* @see #getDisplayCountry()
* @see #getDisplayCountry(ULocale)
* @stable ICU 3.0
*/
public String getCountry() {
return getCountry(localeID);
}
/**
* Returns the country/region code for this locale, which will either be the empty string
* or an uppercase ISO 3166 2-letter code.
* @param localeID
* @see #getDisplayCountry()
* @see #getDisplayCountry(ULocale)
* @stable ICU 3.0
*/
public static String getCountry(String localeID) {
return new IDParser(localeID).getCountry();
}
/**
* Returns the variant code for this locale, which might be the empty string.
* @see #getDisplayVariant()
* @see #getDisplayVariant(ULocale)
* @stable ICU 3.0
*/
public String getVariant() {
return getVariant(localeID);
}
/**
* Returns the variant code for the specified locale, which might be the empty string.
* @see #getDisplayVariant()
* @see #getDisplayVariant(ULocale)
* @stable ICU 3.0
*/
public static String getVariant(String localeID) {
return new IDParser(localeID).getVariant();
}
/**
* Returns the fallback locale for the specified locale, which might be the empty string.
* @stable ICU 3.2
*/
public static String getFallback(String localeID) {
return getFallbackString(getName(localeID));
}
/**
* Returns the fallback locale for this locale. If this locale is root, returns null.
* @stable ICU 3.2
*/
public ULocale getFallback() {
if (localeID.length() == 0 || localeID.charAt(0) == '@') {
return null;
}
return new ULocale(getFallbackString(localeID), (Locale)null);
}
/**
* Return the given (canonical) locale id minus the last part before the tags.
*/
private static String getFallbackString(String fallback) {
int limit = fallback.indexOf('@');
if (limit == -1) {
limit = fallback.length();
}
int start = fallback.lastIndexOf('_', limit);
if (start == -1) {
start = 0;
}
return fallback.substring(0, start) + fallback.substring(limit);
}
/**
* Returns the (normalized) base name for this locale.
* @return the base name as a String.
* @stable ICU 3.0
*/
public String getBaseName() {
return getBaseName(localeID);
}
/**
* Returns the (normalized) base name for the specified locale.
* @param localeID the locale ID as a string
* @return the base name as a String.
* @stable ICU 3.0
*/
public static String getBaseName(String localeID){
if (localeID.indexOf('@') == -1) {
return localeID;
}
return new IDParser(localeID).getBaseName();
}
/**
* Returns the (normalized) full name for this locale.
*
* @return String the full name of the localeID
* @stable ICU 3.0
*/
public String getName() {
return localeID; // always normalized
}
/**
* Returns the (normalized) full name for the specified locale.
*
* @param localeID the localeID as a string
* @return String the full name of the localeID
* @stable ICU 3.0
*/
public static String getName(String localeID){
String name = (String)nameCache.get(localeID);
if (name == null) {
name = new IDParser(localeID).getName();
nameCache.put(localeID, name);
}
return name;
}
/**
* Returns a string representation of this object.
* @stable ICU 3.0
*/
public String toString() {
return localeID;
}
/**
* Returns an iterator over keywords for this locale. If there
* are no keywords, returns null.
* @return iterator over keywords, or null if there are no keywords.
* @stable ICU 3.0
*/
public Iterator getKeywords() {
return getKeywords(localeID);
}
/**
* Returns an iterator over keywords for the specified locale. If there
* are no keywords, returns null.
* @return an iterator over the keywords in the specified locale, or null
* if there are no keywords.
* @stable ICU 3.0
*/
public static Iterator getKeywords(String localeID){
return new IDParser(localeID).getKeywords();
}
/**
* Returns the value for a keyword in this locale. If the keyword is not defined, returns null.
* @param keywordName name of the keyword whose value is desired. Case insensitive.
* @return the value of the keyword, or null.
* @stable ICU 3.0
*/
public String getKeywordValue(String keywordName){
return getKeywordValue(localeID, keywordName);
}
/**
* Returns the value for a keyword in the specified locale. If the keyword is not defined, returns null.
* The locale name does not need to be normalized.
* @param keywordName name of the keyword whose value is desired. Case insensitive.
* @return String the value of the keyword as a string
* @stable ICU 3.0
*/
public static String getKeywordValue(String localeID, String keywordName) {
return new IDParser(localeID).getKeywordValue(keywordName);
}
/**
* Utility class to parse and normalize locale ids (including POSIX style)
*/
private static final class IDParser {
private char[] id;
private int index;
private char[] buffer;
private int blen;
// um, don't handle POSIX ids unless we request it. why not? well... because.
private boolean canonicalize;
private boolean hadCountry;
// used when canonicalizing
Map keywords;
String baseName;
/**
* Parsing constants.
*/
private static final char KEYWORD_SEPARATOR = '@';
private static final char HYPHEN = '-';
private static final char KEYWORD_ASSIGN = '=';
private static final char COMMA = ',';
private static final char ITEM_SEPARATOR = ';';
private static final char DOT = '.';
private IDParser(String localeID) {
this(localeID, false);
}
private IDParser(String localeID, boolean canonicalize) {
id = localeID.toCharArray();
index = 0;
buffer = new char[id.length + 5];
blen = 0;
this.canonicalize = canonicalize;
}
private void reset() {
index = blen = 0;
}
// utilities for working on text in the buffer
/**
* Append c to the buffer.
*/
private void append(char c) {
try {
buffer[blen] = c;
}
catch (IndexOutOfBoundsException e) {
if (buffer.length > 512) {
// something is seriously wrong, let this go
throw e;
}
char[] nbuffer = new char[buffer.length * 2];
System.arraycopy(buffer, 0, nbuffer, 0, buffer.length);
nbuffer[blen] = c;
buffer = nbuffer;
}
++blen;
}
private void addSeparator() {
append(UNDERSCORE);
}
/**
* Returns the text in the buffer from start to blen as a String.
*/
private String getString(int start) {
if (start == blen) {
return EMPTY_STRING;
}
return new String(buffer, start, blen-start);
}
/**
* Set the length of the buffer to pos, then append the string.
*/
private void set(int pos, String s) {
this.blen = pos; // no safety
append(s);
}
/**
* Append the string to the buffer.
*/
private void append(String s) {
for (int i = 0; i < s.length(); ++i) {
append(s.charAt(i));
}
}
// utilities for parsing text out of the id
/**
* Character to indicate no more text is available in the id.
*/
private static final char DONE = '\uffff';
/**
* Returns the character at index in the id, and advance index. The returned character
* is DONE if index was at the limit of the buffer. The index is advanced regardless
* so that decrementing the index will always 'unget' the last character returned.
*/
private char next() {
if (index == id.length) {
index++;
return DONE;
}
return id[index++];
}
/**
* Advance index until the next terminator or id separator, and leave it there.
*/
private void skipUntilTerminatorOrIDSeparator() {
while (!isTerminatorOrIDSeparator(next())) {
}
--index;
}
/**
* Returns true if the character at index in the id is a terminator.
*/
private boolean atTerminator() {
return index >= id.length || isTerminator(id[index]);
}
/*
* Returns true if the character is an id separator (underscore or hyphen).
*/
/* private boolean isIDSeparator(char c) {
return c == UNDERSCORE || c == HYPHEN;
}*/
/**
* Returns true if the character is a terminator (keyword separator, dot, or DONE).
* Dot is a terminator because of the POSIX form, where dot precedes the codepage.
*/
private boolean isTerminator(char c) {
// always terminate at DOT, even if not handling POSIX. It's an error...
return c == KEYWORD_SEPARATOR || c == DONE || c == DOT;
}
/**
* Returns true if the character is a terminator or id separator.
*/
private boolean isTerminatorOrIDSeparator(char c) {
return c == KEYWORD_SEPARATOR || c == UNDERSCORE || c == HYPHEN ||
c == DONE || c == DOT;
}
/**
* Returns true if the start of the buffer has an experimental or private language
* prefix, the pattern '[ixIX][-_].' shows the syntax checked.
*/
private boolean haveExperimentalLanguagePrefix() {
if (id.length > 2) {
char c = id[1];
if (c == HYPHEN || c == UNDERSCORE) {
c = id[0];
return c == 'x' || c == 'X' || c == 'i' || c == 'I';
}
}
return false;
}
/**
* Returns true if a value separator occurs at or after index.
*/
private boolean haveKeywordAssign() {
// assume it is safe to start from index
for (int i = index; i < id.length; ++i) {
if (id[i] == KEYWORD_ASSIGN) {
return true;
}
}
return false;
}
/**
* Advance index past language, and accumulate normalized language code in buffer.
* Index must be at 0 when this is called. Index is left at a terminator or id
* separator. Returns the start of the language code in the buffer.
*/
private int parseLanguage() {
if (haveExperimentalLanguagePrefix()) {
append(Character.toLowerCase(id[0]));
append(HYPHEN);
index = 2;
}
char c;
while(!isTerminatorOrIDSeparator(c = next())) {
append(Character.toLowerCase(c));
}
--index; // unget
if (blen == 3) {
initLanguageTables();
/* convert 3 character code to 2 character code if possible *CWB*/
String lang = getString(0);
int offset = findIndex(_languages3, lang);
if (offset >= 0) {
set(0, _languages[offset]);
} else {
offset = findIndex(_obsoleteLanguages3, lang);
if (offset >= 0) {
set(0, _obsoleteLanguages[offset]);
}
}
}
return 0;
}
/**
* Advance index past language. Index must be at 0 when this is called. Index
* is left at a terminator or id separator.
*/
private void skipLanguage() {
if (haveExperimentalLanguagePrefix()) {
index = 2;
}
skipUntilTerminatorOrIDSeparator();
}
/**
* Advance index past script, and accumulate normalized script in buffer.
* Index must be immediately after the language.
* If the item at this position is not a script (is not four characters
* long) leave index and buffer unchanged. Otherwise index is left at
* a terminator or id separator. Returns the start of the script code
* in the buffer (this may be equal to the buffer length, if there is no
* script).
*/
private int parseScript() {
if (!atTerminator()) {
int oldIndex = index; // save original index
++index;
int oldBlen = blen; // get before append hyphen, if we truncate everything is undone
char c;
while(!isTerminatorOrIDSeparator(c = next())) {
if (blen == oldBlen) { // first pass
addSeparator();
append(Character.toUpperCase(c));
} else {
append(Character.toLowerCase(c));
}
}
--index; // unget
/* If it's not exactly 4 characters long, then it's not a script. */
if (index - oldIndex != 5) { // +1 to account for separator
index = oldIndex;
blen = oldBlen;
} else {
oldBlen++; // index past hyphen, for clients who want to extract just the script
}
return oldBlen;
}
return blen;
}
/**
* Advance index past script.
* Index must be immediately after the language and IDSeparator.
* If the item at this position is not a script (is not four characters
* long) leave index. Otherwise index is left at a terminator or
* id separator.
*/
private void skipScript() {
if (!atTerminator()) {
int oldIndex = index;
++index;
skipUntilTerminatorOrIDSeparator();
if (index - oldIndex != 5) { // +1 to account for separator
index = oldIndex;
}
}
}
/**
* Advance index past country, and accumulate normalized country in buffer.
* Index must be immediately after the script (if there is one, else language)
* and IDSeparator. Return the start of the country code in the buffer.
*/
private int parseCountry() {
if (!atTerminator()) {
int oldIndex = index;
++index;
int oldBlen = blen;
char c;
while (!isTerminatorOrIDSeparator(c = next())) {
if (oldBlen == blen) { // first, add hyphen
hadCountry = true; // we have a country, let variant parsing know
addSeparator();
++oldBlen; // increment past hyphen
}
append(Character.toUpperCase(c));
}
--index; // unget
int charsAppended = blen - oldBlen;
if (charsAppended == 0) {
// Do nothing.
}
else if (charsAppended < 2 || charsAppended > 3) {
// It's not a country, so return index and blen to
// their previous values.
index = oldIndex;
--oldBlen;
blen = oldBlen;
hadCountry = false;
}
else if (charsAppended == 3) {
initCountryTables();
/* convert 3 character code to 2 character code if possible *CWB*/
int offset = findIndex(_countries3, getString(oldBlen));
if (offset >= 0) {
set(oldBlen, _countries[offset]);
} else {
offset = findIndex(_obsoleteCountries3, getString(oldBlen));
if (offset >= 0) {
set(oldBlen, _obsoleteCountries[offset]);
}
}
}
return oldBlen;
}
return blen;
}
/**
* Advance index past country.
* Index must be immediately after the script (if there is one, else language)
* and IDSeparator.
*/
private void skipCountry() {
if (!atTerminator()) {
++index;
/*
* Save the index point after the separator, since the format
* requires two separators if the country is not present.
*/
int oldIndex = index;
skipUntilTerminatorOrIDSeparator();
int charsSkipped = index - oldIndex;
if (charsSkipped < 2 || charsSkipped > 3) {
index = oldIndex;
}
}
}
/**
* Advance index past variant, and accumulate normalized variant in buffer. This ignores
* the codepage information from POSIX ids. Index must be immediately after the country
* or script. Index is left at the keyword separator or at the end of the text. Return
* the start of the variant code in the buffer.
*
* In standard form, we can have the following forms:
* ll__VVVV
* ll_CC_VVVV
* ll_Ssss_VVVV
* ll_Ssss_CC_VVVV
*
* This also handles POSIX ids, which can have the following forms (pppp is code page id):
* ll_CC.pppp --> ll_CC
* ll_CC.pppp@VVVV --> ll_CC_VVVV
* ll_CC@VVVV --> ll_CC_VVVV
*
* We identify this use of '@' in POSIX ids by looking for an '=' following
* the '@'. If there is one, we consider '@' to start a keyword list, instead of
* being part of a POSIX id.
*
* Note: since it was decided that we want an option to not handle POSIX ids, this
* becomes a bit more complex.
*/
private int parseVariant() {
int oldBlen = blen;
boolean start = true;
boolean needSeparator = true;
boolean skipping = false;
char c;
while ((c = next()) != DONE) {
if (c == DOT) {
start = false;
skipping = true;
} else if (c == KEYWORD_SEPARATOR) {
if (haveKeywordAssign()) {
break;
}
skipping = false;
start = false;
needSeparator = true; // add another underscore if we have more text
} else if (start) {
start = false;
} else if (!skipping) {
if (needSeparator) {
boolean incOldBlen = blen == oldBlen; // need to skip separators
needSeparator = false;
if (incOldBlen && !hadCountry) { // no country, we'll need two
addSeparator();
++oldBlen; // for sure
}
addSeparator();
if (incOldBlen) { // only for the first separator
++oldBlen;
}
}
c = Character.toUpperCase(c);
if (c == HYPHEN || c == COMMA) {
c = UNDERSCORE;
}
append(c);
}
}
--index; // unget
return oldBlen;
}
// no need for skipvariant, to get the keywords we'll just scan directly for
// the keyword separator
/**
* Returns the normalized language id, or the empty string.
*/
public String getLanguage() {
reset();
return getString(parseLanguage());
}
/**
* Returns the normalized script id, or the empty string.
*/
public String getScript() {
reset();
skipLanguage();
return getString(parseScript());
}
/**
* return the normalized country id, or the empty string.
*/
public String getCountry() {
reset();
skipLanguage();
skipScript();
return getString(parseCountry());
}
/**
* Returns the normalized variant id, or the empty string.
*/
public String getVariant() {
reset();
skipLanguage();
skipScript();
skipCountry();
return getString(parseVariant());
}
/**
* Returns the language, script, country, and variant as separate strings.
*/
public String[] getLanguageScriptCountryVariant() {
reset();
return new String[] {
getString(parseLanguage()),
getString(parseScript()),
getString(parseCountry()),
getString(parseVariant())
};
}
public void setBaseName(String baseName) {
this.baseName = baseName;
}
public void parseBaseName() {
if (baseName != null) {
set(0, baseName);
} else {
reset();
parseLanguage();
parseScript();
parseCountry();
parseVariant();
// catch unwanted trailing underscore after country if there was no variant
if (blen > 1 && buffer[blen-1] == UNDERSCORE) {
--blen;
}
}
}
/**
* Returns the normalized base form of the locale id. The base
* form does not include keywords.
*/
public String getBaseName() {
if (baseName != null) {
return baseName;
}
parseBaseName();
return getString(0);
}
/**
* Returns the normalized full form of the locale id. The full
* form includes keywords if they are present.
*/
public String getName() {
parseBaseName();
parseKeywords();
return getString(0);
}
// keyword utilities
/**
* If we have keywords, advance index to the start of the keywords and return true,
* otherwise return false.
*/
private boolean setToKeywordStart() {
for (int i = index; i < id.length; ++i) {
if (id[i] == KEYWORD_SEPARATOR) {
if (canonicalize) {
for (int j = ++i; j < id.length; ++j) { // increment i past separator for return
if (id[j] == KEYWORD_ASSIGN) {
index = i;
return true;
}
}
} else {
if (++i < id.length) {
index = i;
return true;
}
}
break;
}
}
return false;
}
private static boolean isDoneOrKeywordAssign(char c) {
return c == DONE || c == KEYWORD_ASSIGN;
}
private static boolean isDoneOrItemSeparator(char c) {
return c == DONE || c == ITEM_SEPARATOR;
}
private String getKeyword() {
int start = index;
while (!isDoneOrKeywordAssign(next())) {
}
--index;
return AsciiUtil.toLowerString(new String(id, start, index-start).trim());
}
private String getValue() {
int start = index;
while (!isDoneOrItemSeparator(next())) {
}
--index;
return new String(id, start, index-start).trim(); // leave case alone
}
private Comparator getKeyComparator() {
final Comparator comp = new Comparator() {
public int compare(Object lhs, Object rhs) {
return ((String)lhs).compareTo((String)rhs);
}
};
return comp;
}
/**
* Returns a map of the keywords and values, or null if there are none.
*/
private Map getKeywordMap() {
if (keywords == null) {
TreeMap m = null;
if (setToKeywordStart()) {
// trim spaces and convert to lower case, both keywords and values.
do {
String key = getKeyword();
if (key.length() == 0) {
break;
}
char c = next();
if (c != KEYWORD_ASSIGN) {
// throw new IllegalArgumentException("key '" + key + "' missing a value.");
if (c == DONE) {
break;
} else {
continue;
}
}
String value = getValue();
if (value.length() == 0) {
// throw new IllegalArgumentException("key '" + key + "' missing a value.");
continue;
}
if (m == null) {
m = new TreeMap(getKeyComparator());
} else if (m.containsKey(key)) {
// throw new IllegalArgumentException("key '" + key + "' already has a value.");
continue;
}
m.put(key, value);
} while (next() == ITEM_SEPARATOR);
}
keywords = m != null ? m : Collections.EMPTY_MAP;
}
return keywords;
}
/**
* Parse the keywords and return start of the string in the buffer.
*/
private int parseKeywords() {
int oldBlen = blen;
Map m = getKeywordMap();
if (!m.isEmpty()) {
Iterator iter = m.entrySet().iterator();
boolean first = true;
while (iter.hasNext()) {
append(first ? KEYWORD_SEPARATOR : ITEM_SEPARATOR);
first = false;
Map.Entry e = (Map.Entry)iter.next();
append((String)e.getKey());
append(KEYWORD_ASSIGN);
append((String)e.getValue());
}
if (blen != oldBlen) {
++oldBlen;
}
}
return oldBlen;
}
/**
* Returns an iterator over the keywords, or null if we have an empty map.
*/
public Iterator getKeywords() {
Map m = getKeywordMap();
return m.isEmpty() ? null : m.keySet().iterator();
}
/**
* Returns the value for the named keyword, or null if the keyword is not
* present.
*/
public String getKeywordValue(String keywordName) {
Map m = getKeywordMap();
return m.isEmpty() ? null : (String)m.get(AsciiUtil.toLowerString(keywordName.trim()));
}
/**
* Set the keyword value only if it is not already set to something else.
*/
public void defaultKeywordValue(String keywordName, String value) {
setKeywordValue(keywordName, value, false);
}
/**
* Set the value for the named keyword, or unset it if value is null. If
* keywordName itself is null, unset all keywords. If keywordName is not null,
* value must not be null.
*/
public void setKeywordValue(String keywordName, String value) {
setKeywordValue(keywordName, value, true);
}
/**
* Set the value for the named keyword, or unset it if value is null. If
* keywordName itself is null, unset all keywords. If keywordName is not null,
* value must not be null. If reset is true, ignore any previous value for
* the keyword, otherwise do not change the keyword (including removal of
* one or all keywords).
*/
private void setKeywordValue(String keywordName, String value, boolean reset) {
if (keywordName == null) {
if (reset) {
// force new map, ignore value
keywords = Collections.EMPTY_MAP;
}
} else {
keywordName = AsciiUtil.toLowerString(keywordName.trim());
if (keywordName.length() == 0) {
throw new IllegalArgumentException("keyword must not be empty");
}
if (value != null) {
value = value.trim();
if (value.length() == 0) {
throw new IllegalArgumentException("value must not be empty");
}
}
Map m = getKeywordMap();
if (m.isEmpty()) { // it is EMPTY_MAP
if (value != null) {
// force new map
keywords = new TreeMap(getKeyComparator());
keywords.put(keywordName, value.trim());
}
} else {
if (reset || !m.containsKey(keywordName)) {
if (value != null) {
m.put(keywordName, value);
} else {
m.remove(keywordName);
if (m.isEmpty()) {
// force new map
keywords = Collections.EMPTY_MAP;
}
}
}
}
}
}
}
/**
* linear search of the string array. the arrays are unfortunately ordered by the
* two-letter target code, not the three-letter search code, which seems backwards.
*/
private static int findIndex(String[] array, String target){
for (int i = 0; i < array.length; i++) {
if (target.equals(array[i])) {
return i;
}
}
return -1;
}
/**
* Returns the canonical name for the specified locale ID. This is used to convert POSIX
* and other grandfathered IDs to standard ICU form.
* @param localeID the locale id
* @return the canonicalized id
* @stable ICU 3.0
*/
public static String canonicalize(String localeID){
IDParser parser = new IDParser(localeID, true);
String baseName = parser.getBaseName();
boolean foundVariant = false;
// formerly, we always set to en_US_POSIX if the basename was empty, but
// now we require that the entire id be empty, so that "@foo=bar"
// will pass through unchanged.
// {dlf} I'd rather keep "" unchanged.
if (localeID.equals("")) {
return "";
// return "en_US_POSIX";
}
// we have an ID in the form xx_Yyyy_ZZ_KKKKK
initCANONICALIZE_MAP();
/* convert the variants to appropriate ID */
for (int i = 0; i < variantsToKeywords.length; i++) {
String[] vals = variantsToKeywords[i];
int idx = baseName.lastIndexOf("_" + vals[0]);
if (idx > -1) {
foundVariant = true;
baseName = baseName.substring(0, idx);
if (baseName.endsWith("_")) {
baseName = baseName.substring(0, --idx);
}
parser.setBaseName(baseName);
parser.defaultKeywordValue(vals[1], vals[2]);
break;
}
}
/* See if this is an already known locale */
for (int i = 0; i < CANONICALIZE_MAP.length; i++) {
if (CANONICALIZE_MAP[i][0].equals(baseName)) {
foundVariant = true;
String[] vals = CANONICALIZE_MAP[i];
parser.setBaseName(vals[1]);
if (vals[2] != null) {
parser.defaultKeywordValue(vals[2], vals[3]);
}
break;
}
}
/* total mondo hack for Norwegian, fortunately the main NY case is handled earlier */
if (!foundVariant) {
if (parser.getLanguage().equals("nb") && parser.getVariant().equals("NY")) {
parser.setBaseName(lscvToID("nn", parser.getScript(), parser.getCountry(), null));
}
}
return parser.getName();
}
/**
* Given a keyword and a value, return a new locale with an updated
* keyword and value. If keyword is null, this removes all keywords from the locale id.
* Otherwise, if the value is null, this removes the value for this keyword from the
* locale id. Otherwise, this adds/replaces the value for this keyword in the locale id.
* The keyword and value must not be empty.
* @param keyword the keyword to add/remove, or null to remove all keywords.
* @param value the value to add/set, or null to remove this particular keyword.
* @return the updated locale
* @stable ICU 3.2
*/
public ULocale setKeywordValue(String keyword, String value) {
return new ULocale(setKeywordValue(localeID, keyword, value), (Locale)null);
}
/**
* Given a locale id, a keyword, and a value, return a new locale id with an updated
* keyword and value. If keyword is null, this removes all keywords from the locale id.
* Otherwise, if the value is null, this removes the value for this keyword from the
* locale id. Otherwise, this adds/replaces the value for this keyword in the locale id.
* The keyword and value must not be empty.
* @param localeID the locale id to modify
* @param keyword the keyword to add/remove, or null to remove all keywords.
* @param value the value to add/set, or null to remove this particular keyword.
* @return the updated locale id
* @stable ICU 3.2
*/
public static String setKeywordValue(String localeID, String keyword, String value) {
IDParser parser = new IDParser(localeID);
parser.setKeywordValue(keyword, value);
return parser.getName();
}
/*
* Given a locale id, a keyword, and a value, return a new locale id with an updated
* keyword and value, if the keyword does not already have a value. The keyword and
* value must not be null or empty.
* @param localeID the locale id to modify
* @param keyword the keyword to add, if not already present
* @param value the value to add, if not already present
* @return the updated locale id
* @internal
*/
/* private static String defaultKeywordValue(String localeID, String keyword, String value) {
IDParser parser = new IDParser(localeID);
parser.defaultKeywordValue(keyword, value);
return parser.getName();
}*/
/**
* Returns a three-letter abbreviation for this locale's language. If the locale
* doesn't specify a language, returns the empty string. Otherwise, returns
* a lowercase ISO 639-2/T language code.
* The ISO 639-2 language codes can be found on-line at
* ftp://dkuug.dk/i18n/iso-639-2.txt
* @exception MissingResourceException Throws MissingResourceException if the
* three-letter language abbreviation is not available for this locale.
* @stable ICU 3.0
*/
public String getISO3Language(){
return getISO3Language(localeID);
}
/**
* Returns a three-letter abbreviation for this locale's language. If the locale
* doesn't specify a language, returns the empty string. Otherwise, returns
* a lowercase ISO 639-2/T language code.
* The ISO 639-2 language codes can be found on-line at
* ftp://dkuug.dk/i18n/iso-639-2.txt
* @exception MissingResourceException Throws MissingResourceException if the
* three-letter language abbreviation is not available for this locale.
* @stable ICU 3.0
*/
public static String getISO3Language(String localeID){
initLanguageTables();
String language = getLanguage(localeID);
int offset = findIndex(_languages, language);
if(offset>=0){
return _languages3[offset];
} else {
offset = findIndex(_obsoleteLanguages, language);
if (offset >= 0) {
return _obsoleteLanguages3[offset];
}
}
return EMPTY_STRING;
}
/**
* Returns a three-letter abbreviation for this locale's country/region. If the locale
* doesn't specify a country, returns the empty string. Otherwise, returns
* an uppercase ISO 3166 3-letter country code.
* @exception MissingResourceException Throws MissingResourceException if the
* three-letter country abbreviation is not available for this locale.
* @stable ICU 3.0
*/
public String getISO3Country(){
return getISO3Country(localeID);
}
/**
* Returns a three-letter abbreviation for this locale's country/region. If the locale
* doesn't specify a country, returns the empty string. Otherwise, returns
* an uppercase ISO 3166 3-letter country code.
* @exception MissingResourceException Throws MissingResourceException if the
* three-letter country abbreviation is not available for this locale.
* @stable ICU 3.0
*/
public static String getISO3Country(String localeID){
initCountryTables();
String country = getCountry(localeID);
int offset = findIndex(_countries, country);
if(offset>=0){
return _countries3[offset];
}else{
offset = findIndex(_obsoleteCountries, country);
if(offset>=0){
return _obsoleteCountries3[offset];
}
}
return EMPTY_STRING;
}
// display names
/**
* Utility to fetch locale display data from resource bundle tables.
*/
private static String getTableString(String tableName, String subtableName, String item, String displayLocaleID) {
if (item.length() > 0) {
try {
ICUResourceBundle bundle = (ICUResourceBundle)UResourceBundle.
getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, displayLocaleID);
return getTableString(tableName, subtableName, item, bundle);
} catch (Exception e) {
// System.out.println("gtsu: " + e.getMessage());
}
}
return item;
}
/**
* Utility to fetch locale display data from resource bundle tables.
*/
private static String getTableString(String tableName, String subtableName, String item, ICUResourceBundle bundle) {
// System.out.println("gts table: " + tableName +
// " subtable: " + subtableName +
// " item: " + item +
// " bundle: " + bundle.getULocale());
try {
for (;;) {
// special case currency
if ("currency".equals(subtableName)) {
ICUResourceBundle table = bundle.getWithFallback("Currencies");
table = table.getWithFallback(item);
return table.getString(1);
} else {
ICUResourceBundle table = bundle.getWithFallback(tableName);
try {
if (subtableName != null) {
table = table.getWithFallback(subtableName);
}
return table.getStringWithFallback(item);
}
catch (MissingResourceException e) {
if(subtableName==null){
try{
// may be a deprecated code
String currentName = null;
if(tableName.equals("Countries")){
currentName = getCurrentCountryID(item);
}else if(tableName.equals("Languages")){
currentName = getCurrentLanguageID(item);
}
return table.getStringWithFallback(currentName);
}catch (MissingResourceException ex){/* fall through*/}
}
// still can't figure out ?.. try the fallback mechanism
String fallbackLocale = table.getWithFallback("Fallback").getString();
if (fallbackLocale.length() == 0) {
fallbackLocale = "root";
}
// System.out.println("bundle: " + bundle.getULocale() + " fallback: " + fallbackLocale);
if(fallbackLocale.equals(table.getULocale().localeID)){
return item;
}
bundle = (ICUResourceBundle)UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME,
fallbackLocale);
// System.out.println("fallback from " + table.getULocale() + " to " + fallbackLocale +
// ", got bundle " + bundle.getULocale());
}
}
}
}
catch (Exception e) {
// System.out.println("gtsi: " + e.getMessage());
}
return item;
}
/**
* Returns this locale's language localized for display in the default locale.
* @return the localized language name.
* @stable ICU 3.0
*/
public String getDisplayLanguage() {
return getDisplayLanguageInternal(localeID, getDefault().localeID);
}
/**
* Returns this locale's language localized for display in the provided locale.
* @param displayLocale the locale in which to display the name.
* @return the localized language name.
* @stable ICU 3.0
*/
public String getDisplayLanguage(ULocale displayLocale) {
return getDisplayLanguageInternal(localeID, displayLocale.localeID);
}
/**
* Returns a locale's language localized for display in the provided locale.
* This is a cover for the ICU4C API.
* @param localeID the id of the locale whose language will be displayed
* @param displayLocaleID the id of the locale in which to display the name.
* @return the localized language name.
* @stable ICU 3.0
*/
public static String getDisplayLanguage(String localeID, String displayLocaleID) {
return getDisplayLanguageInternal(localeID, getName(displayLocaleID));
}
/**
* Returns a locale's language localized for display in the provided locale.
* This is a cover for the ICU4C API.
* @param localeID the id of the locale whose language will be displayed.
* @param displayLocale the locale in which to display the name.
* @return the localized language name.
* @stable ICU 3.0
*/
public static String getDisplayLanguage(String localeID, ULocale displayLocale) {
return getDisplayLanguageInternal(localeID, displayLocale.localeID);
}
static String getCurrentCountryID(String oldID){
initCountryTables();
int offset = findIndex(_deprecatedCountries, oldID);
if (offset >= 0) {
return _replacementCountries[offset];
}
return oldID;
}
static String getCurrentLanguageID(String oldID){
initLanguageTables();
int offset = findIndex(_obsoleteLanguages, oldID);
if (offset >= 0) {
return _replacementLanguages[offset];
}
return oldID;
}
// displayLocaleID is canonical, localeID need not be since parsing will fix this.
private static String getDisplayLanguageInternal(String localeID, String displayLocaleID) {
return getTableString("Languages", null, new IDParser(localeID).getLanguage(), displayLocaleID);
}
/**
* Returns this locale's script localized for display in the default locale.
* @return the localized script name.
* @stable ICU 3.0
*/
public String getDisplayScript() {
return getDisplayScriptInternal(localeID, getDefault().localeID);
}
/**
* Returns this locale's script localized for display in the provided locale.
* @param displayLocale the locale in which to display the name.
* @return the localized script name.
* @stable ICU 3.0
*/
public String getDisplayScript(ULocale displayLocale) {
return getDisplayScriptInternal(localeID, displayLocale.localeID);
}
/**
* Returns a locale's script localized for display in the provided locale.
* This is a cover for the ICU4C API.
* @param localeID the id of the locale whose script will be displayed
* @param displayLocaleID the id of the locale in which to display the name.
* @return the localized script name.
* @stable ICU 3.0
*/
public static String getDisplayScript(String localeID, String displayLocaleID) {
return getDisplayScriptInternal(localeID, getName(displayLocaleID));
}
/**
* Returns a locale's script localized for display in the provided locale.
* @param localeID the id of the locale whose script will be displayed.
* @param displayLocale the locale in which to display the name.
* @return the localized script name.
* @stable ICU 3.0
*/
public static String getDisplayScript(String localeID, ULocale displayLocale) {
return getDisplayScriptInternal(localeID, displayLocale.localeID);
}
// displayLocaleID is canonical, localeID need not be since parsing will fix this.
private static String getDisplayScriptInternal(String localeID, String displayLocaleID) {
return getTableString("Scripts", null, new IDParser(localeID).getScript(), displayLocaleID);
}
/**
* Returns this locale's country localized for display in the default locale.
* @return the localized country name.
* @stable ICU 3.0
*/
public String getDisplayCountry() {
return getDisplayCountryInternal(localeID, getDefault().localeID);
}
/**
* Returns this locale's country localized for display in the provided locale.
* @param displayLocale the locale in which to display the name.
* @return the localized country name.
* @stable ICU 3.0
*/
public String getDisplayCountry(ULocale displayLocale){
return getDisplayCountryInternal(localeID, displayLocale.localeID);
}
/**
* Returns a locale's country localized for display in the provided locale.
* This is a cover for the ICU4C API.
* @param localeID the id of the locale whose country will be displayed
* @param displayLocaleID the id of the locale in which to display the name.
* @return the localized country name.
* @stable ICU 3.0
*/
public static String getDisplayCountry(String localeID, String displayLocaleID) {
return getDisplayCountryInternal(localeID, getName(displayLocaleID));
}
/**
* Returns a locale's country localized for display in the provided locale.
* This is a cover for the ICU4C API.
* @param localeID the id of the locale whose country will be displayed.
* @param displayLocale the locale in which to display the name.
* @return the localized country name.
* @stable ICU 3.0
*/
public static String getDisplayCountry(String localeID, ULocale displayLocale) {
return getDisplayCountryInternal(localeID, displayLocale.localeID);
}
// displayLocaleID is canonical, localeID need not be since parsing will fix this.
private static String getDisplayCountryInternal(String localeID, String displayLocaleID) {
return getTableString("Countries", null, new IDParser(localeID).getCountry(), displayLocaleID);
}
/**
* Returns this locale's variant localized for display in the default locale.
* @return the localized variant name.
* @stable ICU 3.0
*/
public String getDisplayVariant() {
return getDisplayVariantInternal(localeID, getDefault().localeID);
}
/**
* Returns this locale's variant localized for display in the provided locale.
* @param displayLocale the locale in which to display the name.
* @return the localized variant name.
* @stable ICU 3.0
*/
public String getDisplayVariant(ULocale displayLocale) {
return getDisplayVariantInternal(localeID, displayLocale.localeID);
}
/**
* Returns a locale's variant localized for display in the provided locale.
* This is a cover for the ICU4C API.
* @param localeID the id of the locale whose variant will be displayed
* @param displayLocaleID the id of the locale in which to display the name.
* @return the localized variant name.
* @stable ICU 3.0
*/
public static String getDisplayVariant(String localeID, String displayLocaleID){
return getDisplayVariantInternal(localeID, getName(displayLocaleID));
}
/**
* Returns a locale's variant localized for display in the provided locale.
* This is a cover for the ICU4C API.
* @param localeID the id of the locale whose variant will be displayed.
* @param displayLocale the locale in which to display the name.
* @return the localized variant name.
* @stable ICU 3.0
*/
public static String getDisplayVariant(String localeID, ULocale displayLocale) {
return getDisplayVariantInternal(localeID, displayLocale.localeID);
}
// displayLocaleID is canonical, localeID need not be since parsing will fix this.
private static String getDisplayVariantInternal(String localeID, String displayLocaleID) {
return getTableString("Variants", null, new IDParser(localeID).getVariant(), displayLocaleID);
}
/**
* Returns a keyword localized for display in the default locale.
* @param keyword the keyword to be displayed.
* @return the localized keyword name.
* @see #getKeywords()
* @stable ICU 3.0
*/
public static String getDisplayKeyword(String keyword) {
return getDisplayKeywordInternal(keyword, getDefault().localeID);
}
/**
* Returns a keyword localized for display in the specified locale.
* @param keyword the keyword to be displayed.
* @param displayLocaleID the id of the locale in which to display the keyword.
* @return the localized keyword name.
* @see #getKeywords(String)
* @stable ICU 3.0
*/
public static String getDisplayKeyword(String keyword, String displayLocaleID) {
return getDisplayKeywordInternal(keyword, getName(displayLocaleID));
}
/**
* Returns a keyword localized for display in the specified locale.
* @param keyword the keyword to be displayed.
* @param displayLocale the locale in which to display the keyword.
* @return the localized keyword name.
* @see #getKeywords(String)
* @stable ICU 3.0
*/
public static String getDisplayKeyword(String keyword, ULocale displayLocale) {
return getDisplayKeywordInternal(keyword, displayLocale.localeID);
}
// displayLocaleID is canonical, localeID need not be since parsing will fix this.
private static String getDisplayKeywordInternal(String keyword, String displayLocaleID) {
return getTableString("Keys", null, AsciiUtil.toLowerString(keyword.trim()), displayLocaleID);
}
/**
* Returns a keyword value localized for display in the default locale.
* @param keyword the keyword whose value is to be displayed.
* @return the localized value name.
* @stable ICU 3.0
*/
public String getDisplayKeywordValue(String keyword) {
return getDisplayKeywordValueInternal(localeID, keyword, getDefault().localeID);
}
/**
* Returns a keyword value localized for display in the specified locale.
* @param keyword the keyword whose value is to be displayed.
* @param displayLocale the locale in which to display the value.
* @return the localized value name.
* @stable ICU 3.0
*/
public String getDisplayKeywordValue(String keyword, ULocale displayLocale) {
return getDisplayKeywordValueInternal(localeID, keyword, displayLocale.localeID);
}
/**
* Returns a keyword value localized for display in the specified locale.
* This is a cover for the ICU4C API.
* @param localeID the id of the locale whose keyword value is to be displayed.
* @param keyword the keyword whose value is to be displayed.
* @param displayLocaleID the id of the locale in which to display the value.
* @return the localized value name.
* @stable ICU 3.0
*/
public static String getDisplayKeywordValue(String localeID, String keyword, String displayLocaleID) {
return getDisplayKeywordValueInternal(localeID, keyword, getName(displayLocaleID));
}
/**
* Returns a keyword value localized for display in the specified locale.
* This is a cover for the ICU4C API.
* @param localeID the id of the locale whose keyword value is to be displayed.
* @param keyword the keyword whose value is to be displayed.
* @param displayLocale the id of the locale in which to display the value.
* @return the localized value name.
* @stable ICU 3.0
*/
public static String getDisplayKeywordValue(String localeID, String keyword, ULocale displayLocale) {
return getDisplayKeywordValueInternal(localeID, keyword, displayLocale.localeID);
}
// displayLocaleID is canonical, localeID need not be since parsing will fix this.
private static String getDisplayKeywordValueInternal(String localeID, String keyword, String displayLocaleID) {
keyword = AsciiUtil.toLowerString(keyword.trim());
String value = new IDParser(localeID).getKeywordValue(keyword);
return getTableString("Types", keyword, value, displayLocaleID);
}
/**
* Returns this locale name localized for display in the default locale.
* @return the localized locale name.
* @stable ICU 3.0
*/
public String getDisplayName() {
return getDisplayNameInternal(localeID, getDefault().localeID);
}
/**
* Returns this locale name localized for display in the provided locale.
* @param displayLocale the locale in which to display the locale name.
* @return the localized locale name.
* @stable ICU 3.0
*/
public String getDisplayName(ULocale displayLocale) {
return getDisplayNameInternal(localeID, displayLocale.localeID);
}
/**
* Returns the locale ID localized for display in the provided locale.
* This is a cover for the ICU4C API.
* @param localeID the locale whose name is to be displayed.
* @param displayLocaleID the id of the locale in which to display the locale name.
* @return the localized locale name.
* @stable ICU 3.0
*/
public static String getDisplayName(String localeID, String displayLocaleID) {
return getDisplayNameInternal(localeID, getName(displayLocaleID));
}
/**
* Returns the locale ID localized for display in the provided locale.
* This is a cover for the ICU4C API.
* @param localeID the locale whose name is to be displayed.
* @param displayLocale the locale in which to display the locale name.
* @return the localized locale name.
* @stable ICU 3.0
*/
public static String getDisplayName(String localeID, ULocale displayLocale) {
return getDisplayNameInternal(localeID, displayLocale.localeID);
}
// displayLocaleID is canonical, localeID need not be since parsing will fix this.
private static String getDisplayNameInternal(String localeID, String displayLocaleID) {
// lang
// lang (script, country, variant, keyword=value, ...)
// script, country, variant, keyword=value, ...
final String[] tableNames = { "Languages", "Scripts", "Countries", "Variants" };
ICUResourceBundle bundle = (ICUResourceBundle)UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, displayLocaleID);
StringBuffer buf = new StringBuffer();
IDParser parser = new IDParser(localeID);
String[] names = parser.getLanguageScriptCountryVariant();
boolean haveLanguage = names[0].length() > 0;
boolean openParen = false;
for (int i = 0; i < names.length; ++i) {
String name = names[i];
if (name.length() > 0) {
name = getTableString(tableNames[i], null, name, bundle);
if (buf.length() > 0) { // need a separator
if (haveLanguage & !openParen) {
buf.append(" (");
openParen = true;
} else {
buf.append(", ");
}
}
buf.append(name);
}
}
Map m = parser.getKeywordMap();
if (!m.isEmpty()) {
Iterator keys = m.entrySet().iterator();
while (keys.hasNext()) {
if (buf.length() > 0) {
if (haveLanguage & !openParen) {
buf.append(" (");
openParen = true;
} else {
buf.append(", ");
}
}
Map.Entry e = (Map.Entry)keys.next();
String key = (String)e.getKey();
String val = (String)e.getValue();
buf.append(getTableString("Keys", null, key, bundle));
buf.append("=");
buf.append(getTableString("Types", key, val, bundle));
}
}
if (openParen) {
buf.append(")");
}
return buf.toString();
}
/**
* Returns this locale's layout orientation for characters. The possible
* values are "left-to-right", "right-to-left", "top-to-bottom" or
* "bottom-to-top".
* @return The locale's layout orientation for characters.
* @stable ICU 4.0
*/
public String getCharacterOrientation() {
return getTableString("layout", null, "characters", getName());
}
/**
* Returns this locale's layout orientation for lines. The possible
* values are "left-to-right", "right-to-left", "top-to-bottom" or
* "bottom-to-top".
* @return The locale's layout orientation for lines.
* @stable ICU 4.0
*/
public String getLineOrientation() {
return getTableString("layout", null, "lines", getName());
}
/**
* Selector for getLocale() indicating the locale of the
* resource containing the data. This is always at or above the
* valid locale. If the valid locale does not contain the
* specific data being requested, then the actual locale will be
* above the valid locale. If the object was not constructed from
* locale data, then the valid locale is null.
*
* @draft ICU 2.8 (retain)
* @provisional This API might change or be removed in a future release.
*/
public static Type ACTUAL_LOCALE = new Type();
/**
* Selector for getLocale() indicating the most specific
* locale for which any data exists. This is always at or above
* the requested locale, and at or below the actual locale. If
* the requested locale does not correspond to any resource data,
* then the valid locale will be above the requested locale. If
* the object was not constructed from locale data, then the
* actual locale is null.
*
* [0-9A-Za-z].
*
Note:Extension key 'x' and 'X' is reserved for BCP47
* private use. To get the private use value, use PRIVATE_USE_KEY.
* clear() resets all fields
* to their default values.
* @see Builder#create
* @see Builder#clear
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public static final class Builder {
private InternalLocaleBuilder _locbld = new InternalLocaleBuilder();
/**
* Constructs an empty Builder.
* The default values of all fields, extensions, and private
* use information are empty, the language is undefined.
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder() {
}
/**
* Resets the builder to match the provided locale. The previous state
* of the builder is discarded. Fields that do not
* conform to BCP47 syntax are ill-formed.
* @param loc the locale
* @return this builder
* @throws IllformedLocaleException if loc has any ill-formed
* fields.
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder setLocale(ULocale loc) {
clear();
setLanguage(loc.getLanguage())
.setScript(loc.getScript())
.setRegion(loc.getCountry())
.setVariant(loc.getVariant());
Set extKeys = loc.getExtensionKeys();
if (extKeys != null) {
Iterator itr = extKeys.iterator();
while (itr.hasNext()) {
char key = ((Character)itr.next()).charValue();
String value = loc.getExtension(key);
if (value != null && value.length() > 0) {
setExtension(key, value);
}
}
}
return this;
}
/**
* Resets the builder to match the provided language tag. The previous state
* of the builder is discarded.
* @param langtag the language tag
* @return this builder
* @throws IllformedLocaleException if langtag is ill-formed.
* @see #forLanguageTag(String)
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder setLanguageTag(String langtag) {
clear();
LanguageTag tag = null;
try {
tag = LanguageTag.parse(langtag);
} catch (LocaleSyntaxException e) {
throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
}
// base locale fields
String extlang = tag.getExtlang(0);
String language = extlang == null ? tag.getLanguage() : extlang;
setLanguage(language.equals("und") ? "": language).setScript(tag.getScript())
.setRegion(tag.getRegion()).setVariant(tag.getVariant());
// extensions
Set exts = tag.getExtensions();
if (exts != null) {
Iterator itr = exts.iterator();
while (itr.hasNext()) {
Extension e = (Extension)itr.next();
setExtension(e.getSingleton(), e.getValue());
//TODO: setExtension may throw an IllformedLocaleException.
// In this csae, error index must be recalculated.
}
}
// private use
setExtension(PRIVATE_USE_EXTENSION, tag.getPrivateUse());
return this;
}
/**
* Sets the language. If language is the empty string,
* the language is defaulted. Language should be a two or
* three-letter language code as defined in ISO639.
* Well-formed values are any string of two to eight ASCII letters.
* @param language the language
* @return this builder
* @throws IllformedLocaleException if language is ill-formed
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder setLanguage(String language) {
try {
_locbld.setLanguage(language);
} catch (LocaleSyntaxException e) {
throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
}
return this;
}
/**
* Sets the script. If script is
* the empty string, the script is defaulted. Scripts should
* be a four-letter script code as defined in ISO 15924.
* Well-formed values are any string of four ASCII letters.
* @param script the script
* @return this builder
* @throws IllformedLocaleException if script is ill-formed
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder setScript(String script) {
try {
_locbld.setScript(script);
} catch (LocaleSyntaxException e) {
throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
}
return this;
}
/**
* Sets the region. If region is
* the empty string, the region is defaulted. Regions should
* be a two-letter ISO 3166 code or a three-digit M. 49 code.
* Well-formed values are any two-letter or three-digit
* string.
* @param region the region
* @return this builder
* @throws IllformedLocaleException if region is ill-formed
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder setRegion(String region) {
try {
_locbld.setRegion(region);
} catch (LocaleSyntaxException e) {
throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
}
return this;
}
/**
* Sets the variant. If variant is
* or the empty string, the variant is defaulted. Variants
* should be registered variants (see
*
* IANA Language Subtag Registry) for the prefix. Well-formed
* variants are any series of fields of either four characters
* starting with a digit, or five to eight alphanumeric
* characters, separated by hyphen or underscore.
* @param variant the variant
* @return this builder
* @throws IllformedLocaleException if variant is ill-formed
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder setVariant(String variant) {
try {
_locbld.setVariant(variant);
} catch (LocaleSyntaxException e) {
throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
}
return this;
}
/**
* Sets the extension for the given key. If the value is
* the empty string, the extension is removed. Legal
* keys are the [0-9A-WY-Za-wy-z]. Well-formed
* values are any series of fields of two to eight
* alphanumeric characters, separated by hyphen or underscore.
* key is illegal
* or value is ill-formed
* @see #setLDMLExtensionValue
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder setExtension(char key, String value) {
try {
_locbld.setExtension(key, value);
} catch (LocaleSyntaxException e) {
throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
}
return this;
}
/**
* Sets the LDML keyword value ('type') for the given key. If the
* value is the empty string, the LDML keyword is removed.
* Well-formed keys are strings of two alphanumeric characters. Well-formed
* values are strings of three to eight alphanumeric characters.
* key or value
* is ill-formed
* @see #setExtension(char, String)
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder setLDMLExtensionValue(String key, String value) {
try {
_locbld.setLDMLExtensionValue(key, value);
} catch (LocaleSyntaxException e) {
throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
}
return this;
}
/**
* Resets the builder to its initial, default state.
* @return this builder
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder clear() {
_locbld.clear();
return this;
}
/**
* Resets the extensions to their initial, default state.
* Language, script, region and variant are unchanged.
* @return this builder
* @see #setExtension(char, String)
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public Builder clearExtensions() {
_locbld.removeLocaleExtensions();
return this;
}
/**
* Returns an instance of locale created from the fields set
* on this builder.
* @return a new locale
*
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public ULocale create() {
return getInstance(_locbld.getBaseLocale(), _locbld.getLocaleExtensions());
}
}
private static ULocale getInstance(BaseLocale base, LocaleExtensions ext) {
StringBuffer id = new StringBuffer(base.getID());
TreeMap kwds = null;
Set extKeys = ext.getExtensionKeys();
if (extKeys != null) {
// legacy locale ID assume LDML keywords and
// other extensions are at the same level.
// e.g. @a=ext-for-aa;calendar=japanese;m=ext-for-mm;x=priv-use
kwds = new TreeMap();
Iterator itr = extKeys.iterator();
boolean hasLDMLKeywords = false;
while (itr.hasNext()) {
Character key = (Character)itr.next();
if (key.charValue() == 'u') {
// LDML keywords
hasLDMLKeywords = true;
continue;
}
String value = ext.getExtensionValue(key.charValue());
kwds.put(String.valueOf(key), value);
}
if (hasLDMLKeywords) {
Set ldmlKeys = ext.getLDMLKeywordKeys();
if (ldmlKeys != null) {
Iterator litr = ldmlKeys.iterator();
while (litr.hasNext()) {
String bcpKey = (String)litr.next();
String bcpValue = ext.getLDMLKeywordType(bcpKey);
// transform to legacy key/type
String lkey = bcp47ToLDMLKey(bcpKey);
String ltype = bcp47ToLDMLType(lkey, bcpValue);
kwds.put(lkey, ltype);
}
}
}
if (kwds.size() > 0) {
id.append("@");
Set kset = kwds.entrySet();
Iterator kitr = kset.iterator();
boolean insertSep = false;
while (kitr.hasNext()) {
if (insertSep) {
id.append(";");
} else {
insertSep = true;
}
Map.Entry kwd = (Map.Entry)kitr.next();
id.append(kwd.getKey());
id.append("=");
id.append(kwd.getValue());
}
}
}
return new ULocale(id.toString());
}
private BaseLocale base() {
String language = getLanguage();
if (equals(ULocale.ROOT)) {
language = "";
}
return BaseLocale.getInstance(language, getScript(), getCountry(), getVariant());
}
private LocaleExtensions extensions() {
Iterator kwitr = getKeywords();
if (kwitr == null) {
return LocaleExtensions.EMPTY_EXTENSIONS;
}
TreeMap extMap = null;
TreeMap ldmlKwMap = null;
while (kwitr.hasNext()) {
String key = (String)kwitr.next();
String value = getKeywordValue(key);
if (key.length() == 1) {
// non LDML extension or private use
// We want to keep only valid subtags
boolean isPrivUse = (key.charAt(0) == PRIVATE_USE_EXTENSION);
if (isPrivUse || LanguageTag.isExtensionSingleton(key)) {
boolean isValid = true;
String[] subtags = Utility.split(value, '-');
for (int i = 0; i < subtags.length; i++) {
if (isPrivUse) {
if (!LanguageTag.isPrivateuseValueSubtag(subtags[i])) {
isValid = false;
break;
}
} else {
if (!LanguageTag.isExtensionSubtag(subtags[i])) {
isValid = false;
break;
}
}
}
if (isValid) {
if (extMap == null) {
extMap = new TreeMap();
}
extMap.put(new Character(key.charAt(0)), value.intern());
}
}
} else {
// LDML keyword
String bcpKey = ldmlKeyToBCP47(key);
String bcpVal = ldmlTypeToBCP47(key, value);
if (bcpKey != null && bcpVal != null) {
if (ldmlKwMap == null) {
ldmlKwMap = new TreeMap();
}
ldmlKwMap.put(bcpKey.intern(), bcpVal.intern());
}
}
}
if (ldmlKwMap != null) {
// create LDML extension string
StringBuffer buf = new StringBuffer();
LocaleExtensions.keywordsToString(ldmlKwMap, buf);
if (extMap == null) {
extMap = new TreeMap();
}
extMap.put(new Character('u'), buf.toString().intern());
}
return LocaleExtensions.getInstance(extMap, ldmlKwMap);
}
//
// LDML legacy/BCP47 key and type mapping functions
//
private static String ldmlKeyToBCP47(String key) {
UResourceBundle supplemental = UResourceBundle.getBundleInstance(
ICUResourceBundle.ICU_BASE_NAME,
"supplementalData",
ICUResourceBundle.ICU_DATA_CLASS_LOADER);
UResourceBundle bcp47Mappings = supplemental.get("bcp47KeywordMappings");
UResourceBundle keyMaps = bcp47Mappings.get("key");
// normalize key to lowercase
key = AsciiUtil.toLowerString(key);
String bcpKey = null;
try {
bcpKey = keyMaps.getString(key);
} catch (MissingResourceException mre) {
// fall through
}
if (bcpKey == null) {
if (key.length() == 2 && LanguageTag.isExtensionSubtag(key)) {
return key;
}
return null;
}
return bcpKey;
}
private static String bcp47ToLDMLKey(String bcpKey) {
UResourceBundle supplemental = UResourceBundle.getBundleInstance(
ICUResourceBundle.ICU_BASE_NAME,
"supplementalData",
ICUResourceBundle.ICU_DATA_CLASS_LOADER);
UResourceBundle bcp47Mappings = supplemental.get("bcp47KeywordMappings");
UResourceBundle keyMaps = bcp47Mappings.get("key");
// normalize bcp key to lowercase
bcpKey = AsciiUtil.toLowerString(bcpKey);
String key = null;
for (int i = 0; i < keyMaps.getSize(); i++) {
UResourceBundle keyMap = keyMaps.get(i);
if (bcpKey.equals(keyMap.getString())) {
key = keyMap.getKey();
break;
}
}
if (key == null) {
return bcpKey;
}
return key;
}
private static String ldmlTypeToBCP47(String key, String type) {
UResourceBundle supplemental = UResourceBundle.getBundleInstance(
ICUResourceBundle.ICU_BASE_NAME,
"supplementalData",
ICUResourceBundle.ICU_DATA_CLASS_LOADER);
UResourceBundle bcp47Mappings = supplemental.get("bcp47KeywordMappings");
// normalize key/type to lowercase
key = AsciiUtil.toLowerString(key);
type = AsciiUtil.toLowerString(type);
String bcpType = null;
try {
UResourceBundle typeMaps = bcp47Mappings.get(key);
String tmp = key.equals("timezone") ? Utility.replaceAll(type, "/", ":") : type;
bcpType = typeMaps.getString(tmp);
} catch (MissingResourceException mre) {
// fall through
}
if (bcpType == null) {
int typeLen = type.length();
if (typeLen >= 3 && typeLen <= 8 && LanguageTag.isExtensionSubtag(type)) {
return type;
}
return null;
}
return bcpType;
}
private static String bcp47ToLDMLType(String key, String bcpType) {
UResourceBundle supplemental = UResourceBundle.getBundleInstance(
ICUResourceBundle.ICU_BASE_NAME,
"supplementalData",
ICUResourceBundle.ICU_DATA_CLASS_LOADER);
UResourceBundle bcp47Mappings = supplemental.get("bcp47KeywordMappings");
// normalize key/bcpType to lowercase
key = AsciiUtil.toLowerString(key);
bcpType = AsciiUtil.toLowerString(bcpType);
String type = null;
try {
UResourceBundle typeMaps = bcp47Mappings.get(key);
// Note: Linear search for time zone ID might be too slow.
// ICU services do not use timezone keywords for now.
// In future, we may need to build the optimized inverse
// lookup table.
for (int i = 0; i < typeMaps.getSize(); i++) {
UResourceBundle typeMap = typeMaps.get(i);
if (bcpType.equals(typeMap.getString())) {
type = typeMap.getKey();
if (key.equals("timezone")) {
type = Utility.replaceAll(type, ":", "/");
}
break;
}
}
} catch (MissingResourceException mre) {
// fall through
}
if (type == null) {
return bcpType;
}
return type;
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/CECalendar.java 0000644 0001750 0001750 00000022355 11174243256 021302 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2005-2009, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.Date;
import java.util.Locale;
/**
* Base class for EthiopicCalendar and CopticCalendar.
* @internal
* @deprecated This API is ICU internal only.
*/
abstract class CECalendar extends Calendar {
// jdk1.4.2 serialver
private static final long serialVersionUID = -999547623066414271L;
private static final int LIMITS[][] = {
// Minimum Greatest Least Maximum
// Minimum Maximum
{ 0, 0, 1, 1 }, // ERA
{ 1, 1, 5000000, 5000000 }, // YEAR
{ 0, 0, 12, 12 }, // MONTH
{ 1, 1, 52, 53 }, // WEEK_OF_YEAR
{/* */}, // WEEK_OF_MONTH
{ 1, 1, 5, 30 }, // DAY_OF_MONTH
{ 1, 1, 365, 366 }, // DAY_OF_YEAR
{/* */}, // DAY_OF_WEEK
{ -1, -1, 1, 5 }, // DAY_OF_WEEK_IN_MONTH
{/* */}, // AM_PM
{/* */}, // HOUR
{/* */}, // HOUR_OF_DAY
{/* */}, // MINUTE
{/* */}, // SECOND
{/* */}, // MILLISECOND
{/* */}, // ZONE_OFFSET
{/* */}, // DST_OFFSET
{ -5000000, -5000000, 5000000, 5000000 }, // YEAR_WOY
{/* */}, // DOW_LOCAL
{ -5000000, -5000000, 5000000, 5000000 }, // EXTENDED_YEAR
{/* */}, // JULIAN_DAY
{/* */}, // MILLISECONDS_IN_DAY
};
//-------------------------------------------------------------------------
// Constructors...
//-------------------------------------------------------------------------
/**
* Constructs a default CECalendar using the current time
* in the default time zone with the default locale.
*/
protected CECalendar() {
this(TimeZone.getDefault(), ULocale.getDefault());
}
/**
* Constructs a CECalendar based on the current time
* in the given time zone with the default locale.
*
* @param zone The time zone for the new calendar.
*/
protected CECalendar(TimeZone zone) {
this(zone, ULocale.getDefault());
}
/**
* Constructs a CECalendar based on the current time
* in the default time zone with the given locale.
*
* @param aLocale The locale for the new calendar.
*/
protected CECalendar(Locale aLocale) {
this(TimeZone.getDefault(), aLocale);
}
/**
* Constructs a CECalendar based on the current time
* in the default time zone with the given locale.
*
* @param locale The locale for the new calendar.
*/
protected CECalendar(ULocale locale) {
this(TimeZone.getDefault(), locale);
}
/**
* Constructs a CECalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone The time zone for the new calendar.
*
* @param aLocale The locale for the new calendar.
*/
protected CECalendar(TimeZone zone, Locale aLocale) {
super(zone, aLocale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs a CECalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone The time zone for the new calendar.
*
* @param locale The locale for the new calendar.
*/
protected CECalendar(TimeZone zone, ULocale locale) {
super(zone, locale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs a CECalendar with the given date set
* in the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for Tishri.
*
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
*/
protected CECalendar(int year, int month, int date) {
super(TimeZone.getDefault(), ULocale.getDefault());
this.set(year, month, date);
}
/**
* Constructs a CECalendar with the given date set
* in the default time zone with the default locale.
*
* @param date The date to which the new calendar is set.
*/
protected CECalendar(Date date) {
super(TimeZone.getDefault(), ULocale.getDefault());
this.setTime(date);
}
/**
* Constructs a CECalendar with the given date
* and time set for the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for Tishri.
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @param hour The value used to set the calendar's {@link #HOUR_OF_DAY HOUR_OF_DAY} time field.
* @param minute The value used to set the calendar's {@link #MINUTE MINUTE} time field.
* @param second The value used to set the calendar's {@link #SECOND SECOND} time field.
*/
protected CECalendar(int year, int month, int date, int hour,
int minute, int second)
{
super(TimeZone.getDefault(), ULocale.getDefault());
this.set(year, month, date, hour, minute, second);
}
//-------------------------------------------------------------------------
// Calendar framework
//-------------------------------------------------------------------------
/**
* The Coptic and Ethiopic calendars differ only in their epochs.
* This method must be implemented by CECalendar subclasses to
* return the date offset from Julian.
*/
abstract protected int getJDEpochOffset();
/**
* Return JD of start of given month/extended year
*/
protected int handleComputeMonthStart(int eyear,
int emonth,
boolean useMonth) {
return ceToJD(eyear, emonth, 0, getJDEpochOffset());
}
/**
* Calculate the limit for a specified type of limit and field
*/
protected int handleGetLimit(int field, int limitType) {
return LIMITS[field][limitType];
}
//-------------------------------------------------------------------------
// Calendar framework
//-------------------------------------------------------------------------
/**
* Convert an Coptic/Ethiopic year, month and day to a Julian day
* @param year the extended year
* @param month the month
* @param day the day
* @return Julian day
*/
public static int ceToJD(long year, int month, int day, int jdEpochOffset) {
// Julian<->Ethiopic algorithms from:
// "Calendars in Ethiopia", Berhanu Beyene, Manfred Kudlek, International Conference
// of Ethiopian Studies XV, Hamburg, 2003
// handle month > 12, < 0 (e.g. from add/set)
if ( month >= 0 ) {
year += month/13;
month %= 13;
} else {
++month;
year += month/13 - 1;
month = month%13 + 12;
}
return (int) (
jdEpochOffset // difference from Julian epoch to 1,1,1
+ 365 * year // number of days from years
+ floorDivide(year, 4) // extra day of leap year
+ 30 * month // number of days from months (months are 0-based)
+ day - 1 // number of days for present month (1 based)
);
}
/**
* Convert a Julian day to an Coptic/Ethiopic year, month and day
*/
public static void jdToCE(int julianDay, int jdEpochOffset, int[] fields) {
int c4; // number of 4 year cycle (1461 days)
int[] r4 = new int[1]; // remainder of 4 year cycle, always positive
c4 = floorDivide(julianDay - jdEpochOffset, 1461, r4);
// exteded year
fields[0] = 4 * c4 + (r4[0]/365 - r4[0]/1460); // 4 * BuddhistCalendar is a subclass of GregorianCalendar
* that numbers years since the birth of the Buddha. This is the civil calendar
* in some predominantly Buddhist countries such as Thailand, and it is used for
* religious purposes elsewhere.
* BE. If the
* calendar is not in lenient mode (see setLenient), dates before
* 1/1/1 BE are rejected with an IllegalArgumentException.
* ULocale
* with the tag "@calendar=buddhist".ERA
* value for the Buddhist calendar.
*
* @see com.ibm.icu.util.Calendar#ERA
* @stable ICU 2.8
*/
public static final int BE = 0;
/**
* Constructs a BuddhistCalendar using the current time
* in the default time zone with the default locale.
* @stable ICU 2.8
*/
public BuddhistCalendar() {
super();
}
/**
* Constructs a BuddhistCalendar based on the current time
* in the given time zone with the default locale.
*
* @param zone the given time zone.
* @stable ICU 2.8
*/
public BuddhistCalendar(TimeZone zone) {
super(zone);
}
/**
* Constructs a BuddhistCalendar based on the current time
* in the default time zone with the given locale.
*
* @param aLocale the given locale.
* @stable ICU 2.8
*/
public BuddhistCalendar(Locale aLocale) {
super(aLocale);
}
/**
* Constructs a BuddhistCalendar based on the current time
* in the default time zone with the given locale.
*
* @param locale the given ulocale.
* @stable ICU 3.2
*/
public BuddhistCalendar(ULocale locale) {
super(locale);
}
/**
* Constructs a BuddhistCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone the given time zone.
*
* @param aLocale the given locale.
* @stable ICU 2.8
*/
public BuddhistCalendar(TimeZone zone, Locale aLocale) {
super(zone, aLocale);
}
/**
* Constructs a BuddhistCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone the given time zone.
*
* @param locale the given ulocale.
* @stable ICU 3.2
*/
public BuddhistCalendar(TimeZone zone, ULocale locale) {
super(zone, locale);
}
/**
* Constructs a BuddhistCalendar with the given date set
* in the default time zone with the default locale.
*
* @param date The date to which the new calendar is set.
* @stable ICU 2.8
*/
public BuddhistCalendar(Date date) {
this();
setTime(date);
}
/**
* Constructs a BuddhistCalendar with the given date set
* in the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for January.
*
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @stable ICU 2.8
*/
public BuddhistCalendar(int year, int month, int date) {
super(year, month, date);
}
/**
* Constructs a BuddhistCalendar with the given date
* and time set for the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for January.
*
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
*
* @param hour The value used to set the calendar's {@link #HOUR_OF_DAY HOUR_OF_DAY} time field.
*
* @param minute The value used to set the calendar's {@link #MINUTE MINUTE} time field.
*
* @param second The value used to set the calendar's {@link #SECOND SECOND} time field.
* @stable ICU 2.8
*/
public BuddhistCalendar(int year, int month, int date, int hour,
int minute, int second)
{
super(year, month, date, hour, minute, second);
}
//-------------------------------------------------------------------------
// The only practical difference from a Gregorian calendar is that years
// are numbered since the birth of the Buddha. A couple of overrides will
// take care of that....
//-------------------------------------------------------------------------
// Starts in -543 AD, ie 544 BC
private static final int BUDDHIST_ERA_START = -543;
// Use 1970 as the default value of EXTENDED_YEAR
private static final int GREGORIAN_EPOCH = 1970;
/**
* @stable ICU 2.8
*/
protected int handleGetExtendedYear() {
// EXTENDED_YEAR in BuddhistCalendar is a Gregorian year
// The default value of EXTENDED_YEAR is 1970 (Buddhist 2513)
int year;
if (newerField(EXTENDED_YEAR, YEAR) == EXTENDED_YEAR) {
year = internalGet(EXTENDED_YEAR, GREGORIAN_EPOCH);
} else {
year = internalGet(YEAR, GREGORIAN_EPOCH - BUDDHIST_ERA_START)
+ BUDDHIST_ERA_START;
}
return year;
}
// Return JD of start of given month/year
/**
* @stable ICU 2.8
*/
protected int handleComputeMonthStart(int eyear, int month, boolean useMonth) {
return super.handleComputeMonthStart(eyear, month, useMonth);
}
/**
* @stable ICU 2.8
*/
protected void handleComputeFields(int julianDay) {
super.handleComputeFields(julianDay);
int y = internalGet(EXTENDED_YEAR) - BUDDHIST_ERA_START;
internalSet(ERA, 0);
internalSet(YEAR, y);
}
/**
* Override GregorianCalendar. There is only one Buddhist ERA. We
* should really handle YEAR, YEAR_WOY, and EXTENDED_YEAR here too to
* implement the 1..5000000 range, but it's not critical.
* @stable ICU 2.8
*/
protected int handleGetLimit(int field, int limitType) {
if (field == ERA) {
return BE;
}
return super.handleGetLimit(field, limitType);
}
/**
* Return the current Calendar type.
* @return type of calendar
* @stable ICU 3.8
*/
public String getType() {
return "buddhist";
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/DateInterval.java 0000644 0001750 0001750 00000003622 11157074147 021741 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2008-2009, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
*/
package com.ibm.icu.util;
import java.io.Serializable;
/**
* This class represents date interval.
* It is a pair of long representing from date 1 to date 2.
* @stable ICU 4.0
*/
public final class DateInterval implements Serializable {
private static final long serialVersionUID = 1;
private final long fromDate;
private final long toDate;
/**
* Constructor given from date and to date.
* @param from The from date in date interval.
* @param to The to date in date interval.
* @stable ICU 4.0
*/
public DateInterval(long from, long to)
{
fromDate = from;
toDate = to;
}
/**
* Get the from date.
* @return the from date in dateInterval.
* @stable ICU 4.0
*/
public long getFromDate()
{
return fromDate;
}
/**
* Get the to date.
* @return the to date in dateInterval.
* @stable ICU 4.0
*/
public long getToDate()
{
return toDate;
}
/**
* Override equals
* @stable ICU 4.0
*/
public boolean equals(Object a) {
if ( a instanceof DateInterval ) {
DateInterval di = (DateInterval)a;
return fromDate == di.fromDate && toDate == di.toDate;
}
return false;
}
/**
* Override hashcode
* @stable ICU 4.0
*/
public int hashCode() {
return (int)(fromDate + toDate);
}
/**
* Override toString
* @stable ICU 4.0
*/
public String toString() {
return String.valueOf(fromDate) + " " + String.valueOf(toDate);
}
} // end class DateInterval
icu4j-4.2.1.1/src/com/ibm/icu/util/IndianCalendar.java 0000644 0001750 0001750 00000045567 11015072544 022221 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import com.ibm.icu.util.TimeZone;
import java.util.Date;
import java.util.Locale;
/**
* IndianCalendar is a subclass of GregorianCalendar
* that numbers years since the birth of the Buddha. This is the civil calendar
* which is accepted by government of India as Indian National Calendar.
* The two calendars most widely used in India today are the Vikrama calendar
* followed in North India and the Shalivahana or Saka calendar which is followed
* in South India and Maharashtra.
* A variant of the Shalivahana Calendar was reformed and standardized as the
* Indian National calendar in 1957.
* Saka Era. If the
* calendar is not in lenient mode (see setLenient), dates before
* 1/1/1 Saka Era are rejected with an IllegalArgumentException.
* ULocale
* with the tag "@calendar=Indian".ERA
* value for the Indian calendar.
*
* @see com.ibm.icu.util.Calendar#ERA
* @stable ICU 3.8
*/
public static final int IE = 0;
/**
* Constructs a IndianCalendar using the current time
* in the default time zone with the default locale.
* @stable ICU 3.8
*/
public IndianCalendar() {
this(TimeZone.getDefault(), ULocale.getDefault());
}
/**
* Constructs a IndianCalendar based on the current time
* in the given time zone with the default locale.
*
* @param zone the given time zone.
* @stable ICU 3.8
*/
public IndianCalendar(TimeZone zone) {
this(zone, ULocale.getDefault());
}
/**
* Constructs a IndianCalendar based on the current time
* in the default time zone with the given locale.
*
* @param aLocale the given locale.
* @stable ICU 3.8
*/
public IndianCalendar(Locale aLocale) {
this(TimeZone.getDefault(), aLocale);
}
/**
* Constructs a IndianCalendar based on the current time
* in the default time zone with the given locale.
*
* @param locale the given ulocale.
* @stable ICU 3.8
*/
public IndianCalendar(ULocale locale) {
this(TimeZone.getDefault(), locale);
}
/**
* Constructs a IndianCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone the given time zone.
*
* @param aLocale the given locale.
* @stable ICU 3.8
*/
public IndianCalendar(TimeZone zone, Locale aLocale) {
super(zone, aLocale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs a IndianCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone the given time zone.
*
* @param locale the given ulocale.
* @stable ICU 3.8
*/
public IndianCalendar(TimeZone zone, ULocale locale) {
super(zone, locale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs a IndianCalendar with the given date set
* in the default time zone with the default locale.
*
* @param date The date to which the new calendar is set.
* @stable ICU 3.8
*/
public IndianCalendar(Date date) {
super(TimeZone.getDefault(), ULocale.getDefault());
this.setTime(date);
}
/**
* Constructs a IndianCalendar with the given date set
* in the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for January.
*
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @stable ICU 3.8
*/
public IndianCalendar(int year, int month, int date) {
super(TimeZone.getDefault(), ULocale.getDefault());
this.set(Calendar.YEAR, year);
this.set(Calendar.MONTH, month);
this.set(Calendar.DATE, date);
}
/**
* Constructs a IndianCalendar with the given date
* and time set for the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for January.
*
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
*
* @param hour The value used to set the calendar's {@link #HOUR_OF_DAY HOUR_OF_DAY} time field.
*
* @param minute The value used to set the calendar's {@link #MINUTE MINUTE} time field.
*
* @param second The value used to set the calendar's {@link #SECOND SECOND} time field.
* @stable ICU 3.8
*/
public IndianCalendar(int year, int month, int date, int hour,
int minute, int second)
{
super(TimeZone.getDefault(), ULocale.getDefault());
this.set(Calendar.YEAR, year);
this.set(Calendar.MONTH, month);
this.set(Calendar.DATE, date);
this.set(Calendar.HOUR_OF_DAY, hour);
this.set(Calendar.MINUTE, minute);
this.set(Calendar.SECOND, second);
}
//-------------------------------------------------------------------------
// The only practical difference from a Gregorian calendar is that years
// are numbered since the Saka Era. A couple of overrides will
// take care of that....
//-------------------------------------------------------------------------
// Starts in 78 AD,
private static final int INDIAN_ERA_START = 78;
// The Indian year starts 80 days later than the Gregorian year.
private static final int INDIAN_YEAR_START = 80;
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
protected int handleGetExtendedYear() {
int year;
if (newerField(EXTENDED_YEAR, YEAR) == EXTENDED_YEAR) {
year = internalGet(EXTENDED_YEAR, 1);
} else {
// Ignore the era, as there is only one
year = internalGet(YEAR, 1);
}
return year;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
protected int handleGetYearLength(int extendedYear) {
return super.handleGetYearLength(extendedYear);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
protected int handleGetMonthLength(int extendedYear, int month) {
if (month < 0 || month > 11) {
int[] remainder = new int[1];
extendedYear += floorDivide(month, 12, remainder);
month = remainder[0];
}
if(isGregorianLeap(extendedYear + INDIAN_ERA_START) && month == 0) {
return 31;
}
if(month >= 1 && month <=5) {
return 31;
}
return 30;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
protected void handleComputeFields(int julianDay){
double jdAtStartOfGregYear;
int leapMonth, IndianYear, yday, IndianMonth, IndianDayOfMonth, mday;
int[] gregorianDay; // Stores gregorian date corresponding to Julian day;
gregorianDay = jdToGregorian(julianDay); // Gregorian date for Julian day
IndianYear = gregorianDay[0] - INDIAN_ERA_START; // Year in Saka era
jdAtStartOfGregYear = gregorianToJD(gregorianDay[0], 1, 1); // JD at start of Gregorian year
yday = (int)(julianDay - jdAtStartOfGregYear); // Day number in Gregorian year (starting from 0)
if (yday < INDIAN_YEAR_START) {
// Day is at the end of the preceding Saka year
IndianYear -= 1;
leapMonth = isGregorianLeap(gregorianDay[0] - 1) ? 31 : 30; // Days in leapMonth this year, previous Gregorian year
yday += leapMonth + (31 * 5) + (30 * 3) + 10;
} else {
leapMonth = isGregorianLeap(gregorianDay[0]) ? 31 : 30; // Days in leapMonth this year
yday -= INDIAN_YEAR_START;
}
if (yday < leapMonth) {
IndianMonth = 0;
IndianDayOfMonth = yday + 1;
} else {
mday = yday - leapMonth;
if (mday < (31 * 5)) {
IndianMonth = (int)Math.floor(mday / 31) + 1;
IndianDayOfMonth = (mday % 31) + 1;
} else {
mday -= 31 * 5;
IndianMonth = (int)Math.floor(mday / 30) + 6;
IndianDayOfMonth = (mday % 30) + 1;
}
}
internalSet(ERA, 0);
internalSet(EXTENDED_YEAR, IndianYear);
internalSet(YEAR, IndianYear);
internalSet(MONTH, IndianMonth);
internalSet(DAY_OF_MONTH, IndianDayOfMonth );
internalSet(DAY_OF_YEAR, yday + 1); // yday is 0-based
}
private static final int LIMITS[][] = {
// Minimum Greatest Least Maximum
// Minimum Maximum
{ 0, 0, 0, 0}, // ERA
{ -5000000, -5000000, 5000000, 5000000}, // YEAR
{ 0, 0, 11, 11}, // MONTH
{ 1, 1, 52, 53}, // WEEK_OF_YEAR
{/* */}, // WEEK_OF_MONTH
{ 1, 1, 30, 31}, // DAY_OF_MONTH
{ 1, 1, 365, 366}, // DAY_OF_YEAR
{/* */}, // DAY_OF_WEEK
{ -1, -1, 5, 5}, // DAY_OF_WEEK_IN_MONTH
{/* */}, // AM_PM
{/* */}, // HOUR
{/* */}, // HOUR_OF_DAY
{/* */}, // MINUTE
{/* */}, // SECOND
{/* */}, // MILLISECOND
{/* */}, // ZONE_OFFSET
{/* */}, // DST_OFFSET
{ -5000000, -5000000, 5000000, 5000000}, // YEAR_WOY
{/* */}, // DOW_LOCAL
{ -5000000, -5000000, 5000000, 5000000}, // EXTENDED_YEAR
{/* */}, // JULIAN_DAY
{/* */}, // MILLISECONDS_IN_DAY
};
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
protected int handleGetLimit(int field, int limitType) {
return LIMITS[field][limitType];
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
protected int handleComputeMonthStart(int year, int month, boolean useMonth) {
//month is 0 based; converting it to 1-based
int imonth;
if(month == 12) {
imonth = 1;
} else {
imonth = month +1;
}
double jd = IndianToJD(year ,imonth, 1);
return (int)jd;
}
/*
* This routine converts an Indian date to the corresponding Julian date"
* @param year The year in Saka Era according to Indian calendar.
* @param month The month according to Indian calendar (between 1 to 12)
* @param date The date in month
*/
private static double IndianToJD(int year, int month, int date) {
int leapMonth, gyear, m;
double start, jd;
gyear = year + INDIAN_ERA_START;
if(isGregorianLeap(gyear)) {
leapMonth = 31;
start = gregorianToJD(gyear, 3, 21);
} else {
leapMonth = 30;
start = gregorianToJD(gyear, 3, 22);
}
if (month == 1) {
jd = start + (date - 1);
} else {
jd = start + leapMonth;
m = month - 2;
m = Math.min(m, 5);
jd += m * 31;
if (month >= 8) {
m = month - 7;
jd += m * 30;
}
jd += date - 1;
}
return jd;
}
/*
* The following function is not needed for basic calendar functioning.
* This routine converts a gregorian date to the corresponding Julian date"
* @param year The year in standard Gregorian calendar (AD/BC) .
* @param month The month according to Gregorian calendar (between 0 to 11)
* @param date The date in month
*/
private static double gregorianToJD(int year, int month, int date) {
double JULIAN_EPOCH = 1721425.5;
double jd = (JULIAN_EPOCH - 1) +
(365 * (year - 1)) +
Math.floor((year - 1) / 4) +
(-Math.floor((year - 1) / 100)) +
Math.floor((year - 1) / 400) +
Math.floor((((367 * month) - 362) / 12) +
((month <= 2) ? 0 :
(isGregorianLeap(year) ? -1 : -2)
) +
date);
return jd;
}
/*
* The following function is not needed for basic calendar functioning.
* This routine converts a julian day (jd) to the corresponding date in Gregorian calendar"
* @param jd The Julian date in Julian Calendar which is to be converted to Indian date"
*/
private static int[] jdToGregorian(double jd) {
double JULIAN_EPOCH = 1721425.5;
double wjd, depoch, quadricent, dqc, cent, dcent, quad, dquad, yindex, yearday, leapadj;
int year, month, day;
wjd = Math.floor(jd - 0.5) + 0.5;
depoch = wjd - JULIAN_EPOCH;
quadricent = Math.floor(depoch / 146097);
dqc = depoch % 146097;
cent = Math.floor(dqc / 36524);
dcent = dqc % 36524;
quad = Math.floor(dcent / 1461);
dquad = dcent % 1461;
yindex = Math.floor(dquad / 365);
year = (int)((quadricent * 400) + (cent * 100) + (quad * 4) + yindex);
if (!((cent == 4) || (yindex == 4))) {
year++;
}
yearday = wjd - gregorianToJD(year, 1, 1);
leapadj = ((wjd < gregorianToJD(year, 3, 1)) ? 0
:
(isGregorianLeap(year) ? 1 : 2)
);
month = (int)Math.floor((((yearday + leapadj) * 12) + 373) / 367);
day = (int)(wjd - gregorianToJD(year, month, 1)) + 1;
int[] julianDate = new int[3];
julianDate[0] = year;
julianDate[1] = month;
julianDate[2] = day;
return julianDate;
}
/*
* The following function is not needed for basic calendar functioning.
* This routine checks if the Gregorian year is a leap year"
* @param year The year in Gregorian Calendar
*/
private static boolean isGregorianLeap(int year)
{
return ((year % 4) == 0) &&
(!(((year % 100) == 0) && ((year % 400) != 0)));
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public String getType() {
return "indian";
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/CompactByteArray.java 0000644 0001750 0001750 00000031025 10666355147 022574 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2007, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import com.ibm.icu.impl.Utility;
/**
* class CompactATypeArray : use only on primitive data types
* Provides a compact way to store information that is indexed by Unicode
* values, such as character properties, types, keyboard values, etc.This
* is very useful when you have a block of Unicode data that contains
* significant values while the rest of the Unicode data is unused in the
* application or when you have a lot of redundance, such as where all 21,000
* Han ideographs have the same value. However, lookup is much faster than a
* hash table.
* A compact array of any primitive data type serves two purposes:
*
*
* A compact array is composed of a index array and value array. The index
* array contains the indicies of Unicode characters to the value array.
*
* @see CompactCharArray
* @author Helena Shih
* @internal
* @deprecated This API is ICU internal only.
*/
public final class CompactByteArray implements Cloneable {
/**
* The total number of Unicode characters.
* @internal
* @deprecated This API is ICU internal only.
*/
public static final int UNICODECOUNT =65536;
/**
* Default constructor for CompactByteArray, the default value of the
* compact array is 0.
* @internal
* @deprecated This API is ICU internal only.
*/
public CompactByteArray()
{
this((byte)0);
}
/**
* Constructor for CompactByteArray.
* @param defaultValue the default value of the compact array.
* @internal
* @deprecated This API is ICU internal only.
*/
public CompactByteArray(byte defaultValue)
{
int i;
values = new byte[UNICODECOUNT];
indices = new char[INDEXCOUNT];
hashes = new int[INDEXCOUNT];
for (i = 0; i < UNICODECOUNT; ++i) {
values[i] = defaultValue;
}
for (i = 0; i < INDEXCOUNT; ++i) {
indices[i] = (char)(i<HebrewCalendar is a subclass of Calendar
* that that implements the traditional Hebrew calendar.
* This is the civil calendar in Israel and the liturgical calendar
* of the Jewish faith worldwide.
*
*
*
* ULocale
* with the tag "@calendar=hebrew".HebrewCalendar using the current time
* in the default time zone with the default locale.
* @stable ICU 2.8
*/
public HebrewCalendar() {
this(TimeZone.getDefault(), ULocale.getDefault());
}
/**
* Constructs a HebrewCalendar based on the current time
* in the given time zone with the default locale.
*
* @param zone The time zone for the new calendar.
* @stable ICU 2.8
*/
public HebrewCalendar(TimeZone zone) {
this(zone, ULocale.getDefault());
}
/**
* Constructs a HebrewCalendar based on the current time
* in the default time zone with the given locale.
*
* @param aLocale The locale for the new calendar.
* @stable ICU 2.8
*/
public HebrewCalendar(Locale aLocale) {
this(TimeZone.getDefault(), aLocale);
}
/**
* Constructs a HebrewCalendar based on the current time
* in the default time zone with the given locale.
*
* @param locale The locale for the new calendar.
* @stable ICU 3.2
*/
public HebrewCalendar(ULocale locale) {
this(TimeZone.getDefault(), locale);
}
/**
* Constructs a HebrewCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone The time zone for the new calendar.
*
* @param aLocale The locale for the new calendar.
* @stable ICU 2.8
*/
public HebrewCalendar(TimeZone zone, Locale aLocale) {
super(zone, aLocale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs a HebrewCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone The time zone for the new calendar.
*
* @param locale The locale for the new calendar.
* @stable ICU 3.2
*/
public HebrewCalendar(TimeZone zone, ULocale locale) {
super(zone, locale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs a HebrewCalendar with the given date set
* in the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for Tishri.
*
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @stable ICU 2.8
*/
public HebrewCalendar(int year, int month, int date) {
super(TimeZone.getDefault(), ULocale.getDefault());
this.set(YEAR, year);
this.set(MONTH, month);
this.set(DATE, date);
}
/**
* Constructs a HebrewCalendar with the given date set
* in the default time zone with the default locale.
*
* @param date The date to which the new calendar is set.
* @stable ICU 2.8
*/
public HebrewCalendar(Date date) {
super(TimeZone.getDefault(), ULocale.getDefault());
this.setTime(date);
}
/**
* Constructs a HebrewCalendar with the given date
* and time set for the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
*
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for Tishri.
*
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
*
* @param hour The value used to set the calendar's {@link #HOUR_OF_DAY HOUR_OF_DAY} time field.
*
* @param minute The value used to set the calendar's {@link #MINUTE MINUTE} time field.
*
* @param second The value used to set the calendar's {@link #SECOND SECOND} time field.
* @stable ICU 2.8
*/
public HebrewCalendar(int year, int month, int date, int hour,
int minute, int second)
{
super(TimeZone.getDefault(), ULocale.getDefault());
this.set(YEAR, year);
this.set(MONTH, month);
this.set(DATE, date);
this.set(HOUR_OF_DAY, hour);
this.set(MINUTE, minute);
this.set(SECOND, second);
}
//-------------------------------------------------------------------------
// Rolling and adding functions overridden from Calendar
//
// These methods call through to the default implementation in IBMCalendar
// for most of the fields and only handle the unusual ones themselves.
//-------------------------------------------------------------------------
/**
* Add a signed amount to a specified field, using this calendar's rules.
* For example, to add three days to the current date, you can call
* add(Calendar.DATE, 3).
* roll(Calendar.DATE, 3). If the
* field is rolled past its maximum allowable value, it will "wrap" back
* to its minimum and continue rolling.
* For example, calling roll(Calendar.DATE, 10)
* on a Hebrew calendar set to "25 Av 5758" will result in the date "5 Av 5758".
* roll.
*
*
*/
private static long startOfYear(int year)
{
long day = cache.get(year);
if (day == CalendarCache.EMPTY) {
int months = (235 * year - 234) / 19; // # of months before year
long frac = months * MONTH_FRACT + BAHARAD; // Fractional part of day #
day = months * 29 + (frac / DAY_PARTS); // Whole # part of calculation
frac = frac % DAY_PARTS; // Time of day
int wd = (int)(day % 7); // Day of week (0 == Monday)
if (wd == 2 || wd == 4 || wd == 6) {
// If the 1st is on Sun, Wed, or Fri, postpone to the next day
day += 1;
wd = (int)(day % 7);
}
if (wd == 1 && frac > 15*HOUR_PARTS+204 && !isLeapYear(year) ) {
// If the new moon falls after 3:11:20am (15h204p from the previous noon)
// on a Tuesday and it is not a leap year, postpone by 2 days.
// This prevents 356-day years.
day += 2;
}
else if (wd == 0 && frac > 21*HOUR_PARTS+589 && isLeapYear(year-1) ) {
// If the new moon falls after 9:32:43 1/3am (21h589p from yesterday noon)
// on a Monday and *last* year was a leap year, postpone by 1 day.
// Prevents 382-day years.
day += 1;
}
cache.put(year, day);
}
return day;
}
/*
* Find the day of the week for a given day
*
* @param day The # of days since the start of the Hebrew calendar,
* 1-based (i.e. 1/1/1 AM is day 1).
*/
/*private static int absoluteDayToDayOfWeek(long day)
{
// We know that 1/1/1 AM is a Monday, which makes the math easy...
return (int)(day % 7) + 1;
}*/
/**
* Returns the the type of a given year.
* 0 "Deficient" year with 353 or 383 days
* 1 "Normal" year with 354 or 384 days
* 2 "Complete" year with 355 or 385 days
*/
private final int yearType(int year)
{
int yearLength = handleGetYearLength(year);
if (yearLength > 380) {
yearLength -= 30; // Subtract length of leap month.
}
int type = 0;
switch (yearLength) {
case 353:
type = 0; break;
case 354:
type = 1; break;
case 355:
type = 2; break;
default:
throw new IllegalArgumentException("Illegal year length " + yearLength + " in year " + year);
}
return type;
}
/**
* Determine whether a given Hebrew year is a leap year
*
* The rule here is that if (year % 19) == 0, 3, 6, 8, 11, 14, or 17.
* The formula below performs the same test, believe it or not.
*/
private static final boolean isLeapYear(int year) {
//return (year * 12 + 17) % 19 >= 12;
int x = (year*12 + 17) % 19;
return x >= ((x < 0) ? -7 : 12);
}
private static int monthsInYear(int year) {
return isLeapYear(year) ? 13 : 12;
}
//-------------------------------------------------------------------------
// Calendar framework
//-------------------------------------------------------------------------
/**
* @stable ICU 2.8
*/
protected int handleGetLimit(int field, int limitType) {
return LIMITS[field][limitType];
}
/**
* Returns the length of the given month in the given year
* @stable ICU 2.8
*/
protected int handleGetMonthLength(int extendedYear, int month) {
// Resolve out-of-range months. This is necessary in order to
// obtain the correct year. We correct to
// a 12- or 13-month year (add/subtract 12 or 13, depending
// on the year) but since we _always_ number from 0..12, and
// the leap year determines whether or not month 5 (Adar 1)
// is present, we allow 0..12 in any given year.
while (month < 0) {
month += monthsInYear(--extendedYear);
}
// Careful: allow 0..12 in all years
while (month > 12) {
month -= monthsInYear(extendedYear++);
}
switch (month) {
case HESHVAN:
case KISLEV:
// These two month lengths can vary
return MONTH_LENGTH[month][yearType(extendedYear)];
default:
// The rest are a fixed length
return MONTH_LENGTH[month][0];
}
}
/**
* Returns the number of days in the given Hebrew year
* @stable ICU 2.8
*/
protected int handleGetYearLength(int eyear) {
return (int)(startOfYear(eyear+1) - startOfYear(eyear));
}
//-------------------------------------------------------------------------
// Functions for converting from milliseconds to field values
//-------------------------------------------------------------------------
/**
* Subclasses may override this method to compute several fields
* specific to each calendar system. These are:
*
*
*
* Subclasses can refer to the DAY_OF_WEEK and DOW_LOCAL fields,
* which will be set when this method is called. Subclasses can
* also call the getGregorianXxx() methods to obtain Gregorian
* calendar equivalents for the given Julian day.
*
* TimeZoneTransition is a class representing a time zone transition.
* An instance has a time of transition and rules for both before and
* after the transition.
*
* @stable ICU 3.8
*/
public class TimeZoneTransition {
private final TimeZoneRule from;
private final TimeZoneRule to;
private final long time;
/**
* Constructs a TimeZoneTransition with the time and the rules before/after
* the transition.
*
* @param time The time of transition in milliseconds since the base time.
* @param from The time zone rule used before the transition.
* @param to The time zone rule used after the transition.
*
* @stable ICU 3.8
*/
public TimeZoneTransition(long time, TimeZoneRule from, TimeZoneRule to) {
this.time = time;
this.from = from;
this.to = to;
}
/**
* Returns the time of transition in milliseconds since the base time.
*
* @return The time of the transition in milliseconds since the base time.
*
* @stable ICU 3.8
*/
public long getTime() {
return time;
}
/**
* Returns the rule used after the transition.
*
* @return The time zone rule used after the transition.
*
* @stable ICU 3.8
*/
public TimeZoneRule getTo() {
return to;
}
/**
* Returns the rule used before the transition.
*
* @return The time zone rule used after the transition.
*
* @stable ICU 3.8
*/
public TimeZoneRule getFrom() {
return from;
}
/**
* Returns a String representation of this TimeZoneTransition object.
* This method is used for debugging purpose only. The string representation can be changed
* in future version of ICU without any notice.
*
* @stable ICU 3.8
*/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("time=" + time);
buf.append(", from={" + from + "}");
buf.append(", to={" + to + "}");
return buf.toString();
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/StringTokenizer.java 0000644 0001750 0001750 00000062013 10435372603 022513 0 ustar twerner twerner /**
*******************************************************************************
* Copyright (C) 1996-2006, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.Enumeration;
import java.util.NoSuchElementException;
import com.ibm.icu.text.UnicodeSet;
import com.ibm.icu.text.UTF16;
/**
* StringTokenizer methods do not distinguish
* among identifiers, numbers, and quoted strings, nor do they recognize
* and skip comments.StringTokenizer behaves in one of three ways,
* depending on whether it was created with the returnDelims
* and coalesceDelims
* flags having the value true or false:
*
*
* false, delimiter code points serve to
* separate tokens. A token is a maximal sequence of consecutive
* code points that are not delimiters.
* true, delimiter code points are
* themselves considered to be tokens. In this case, if coalesceDelims is
* true, such tokens will be the maximal sequence of consecutive
* code points that are delimiters. If coalesceDelims is false,
* a token will be received for each delimiter code point.
*
*
* StringTokenizer st = new StringTokenizer("this is a test");
* while (st.hasMoreTokens()) {
* println(st.nextToken());
* }
*
*
* this
* is
* a
* test
*
* Example of the use of the tokenizer with user specified delimiter. *
* StringTokenizer st = new StringTokenizer(
* "this is a test with supplementary characters \ud800\ud800\udc00\udc00",
* " \ud800\udc00");
* while (st.hasMoreTokens()) {
* println(st.nextToken());
* }
* * prints the following output: *
* * @author syn wee * @stable ICU 2.4 */ public final class StringTokenizer implements Enumeration { // public constructors --------------------------------------------- /** ** this * is * a * test * with * supplementary * characters * \ud800 * \udc00 *
Constructs a string tokenizer for the specified string. All * characters in the delim argument are the delimiters for separating * tokens.
*If the returnDelims flag is false, the delimiter characters are * skipped and only serve as separators between tokens.
*If the returnDelims flag is true, then the delimiter characters * are also returned as tokens, one per delimiter. * @param str a string to be parsed. * @param delim the delimiters. * @param returndelims flag indicating whether to return the delimiters * as tokens. * @exception throws a NullPointerException if str is null * @stable ICU 2.4 */ public StringTokenizer(String str, UnicodeSet delim, boolean returndelims) { this(str, delim, returndelims, false); } /** *
Constructs a string tokenizer for the specified string. All * characters in the delim argument are the delimiters for separating * tokens.
*If the returnDelims flag is false, the delimiter characters are * skipped and only serve as separators between tokens.
*If the returnDelims flag is true, then the delimiter characters * are also returned as tokens. If coalescedelims is true, one token * is returned for each run of delimiter characters, otherwise one * token is returned per delimiter. Since surrogate pairs can be * delimiters, the returned token might be two chars in length.
* @param str a string to be parsed. * @param delim the delimiters. * @param returndelims flag indicating whether to return the delimiters * as tokens. * @param coalescedelims flag indicating whether to return a run of * delimiters as a single token or as one token per delimiter. * This only takes effect if returndelims is true. * @exception throws a NullPointerException if str is null * @internal ICU 3.4.3 * @deprecated This API is ICU internal only. */ public StringTokenizer(String str, UnicodeSet delim, boolean returndelims, boolean coalescedelims) { m_source_ = str; m_length_ = str.length(); if (delim == null) { m_delimiters_ = EMPTY_DELIMITER_; } else { m_delimiters_ = delim; } m_returnDelimiters_ = returndelims; m_coalesceDelimiters_ = coalescedelims; m_tokenOffset_ = -1; m_tokenSize_ = -1; if (m_length_ == 0) { // string length 0, no tokens m_nextOffset_ = -1; } else { m_nextOffset_ = 0; if (!returndelims) { m_nextOffset_ = getNextNonDelimiter(0); } } } /** *Constructs a string tokenizer for the specified string. The * characters in the delim argument are the delimiters for separating * tokens.
*Delimiter characters themselves will not be treated as tokens.
* @param str a string to be parsed. * @param delim the delimiters. * @exception throws a NullPointerException if str is null * @stable ICU 2.4 */ public StringTokenizer(String str, UnicodeSet delim) { this(str, delim, false, false); } /** *Constructs a string tokenizer for the specified string. All * characters in the delim argument are the delimiters for separating * tokens.
*If the returnDelims flag is false, the delimiter characters are * skipped and only serve as separators between tokens.
*If the returnDelims flag is true, then the delimiter characters * are also returned as tokens, one per delimiter. * @param str a string to be parsed. * @param delim the delimiters. * @param returndelims flag indicating whether to return the delimiters * as tokens. * @exception throws a NullPointerException if str is null * @stable ICU 2.4 */ public StringTokenizer(String str, String delim, boolean returndelims) { this(str, delim, returndelims, false); // java default behavior } /** *
Constructs a string tokenizer for the specified string. All * characters in the delim argument are the delimiters for separating * tokens.
*If the returnDelims flag is false, the delimiter characters are * skipped and only serve as separators between tokens.
*If the returnDelims flag is true, then the delimiter characters * are also returned as tokens. If coalescedelims is true, one token * is returned for each run of delimiter characters, otherwise one * token is returned per delimiter. Since surrogate pairs can be * delimiters, the returned token might be two chars in length.
* @param str a string to be parsed. * @param delim the delimiters. * @param returndelims flag indicating whether to return the delimiters * as tokens. * @param coalescedelims flag indicating whether to return a run of * delimiters as a single token or as one token per delimiter. * This only takes effect if returndelims is true. * @exception throws a NullPointerException if str is null * @internal ICU 3.4.3 * @deprecated This API is ICU internal only. */ public StringTokenizer(String str, String delim, boolean returndelims, boolean coalescedelims) { // don't ignore whitespace m_delimiters_ = EMPTY_DELIMITER_; if (delim != null && delim.length() > 0) { m_delimiters_ = new UnicodeSet(); m_delimiters_.addAll(delim); checkDelimiters(); } m_coalesceDelimiters_ = coalescedelims; m_source_ = str; m_length_ = str.length(); m_returnDelimiters_ = returndelims; m_tokenOffset_ = -1; m_tokenSize_ = -1; if (m_length_ == 0) { // string length 0, no tokens m_nextOffset_ = -1; } else { m_nextOffset_ = 0; if (!returndelims) { m_nextOffset_ = getNextNonDelimiter(0); } } } /** *Constructs a string tokenizer for the specified string. The * characters in the delim argument are the delimiters for separating * tokens.
*Delimiter characters themselves will not be treated as tokens.
* @param str a string to be parsed. * @param delim the delimiters. * @exception throws a NullPointerException if str is null * @stable ICU 2.4 */ public StringTokenizer(String str, String delim) { // don't ignore whitespace this(str, delim, false, false); } /** *Constructs a string tokenizer for the specified string. * The tokenizer uses the default delimiter set, which is * " \t\n\r\f": * the space character, the tab character, the newline character, the * carriage-return character, and the form-feed character.
*Delimiter characters themselves will not be treated as tokens.
* @param str a string to be parsed * @exception throws a NullPointerException if str is null * @stable ICU 2.4 */ public StringTokenizer(String str) { this(str, DEFAULT_DELIMITERS_, false, false); } // public methods -------------------------------------------------- /** * Tests if there are more tokens available from this tokenizer's * string. * If this method returns true, then a subsequent call to * nextToken with no argument will successfully return a token. * @returntrue if and only if there is at least one token
* in the string after the current position; false
* otherwise.
* @stable ICU 2.4
*/
public boolean hasMoreTokens()
{
return m_nextOffset_ >= 0;
}
/**
* Returns the next token from this string tokenizer.
* @return the next token from this string tokenizer.
* @exception NoSuchElementException if there are no more tokens in
* this tokenizer's string.
* @stable ICU 2.4
*/
public String nextToken()
{
if (m_tokenOffset_ < 0) {
if (m_nextOffset_ < 0) {
throw new NoSuchElementException("No more tokens in String");
}
// pre-calculations of tokens not done
if (m_returnDelimiters_) {
int tokenlimit = 0;
int c = UTF16.charAt(m_source_, m_nextOffset_);
boolean contains = delims == null
? m_delimiters_.contains(c)
: c < delims.length && delims[c];
if (contains) {
if (m_coalesceDelimiters_) {
tokenlimit = getNextNonDelimiter(m_nextOffset_);
} else {
tokenlimit = m_nextOffset_ + UTF16.getCharCount(c);
if (tokenlimit == m_length_) {
tokenlimit = -1;
}
}
}
else {
tokenlimit = getNextDelimiter(m_nextOffset_);
}
String result;
if (tokenlimit < 0) {
result = m_source_.substring(m_nextOffset_);
}
else {
result = m_source_.substring(m_nextOffset_, tokenlimit);
}
m_nextOffset_ = tokenlimit;
return result;
}
else {
int tokenlimit = getNextDelimiter(m_nextOffset_);
String result;
if (tokenlimit < 0) {
result = m_source_.substring(m_nextOffset_);
m_nextOffset_ = tokenlimit;
}
else {
result = m_source_.substring(m_nextOffset_, tokenlimit);
m_nextOffset_ = getNextNonDelimiter(tokenlimit);
}
return result;
}
}
// count was called before and we have all the tokens
if (m_tokenOffset_ >= m_tokenSize_) {
throw new NoSuchElementException("No more tokens in String");
}
String result;
if (m_tokenLimit_[m_tokenOffset_] >= 0) {
result = m_source_.substring(m_tokenStart_[m_tokenOffset_],
m_tokenLimit_[m_tokenOffset_]);
}
else {
result = m_source_.substring(m_tokenStart_[m_tokenOffset_]);
}
m_tokenOffset_ ++;
m_nextOffset_ = -1;
if (m_tokenOffset_ < m_tokenSize_) {
m_nextOffset_ = m_tokenStart_[m_tokenOffset_];
}
return result;
}
/**
* Returns the next token in this string tokenizer's string. First,
* the set of characters considered to be delimiters by this
* StringTokenizer object is changed to be the characters in
* the string delim. Then the next token in the string
* after the current position is returned. The current position is
* advanced beyond the recognized token. The new delimiter set
* remains the default after this call.
* @param delim the new delimiters.
* @return the next token, after switching to the new delimiter set.
* @exception NoSuchElementException if there are no more tokens in
* this tokenizer's string.
* @stable ICU 2.4
*/
public String nextToken(String delim)
{
m_delimiters_ = EMPTY_DELIMITER_;
if (delim != null && delim.length() > 0) {
m_delimiters_ = new UnicodeSet();
m_delimiters_.addAll(delim);
}
return nextToken(m_delimiters_);
}
/**
* Returns the next token in this string tokenizer's string. First,
* the set of characters considered to be delimiters by this
* StringTokenizer object is changed to be the characters in
* the string delim. Then the next token in the string
* after the current position is returned. The current position is
* advanced beyond the recognized token. The new delimiter set
* remains the default after this call.
* @param delim the new delimiters.
* @return the next token, after switching to the new delimiter set.
* @exception NoSuchElementException if there are no more tokens in
* this tokenizer's string.
* @stable ICU 2.4
*/
public String nextToken(UnicodeSet delim)
{
m_delimiters_ = delim;
checkDelimiters();
m_tokenOffset_ = -1;
m_tokenSize_ = -1;
if (!m_returnDelimiters_) {
m_nextOffset_ = getNextNonDelimiter(m_nextOffset_);
}
return nextToken();
}
/**
* Returns the same value as the hasMoreTokens method.
* It exists so that this class can implement the
* Enumeration interface.
* @return true if there are more tokens;
* false otherwise.
* @see #hasMoreTokens()
* @stable ICU 2.4
*/
public boolean hasMoreElements()
{
return hasMoreTokens();
}
/**
* Returns the same value as the nextToken method, except
* that its declared return value is Object rather than
* String. It exists so that this class can implement the
* Enumeration interface.
* @return the next token in the string.
* @exception NoSuchElementException if there are no more tokens in
* this tokenizer's string.
* @see #nextToken()
* @stable ICU 2.4
*/
public Object nextElement()
{
return nextToken();
}
/**
* Calculates the number of times that this tokenizer's
* nextToken method can be called before it generates an
* exception. The current position is not advanced.
* @return the number of tokens remaining in the string using the
* current delimiter set.
* @see #nextToken()
* @stable ICU 2.4
*/
public int countTokens()
{
int result = 0;
if (hasMoreTokens()) {
if (m_tokenOffset_ >= 0) {
return m_tokenSize_ - m_tokenOffset_;
}
if (m_tokenStart_ == null) {
m_tokenStart_ = new int[TOKEN_SIZE_];
m_tokenLimit_ = new int[TOKEN_SIZE_];
}
do {
if (m_tokenStart_.length == result) {
int temptokenindex[] = m_tokenStart_;
int temptokensize[] = m_tokenLimit_;
int originalsize = temptokenindex.length;
int newsize = originalsize + TOKEN_SIZE_;
m_tokenStart_ = new int[newsize];
m_tokenLimit_ = new int[newsize];
System.arraycopy(temptokenindex, 0, m_tokenStart_, 0,
originalsize);
System.arraycopy(temptokensize, 0, m_tokenLimit_, 0,
originalsize);
}
m_tokenStart_[result] = m_nextOffset_;
if (m_returnDelimiters_) {
int c = UTF16.charAt(m_source_, m_nextOffset_);
boolean contains = delims == null
? m_delimiters_.contains(c)
: c < delims.length && delims[c];
if (contains) {
if (m_coalesceDelimiters_) {
m_tokenLimit_[result] = getNextNonDelimiter(
m_nextOffset_);
} else {
int p = m_nextOffset_ + 1;
if (p == m_length_) {
p = -1;
}
m_tokenLimit_[result] = p;
}
}
else {
m_tokenLimit_[result] = getNextDelimiter(m_nextOffset_);
}
m_nextOffset_ = m_tokenLimit_[result];
}
else {
m_tokenLimit_[result] = getNextDelimiter(m_nextOffset_);
m_nextOffset_ = getNextNonDelimiter(m_tokenLimit_[result]);
}
result ++;
} while (m_nextOffset_ >= 0);
m_tokenOffset_ = 0;
m_tokenSize_ = result;
m_nextOffset_ = m_tokenStart_[0];
}
return result;
}
// private data members -------------------------------------------------
/**
* Current offset to the token array. If the array token is not set up yet,
* this value is a -1
*/
private int m_tokenOffset_;
/**
* Size of the token array. If the array token is not set up yet,
* this value is a -1
*/
private int m_tokenSize_;
/**
* Array of pre-calculated tokens start indexes in source string terminated
* by -1.
* This is only set up during countTokens() and only stores the remaining
* tokens, not all tokens including parsed ones
*/
private int m_tokenStart_[];
/**
* Array of pre-calculated tokens limit indexes in source string.
* This is only set up during countTokens() and only stores the remaining
* tokens, not all tokens including parsed ones
*/
private int m_tokenLimit_[];
/**
* UnicodeSet containing delimiters
*/
private UnicodeSet m_delimiters_;
/**
* String to parse for tokens
*/
private String m_source_;
/**
* Length of m_source_
*/
private int m_length_;
/**
* Current position in string to parse for tokens
*/
private int m_nextOffset_;
/**
* Flag indicator if delimiters are to be treated as tokens too
*/
private boolean m_returnDelimiters_;
/**
* Flag indicating whether to coalesce runs of delimiters into single tokens
*/
private boolean m_coalesceDelimiters_;
/**
* Default set of delimiters \t\n\r\f
*/
private static final UnicodeSet DEFAULT_DELIMITERS_
= new UnicodeSet("[ \t\n\r\f]", false);
/**
* Array size increments
*/
private static final int TOKEN_SIZE_ = 100;
/**
* A empty delimiter UnicodeSet, used when user specified null delimiters
*/
private static final UnicodeSet EMPTY_DELIMITER_ = new UnicodeSet();
// private methods ------------------------------------------------------
/**
* Gets the index of the next delimiter after offset
* @param offset to the source string
* @return offset of the immediate next delimiter, otherwise
* (- source string length - 1) if there
* are no more delimiters after m_nextOffset
*/
private int getNextDelimiter(int offset)
{
if (offset >= 0) {
int result = offset;
int c = 0;
if (delims == null) {
do {
c = UTF16.charAt(m_source_, result);
if (m_delimiters_.contains(c)) {
break;
}
result ++;
} while (result < m_length_);
} else {
do {
c = UTF16.charAt(m_source_, result);
if (c < delims.length && delims[c]) {
break;
}
result ++;
} while (result < m_length_);
}
if (result < m_length_) {
return result;
}
}
return -1 - m_length_;
}
/**
* Gets the index of the next non-delimiter after m_nextOffset_
* @param offset to the source string
* @return offset of the immediate next non-delimiter, otherwise
* (- source string length - 1) if there
* are no more delimiters after m_nextOffset
*/
private int getNextNonDelimiter(int offset)
{
if (offset >= 0) {
int result = offset;
int c = 0;
if (delims == null) {
do {
c = UTF16.charAt(m_source_, result);
if (!m_delimiters_.contains(c)) {
break;
}
result ++;
} while (result < m_length_);
} else {
do {
c = UTF16.charAt(m_source_, result);
if (!(c < delims.length && delims[c])) {
break;
}
result ++;
} while (result < m_length_);
}
if (result < m_length_) {
return result;
}
}
return -1 - m_length_;
}
void checkDelimiters() {
if (m_delimiters_ == null || m_delimiters_.size() == 0) {
delims = new boolean[0];
} else {
int maxChar = m_delimiters_.getRangeEnd(m_delimiters_.getRangeCount()-1);
if (maxChar < 0x7f) {
delims = new boolean[maxChar+1];
for (int i = 0, ch; -1 != (ch = m_delimiters_.charAt(i)); ++i) {
delims[ch] = true;
}
} else {
delims = null;
}
}
}
private boolean[] delims;
}
icu4j-4.2.1.1/src/com/ibm/icu/util/SimpleTimeZone.java 0000644 0001750 0001750 00000162270 11220605400 022247 0 ustar twerner twerner /*
* Copyright (C) 1996-2009, International Business Machines
* Corporation and others. All Rights Reserved.
*/
package com.ibm.icu.util;
import java.io.IOException;
import java.util.Date;
import com.ibm.icu.impl.Grego;
/**
* SimpleTimeZone is a concrete subclass of TimeZone
* that represents a time zone for use with a Gregorian calendar. This
* class does not handle historical changes.
*
*
* Use a negative value for dayOfWeekInMonth to indicate that
* SimpleTimeZone should count from the end of the month backwards.
* For example, if Daylight Savings Time starts or ends at the last Sunday in a month,
* use dayOfWeekInMonth = -1 along with dayOfWeek = Calendar.SUNDAY
* to specify the rule.
*
* @see Calendar
* @see GregorianCalendar
* @see TimeZone
* @author David Goldsmith, Mark Davis, Chen-Lieh Huang, Alan Liu
* @stable ICU 2.0
*/
public class SimpleTimeZone extends BasicTimeZone {
private static final long serialVersionUID = -7034676239311322769L;
/**
* Constant for a mode of start or end time specified as local wall time.
* @stable ICU 3.8
*/
public static final int WALL_TIME = 0;
/**
* Constant for a mode of start or end time specified as local standard time.
* @stable ICU 3.8
*/
public static final int STANDARD_TIME = 1;
/**
* Constant for a mode of start or end time specified as UTC.
* @stable ICU 3.8
*/
public static final int UTC_TIME = 2;
/**
* Constructs a SimpleTimeZone with the given base time zone offset from GMT
* and time zone ID. Timezone IDs can be obtained from
* TimeZone.getAvailableIDs. Normally you should use TimeZone.getDefault to
* construct a TimeZone.
*
* @param rawOffset The given base time zone offset to GMT.
* @param ID The time zone ID which is obtained from
* TimeZone.getAvailableIDs.
* @stable ICU 2.0
*/
public SimpleTimeZone(int rawOffset, String ID) {
construct(rawOffset, 0, 0, 0,
0, WALL_TIME,
0, 0, 0,
0, WALL_TIME,
Grego.MILLIS_PER_HOUR);
super.setID(ID);
}
/**
* Construct a SimpleTimeZone with the given base time zone offset from
* GMT, time zone ID, time to start and end the daylight time. Timezone IDs
* can be obtained from TimeZone.getAvailableIDs. Normally you should use
* TimeZone.getDefault to create a TimeZone. For a time zone that does not
* use daylight saving time, do not use this constructor; instead you should
* use SimpleTimeZone(rawOffset, ID).
*
* By default, this constructor specifies day-of-week-in-month rules. That
* is, if the startDay is 1, and the startDayOfWeek is SUNDAY, then this
* indicates the first Sunday in the startMonth. A startDay of -1 likewise
* indicates the last Sunday. However, by using negative or zero values for
* certain parameters, other types of rules can be specified.
*
* Day of month. To specify an exact day of the month, such as March 1, set
* startDayOfWeek to zero.
*
* Day of week after day of month. To specify the first day of the week
* occurring on or after an exact day of the month, make the day of the week
* negative. For example, if startDay is 5 and startDayOfWeek is -MONDAY,
* this indicates the first Monday on or after the 5th day of the
* startMonth.
*
* Day of week before day of month. To specify the last day of the week
* occurring on or before an exact day of the month, make the day of the
* week and the day of the month negative. For example, if startDay is -21
* and startDayOfWeek is -WEDNESDAY, this indicates the last Wednesday on or
* before the 21st of the startMonth.
*
* The above examples refer to the startMonth, startDay, and startDayOfWeek;
* the same applies for the endMonth, endDay, and endDayOfWeek.
*
* @param rawOffset The given base time zone offset to GMT.
* @param ID The time zone ID which is obtained from
* TimeZone.getAvailableIDs.
* @param startMonth The daylight savings starting month. Month is
* 0-based. eg, 0 for January.
* @param startDay The daylight savings starting
* day-of-week-in-month. Please see the member
* description for an example.
* @param startDayOfWeek The daylight savings starting day-of-week. Please
* see the member description for an example.
* @param startTime The daylight savings starting time in local wall
* time, which is standard time in this case. Please see the
* member description for an example.
* @param endMonth The daylight savings ending month. Month is
* 0-based. eg, 0 for January.
* @param endDay The daylight savings ending day-of-week-in-month.
* Please see the member description for an example.
* @param endDayOfWeek The daylight savings ending day-of-week. Please
* see the member description for an example.
* @param endTime The daylight savings ending time in local wall time,
* which is daylight time in this case. Please see the
* member description for an example.
* @exception IllegalArgumentException the month, day, dayOfWeek, or time
* parameters are out of range for the start or end rule
* @stable ICU 2.0
*/
public SimpleTimeZone(int rawOffset, String ID,
int startMonth, int startDay, int startDayOfWeek, int startTime,
int endMonth, int endDay, int endDayOfWeek, int endTime) {
construct(rawOffset,
startMonth, startDay, startDayOfWeek,
startTime, WALL_TIME,
endMonth, endDay, endDayOfWeek,
endTime, WALL_TIME,
Grego.MILLIS_PER_HOUR);
super.setID(ID);
}
/**
* Construct a SimpleTimeZone with the given base time zone offset from
* GMT, time zone ID, time and its mode to start and end the daylight time.
* The mode specifies either {@link #WALL_TIME} or {@link #STANDARD_TIME}
* or {@link #UTC_TIME}.
*
* @param rawOffset The given base time zone offset to GMT.
* @param ID The time zone ID which is obtained from
* TimeZone.getAvailableIDs.
* @param startMonth The daylight savings starting month. Month is
* 0-based. eg, 0 for January.
* @param startDay The daylight savings starting
* day-of-week-in-month. Please see the member
* description for an example.
* @param startDayOfWeek The daylight savings starting day-of-week. Please
* see the member description for an example.
* @param startTime The daylight savings starting time in local wall
* time, which is standard time in this case. Please see the
* member description for an example.
* @param startTimeMode The mode of the start time specified by startTime.
* @param endMonth The daylight savings ending month. Month is
* 0-based. eg, 0 for January.
* @param endDay The daylight savings ending day-of-week-in-month.
* Please see the member description for an example.
* @param endDayOfWeek The daylight savings ending day-of-week. Please
* see the member description for an example.
* @param endTime The daylight savings ending time in local wall time,
* which is daylight time in this case. Please see the
* member description for an example.
* @param endTimeMode The mode of the end time specified by endTime.
* @param dstSavings The amount of time in ms saved during DST.
* @exception IllegalArgumentException the month, day, dayOfWeek, or time
* parameters are out of range for the start or end rule
* @stable ICU 3.8
*/
public SimpleTimeZone(int rawOffset, String ID,
int startMonth, int startDay,
int startDayOfWeek, int startTime,
int startTimeMode,
int endMonth, int endDay,
int endDayOfWeek, int endTime,
int endTimeMode,int dstSavings){
construct(rawOffset,
startMonth, startDay, startDayOfWeek,
startTime, startTimeMode,
endMonth, endDay, endDayOfWeek,
endTime, endTimeMode,
dstSavings);
super.setID(ID);
}
/**
* Constructor. This constructor is identical to the 10-argument
* constructor, but also takes a dstSavings parameter.
* @param rawOffset The given base time zone offset to GMT.
* @param ID The time zone ID which is obtained from
* TimeZone.getAvailableIDs.
* @param startMonth The daylight savings starting month. Month is
* 0-based. eg, 0 for January.
* @param startDay The daylight savings starting
* day-of-week-in-month. Please see the member
* description for an example.
* @param startDayOfWeek The daylight savings starting day-of-week. Please
* see the member description for an example.
* @param startTime The daylight savings starting time in local wall
* time, which is standard time in this case. Please see the
* member description for an example.
* @param endMonth The daylight savings ending month. Month is
* 0-based. eg, 0 for January.
* @param endDay The daylight savings ending day-of-week-in-month.
* Please see the member description for an example.
* @param endDayOfWeek The daylight savings ending day-of-week. Please
* see the member description for an example.
* @param endTime The daylight savings ending time in local wall time,
* which is daylight time in this case. Please see the
* member description for an example.
* @param dstSavings The amount of time in ms saved during DST.
* @exception IllegalArgumentException the month, day, dayOfWeek, or time
* parameters are out of range for the start or end rule
* @stable ICU 2.0
*/
public SimpleTimeZone(int rawOffset, String ID,
int startMonth, int startDay, int startDayOfWeek, int startTime,
int endMonth, int endDay, int endDayOfWeek, int endTime,
int dstSavings) {
construct(rawOffset,
startMonth, startDay, startDayOfWeek,
startTime, WALL_TIME,
endMonth, endDay, endDayOfWeek,
endTime, WALL_TIME,
dstSavings);
super.setID(ID);
}
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public void setID(String ID) {
super.setID(ID);
transitionRulesInitialized = false;
}
/**
* Overrides TimeZone
* Sets the base time zone offset to GMT.
* This is the offset to add "to" UTC to get local time.
* @param offsetMillis the raw offset of the time zone
* @stable ICU 2.0
*/
public void setRawOffset(int offsetMillis) {
raw = offsetMillis;
transitionRulesInitialized = false;
}
/**
* Overrides TimeZone
* Gets the GMT offset for this time zone.
* @return the raw offset
* @stable ICU 2.0
*/
public int getRawOffset() {
return raw;
}
/**
* Sets the daylight savings starting year.
*
* @param year The daylight savings starting year.
* @stable ICU 2.0
*/
public void setStartYear(int year) {
//unwrapSTZ().setStartYear(year);
getSTZInfo().sy = year;
this.startYear = year;
transitionRulesInitialized = false;
}
/**
* Sets the daylight savings starting rule. For example, Daylight Savings
* Time starts at the second Sunday in March, at 2 AM in standard time.
* Therefore, you can set the start rule by calling:
* setStartRule(Calendar.MARCH, 2, Calendar.SUNDAY, 2*60*60*1000);
*
* @param month The daylight savings starting month. Month is
* 0-based. eg, 0 for January.
* @param dayOfWeekInMonth The daylight savings starting
* day-of-week-in-month. Please see the member
* description for an example.
* @param dayOfWeek The daylight savings starting day-of-week.
* Please see the member description for an
* example.
* @param time The daylight savings starting time in local wall
* time, which is standard time in this case. Please see
* the member description for an example.
* @exception IllegalArgumentException the month, dayOfWeekInMonth,
* dayOfWeek, or time parameters are out of range
* @stable ICU 2.0
*/
public void setStartRule(int month, int dayOfWeekInMonth, int dayOfWeek,
int time) {
getSTZInfo().setStart(month, dayOfWeekInMonth, dayOfWeek, time, -1, false);
setStartRule(month, dayOfWeekInMonth, dayOfWeek, time, WALL_TIME);
}
/**
* Sets the daylight savings starting rule. For example, in the U.S., Daylight Savings
* Time starts at the second Sunday in March, at 2 AM in standard time.
* Therefore, you can set the start rule by calling:
* setStartRule(Calendar.MARCH, 2, Calendar.SUNDAY, 2*60*60*1000);
* The dayOfWeekInMonth and dayOfWeek parameters together specify how to calculate
* the exact starting date. Their exact meaning depend on their respective signs,
* allowing various types of rules to be constructed, as follows:
setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*60*60*1000);
*
* @param month The daylight savings ending month. Month is
* 0-based. eg, 0 for January.
* @param dayOfWeekInMonth The daylight savings ending
* day-of-week-in-month. Please see the member
* description for an example.
* @param dayOfWeek The daylight savings ending day-of-week. Please
* see the member description for an example.
* @param time The daylight savings ending time in local wall time,
* which is daylight time in this case. Please see the
* member description for an example.
* @exception IllegalArgumentException the month, dayOfWeekInMonth,
* dayOfWeek, or time parameters are out of range
* @stable ICU 2.0
*/
public void setEndRule(int month, int dayOfWeekInMonth, int dayOfWeek, int time) {
getSTZInfo().setEnd(month, dayOfWeekInMonth, dayOfWeek, time, -1, false);
setEndRule(month, dayOfWeekInMonth, dayOfWeek, time, WALL_TIME);
}
/**
* Sets the DST end rule to a fixed date within a month.
*
* @param month The month in which this rule occurs (0-based).
* @param dayOfMonth The date in that month (1-based).
* @param time The time of that day (number of millis after midnight)
* when DST ends in local wall time, which is daylight
* time in this case.
* @exception IllegalArgumentException the month,
* dayOfMonth, or time parameters are out of range
* @stable ICU 2.0
*/
public void setEndRule(int month, int dayOfMonth, int time) {
getSTZInfo().setEnd(month, -1, -1, time, dayOfMonth, false);
setEndRule(month, dayOfMonth, WALL_TIME, time);
}
/**
* Sets the DST end rule to a weekday before or after a give date within
* a month, e.g., the first Monday on or after the 8th.
*
* @param month The month in which this rule occurs (0-based).
* @param dayOfMonth A date within that month (1-based).
* @param dayOfWeek The day of the week on which this rule occurs.
* @param time The time of that day (number of millis after midnight)
* when DST ends in local wall time, which is daylight
* time in this case.
* @param after If true, this rule selects the first dayOfWeek on
* or after dayOfMonth. If false, this rule selects
* the last dayOfWeek on or before dayOfMonth.
* @exception IllegalArgumentException the month, dayOfMonth,
* dayOfWeek, or time parameters are out of range
* @stable ICU 2.0
*/
public void setEndRule(int month, int dayOfMonth, int dayOfWeek, int time, boolean after) {
getSTZInfo().setEnd(month, -1, dayOfWeek, time, dayOfMonth, after);
setEndRule(month, dayOfMonth, dayOfWeek, time, WALL_TIME, after);
}
private void setEndRule(int month, int dayOfMonth, int dayOfWeek,
int time, int mode, boolean after){
setEndRule(month, after ? dayOfMonth : -dayOfMonth, -dayOfWeek, time, mode);
}
/**
* Sets the daylight savings ending rule. For example, in the U.S., Daylight
* Savings Time ends at the first Sunday in November, at 2 AM in standard time.
* Therefore, you can set the end rule by calling:
* setEndRule(Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2*60*60*1000);
* Various other types of rules can be specified by manipulating the dayOfWeek
* and dayOfWeekInMonth parameters. For complete details, see the documentation
* for setStartRule().
* @param month the daylight savings ending month. Month is 0-based.
* eg, 0 for January.
* @param dayOfWeekInMonth the daylight savings ending
* day-of-week-in-month. See setStartRule() for a complete explanation.
* @param dayOfWeek the daylight savings ending day-of-week. See setStartRule()
* for a complete explanation.
* @param time the daylight savings ending time. Please see the member
* description for an example.
*/
private void setEndRule(int month, int dayOfWeekInMonth, int dayOfWeek, int time, int mode){
endMonth = month;
endDay = dayOfWeekInMonth;
endDayOfWeek = dayOfWeek;
endTime = time;
endTimeMode = mode;
decodeEndRule();
transitionRulesInitialized = false;
}
/**
* Sets the amount of time in ms that the clock is advanced during DST.
* @param millisSavedDuringDST the number of milliseconds the time is
* advanced with respect to standard time when the daylight savings rules
* are in effect. A positive number, typically one hour (3600000).
* @stable ICU 2.0
*/
public void setDSTSavings(int millisSavedDuringDST) {
if (millisSavedDuringDST <= 0) {
throw new IllegalArgumentException();
}
dst = millisSavedDuringDST;
transitionRulesInitialized = false;
}
/**
* Returns the amount of time in ms that the clock is advanced during DST.
* @return the number of milliseconds the time is
* advanced with respect to standard time when the daylight savings rules
* are in effect. A positive number, typically one hour (3600000).
* @stable ICU 2.0
*/
public int getDSTSavings() {
return dst;
}
/**
* Returns the java.util.SimpleTimeZone that this class wraps.
*
java.util.SimpleTimeZone unwrapSTZ() {
return (java.util.SimpleTimeZone) unwrap();
}
*/
// on JDK 1.4 and later, can't deserialize a SimpleTimeZone as a SimpleTimeZone...
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
/*
String id = getID();
if (id!=null && !(zone instanceof java.util.SimpleTimeZone && zone.getID().equals(id))) {
// System.out.println("*** readjust " + zone.getClass().getName() + " " + zone.getID() + " ***");
java.util.SimpleTimeZone stz =
new java.util.SimpleTimeZone(raw, id);
if (dst != 0) {
stz.setDSTSavings(dst);
// if it is 0, then there shouldn't be start/end rules and the default
// behavior should be no dst
}
if (xinfo != null) {
xinfo.applyTo(stz);
}
zoneJDK = stz;
}
*/
/* set all instance variables in this object
* to the values in zone
*/
if (xinfo != null) {
xinfo.applyTo(this);
}
}
/**
* Returns a string representation of this object.
* @return a string representation of this object
* @stable ICU 3.6
*/
public String toString() {
return "SimpleTimeZone: " + getID();
}
private STZInfo getSTZInfo() {
if (xinfo == null) {
xinfo = new STZInfo();
}
return xinfo;
}
// Use only for decodeStartRule() and decodeEndRule() where the year is not
// available. Set February to 29 days to accomodate rules with that date
// and day-of-week-on-or-before-that-date mode (DOW_LE_DOM_MODE).
// The compareToRule() method adjusts to February 28 in non-leap years.
//
// For actual getOffset() calculations, use TimeZone::monthLength() and
// TimeZone::previousMonthLength() which take leap years into account.
// We handle leap years assuming always
// Gregorian, since we know they didn't have daylight time when
// Gregorian calendar started.
private final static byte staticMonthLength[] = {31,29,31,30,31,30,31,31,30,31,30,31};
/**
* {@inheritDoc}
* @stable ICU 2.0
*/
public int getOffset(int era, int year, int month, int day,
int dayOfWeek, int millis)
{
// Check the month before calling Grego.monthLength(). This
// duplicates the test that occurs in the 7-argument getOffset(),
// however, this is unavoidable. We don't mind because this method, in
// fact, should not be called; internal code should always call the
// 7-argument getOffset(), and outside code should use Calendar.get(int
// field) with fields ZONE_OFFSET and DST_OFFSET. We can't get rid of
// this method because it's public API. - liu 8/10/98
if(month < Calendar.JANUARY || month > Calendar.DECEMBER) {
throw new IllegalArgumentException();
}
return getOffset(era, year, month, day, dayOfWeek, millis, Grego.monthLength(year, month));
}
/**
* @internal
* @deprecated This API is ICU internal only.
*/
public int getOffset(int era, int year, int month, int day,
int dayOfWeek, int millis,
int monthLength) {
// Check the month before calling Grego.monthLength(). This
// duplicates a test that occurs in the 9-argument getOffset(),
// however, this is unavoidable. We don't mind because this method, in
// fact, should not be called; internal code should always call the
// 9-argument getOffset(), and outside code should use Calendar.get(int
// field) with fields ZONE_OFFSET and DST_OFFSET. We can't get rid of
// this method because it's public API. - liu 8/10/98
if(month < Calendar.JANUARY || month > Calendar.DECEMBER) {
throw new IllegalArgumentException();
}
return getOffset(era, year, month, day, dayOfWeek, millis,
Grego.monthLength(year, month), Grego.previousMonthLength(year, month));
}
int getOffset(int era, int year, int month, int day,
int dayOfWeek, int millis,
int monthLength, int prevMonthLength ){
if (true) {
/* Use this parameter checking code for normal operation. Only one
* of these two blocks should actually get compiled into the class
* file. */
if ((era != GregorianCalendar.AD && era != GregorianCalendar.BC)
|| month < Calendar.JANUARY
|| month > Calendar.DECEMBER
|| day < 1
|| day > monthLength
|| dayOfWeek < Calendar.SUNDAY
|| dayOfWeek > Calendar.SATURDAY
|| millis < 0
|| millis >= Grego.MILLIS_PER_DAY
|| monthLength < 28
|| monthLength > 31
|| prevMonthLength < 28
|| prevMonthLength > 31) {
throw new IllegalArgumentException();
}
} else {
/* This parameter checking code is better for debugging, but
* overkill for normal operation. Only one of these two blocks
* should actually get compiled into the class file. */
if (era != GregorianCalendar.AD && era != GregorianCalendar.BC) {
throw new IllegalArgumentException("Illegal era " + era);
}
if (month < Calendar.JANUARY
|| month > Calendar.DECEMBER) {
throw new IllegalArgumentException("Illegal month " + month);
}
if (day < 1
|| day > monthLength) {
throw new IllegalArgumentException("Illegal day " + day+" max month len: "+monthLength);
}
if (dayOfWeek < Calendar.SUNDAY
|| dayOfWeek > Calendar.SATURDAY) {
throw new IllegalArgumentException("Illegal day of week " + dayOfWeek);
}
if (millis < 0
|| millis >= Grego.MILLIS_PER_DAY) {
throw new IllegalArgumentException("Illegal millis " + millis);
}
if (monthLength < 28
|| monthLength > 31) {
throw new IllegalArgumentException("Illegal month length " + monthLength);
}
if (prevMonthLength < 28
|| prevMonthLength > 31) {
throw new IllegalArgumentException("Illegal previous month length " + prevMonthLength);
}
}
int result = raw;
// Bail out if we are before the onset of daylight savings time
if (!useDaylight || year < startYear || era != GregorianCalendar.AD) return result;
// Check for southern hemisphere. We assume that the start and end
// month are different.
boolean southern = (startMonth > endMonth);
// Compare the date to the starting and ending rules.+1 = date>rule, -1
// = date*
* DOW_IN_MONTH DOM DOW>=DOM DOW<=DOM no DST
* ------------ ----- -------- -------- ----------
* month 0..11 same same same don't care
* day -5..5 1..31 1..31 -1..-31 0
* dayOfWeek 1..7 0 -1..-7 -1..-7 don't care
* time 0..ONEDAY same same same don't care
*
* The range for month does not include UNDECIMBER since this class is
* really specific to GregorianCalendar, which does not use that month.
* The range for time includes ONEDAY (vs. ending at ONEDAY-1) because the
* end rule is an exclusive limit point. That is, the range of times that
* are in DST include those >= the start and < the end. For this reason,
* it should be possible to specify an end of ONEDAY in order to include the
* entire day. Although this is equivalent to time 0 of the following day,
* it's not always possible to specify that, for example, on December 31.
* While arguably the start range should still be 0..ONEDAY-1, we keep
* the start and end ranges the same for consistency.
*/
private void decodeStartRule() {
useDaylight = (boolean)((startDay != 0) && (endDay != 0) ? true : false );
if (useDaylight && dst == 0) {
dst = Grego.MILLIS_PER_DAY;
}
if (startDay != 0) {
if (startMonth < Calendar.JANUARY || startMonth > Calendar.DECEMBER) {
throw new IllegalArgumentException();
}
if (startTime < 0 || startTime > Grego.MILLIS_PER_DAY ||
startTimeMode < WALL_TIME || startTimeMode > UTC_TIME) {
throw new IllegalArgumentException();
}
if (startDayOfWeek == 0) {
startMode = DOM_MODE;
} else {
if (startDayOfWeek > 0) {
startMode = DOW_IN_MONTH_MODE;
} else {
startDayOfWeek = (int)-startDayOfWeek;
if (startDay > 0) {
startMode = DOW_GE_DOM_MODE;
} else {
startDay = (int)-startDay;
startMode = DOW_LE_DOM_MODE;
}
}
if (startDayOfWeek > Calendar.SATURDAY) {
throw new IllegalArgumentException();
}
}
if (startMode == DOW_IN_MONTH_MODE) {
if (startDay < -5 || startDay > 5) {
throw new IllegalArgumentException();
}
} else if (startDay < 1 || startDay > staticMonthLength[startMonth]) {
throw new IllegalArgumentException();
}
}
}
/**
* Decode the end rule and validate the parameters. This method is exactly
* analogous to decodeStartRule().
* @see #decodeStartRule
*/
private void decodeEndRule() {
useDaylight = (boolean)((startDay != 0) && (endDay != 0) ? true : false);
if (useDaylight && dst == 0) {
dst = Grego.MILLIS_PER_DAY;
}
if (endDay != 0) {
if (endMonth < Calendar.JANUARY || endMonth > Calendar.DECEMBER) {
throw new IllegalArgumentException();
}
if (endTime < 0 || endTime > Grego.MILLIS_PER_DAY ||
endTimeMode < WALL_TIME || endTimeMode > UTC_TIME) {
throw new IllegalArgumentException();
}
if (endDayOfWeek == 0) {
endMode = DOM_MODE;
} else {
if (endDayOfWeek > 0) {
endMode = DOW_IN_MONTH_MODE;
} else {
endDayOfWeek = (int)-endDayOfWeek;
if (endDay > 0) {
endMode = DOW_GE_DOM_MODE;
} else {
endDay = (int)-endDay;
endMode = DOW_LE_DOM_MODE;
}
}
if (endDayOfWeek > Calendar.SATURDAY) {
throw new IllegalArgumentException();
}
}
if (endMode == DOW_IN_MONTH_MODE) {
if (endDay < -5 || endDay > 5) {
throw new IllegalArgumentException();
}
} else if (endDay<1 || endDay > staticMonthLength[endMonth]) {
throw new IllegalArgumentException();
}
}
}
/**
* Return true if obj is a SimpleTimeZone equivalent to this.
* @return true if obj is a SimpleTimeZone equivalent to this
* @stable ICU 3.6
*/
public boolean equals(Object obj){
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
SimpleTimeZone that = (SimpleTimeZone) obj;
return raw == that.raw &&
useDaylight == that.useDaylight &&
idEquals(getID(),that.getID()) &&
(!useDaylight
// Only check rules if using DST
|| (dst == that.dst &&
startMode == that.startMode &&
startMonth == that.startMonth &&
startDay == that.startDay &&
startDayOfWeek == that.startDayOfWeek &&
startTime == that.startTime &&
startTimeMode == that.startTimeMode &&
endMode == that.endMode &&
endMonth == that.endMonth &&
endDay == that.endDay &&
endDayOfWeek == that.endDayOfWeek &&
endTime == that.endTime &&
endTimeMode == that.endTimeMode &&
startYear == that.startYear ));
}
private boolean idEquals(String id1, String id2){
if(id1==null && id2==null){
return true;
}
if(id1!=null && id2!=null){
return id1.equals(id2);
}
return false;
}
/**
* Return the hash code.
* @return the hash code
* @stable ICU 3.6
*/
public int hashCode(){
int ret = (int)( super.hashCode() +
raw ^ (raw>>>8) +
(useDaylight?0:1));
if(!useDaylight){
ret += (int)(dst ^ (dst>>>10) +
startMode ^ (startMode>>>11) +
startMonth ^ (startMonth>>>12) +
startDay ^ (startDay>>>13) +
startDayOfWeek ^ (startDayOfWeek>>>14) +
startTime ^ (startTime>>>15) +
startTimeMode ^ (startTimeMode>>>16) +
endMode ^ (endMode>>>17) +
endMonth ^ (endMonth>>>18) +
endDay ^ (endDay>>>19) +
endDayOfWeek ^ (endDayOfWeek>>>20) +
endTime ^ (endTime>>>21) +
endTimeMode ^ (endTimeMode>>>22) +
startYear ^ (startYear>>>23));
}
return ret;
}
/**
* Return a clone of this time zone.
* @return a clone of this time zone
* @stable ICU 3.6
*/
public Object clone() {
return super.clone();
}
/**
* Return true if this zone has the same rules and offset as another zone.
* @param othr the TimeZone object to be compared with
* @return true if the given zone has the same rules and offset as this one
* @stable ICU 2.0
*/
public boolean hasSameRules(TimeZone othr) {
if(!(othr instanceof SimpleTimeZone)){
return false;
}
SimpleTimeZone other = (SimpleTimeZone)othr;
return other != null &&
raw == other.raw &&
useDaylight == other.useDaylight &&
(!useDaylight
// Only check rules if using DST
|| (dst == other.dst &&
startMode == other.startMode &&
startMonth == other.startMonth &&
startDay == other.startDay &&
startDayOfWeek == other.startDayOfWeek &&
startTime == other.startTime &&
startTimeMode == other.startTimeMode &&
endMode == other.endMode &&
endMonth == other.endMonth &&
endDay == other.endDay &&
endDayOfWeek == other.endDayOfWeek &&
endTime == other.endTime &&
endTimeMode == other.endTimeMode &&
startYear == other.startYear));
}
// BasicTimeZone methods
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public TimeZoneTransition getNextTransition(long base, boolean inclusive) {
if (!useDaylight) {
return null;
}
initTransitionRules();
long firstTransitionTime = firstTransition.getTime();
if (base < firstTransitionTime || (inclusive && base == firstTransitionTime)) {
return firstTransition;
}
Date stdDate = stdRule.getNextStart(base, dstRule.getRawOffset(), dstRule.getDSTSavings(), inclusive);
Date dstDate = dstRule.getNextStart(base, stdRule.getRawOffset(), stdRule.getDSTSavings(), inclusive);
if (stdDate != null && (dstDate == null || stdDate.before(dstDate))) {
return new TimeZoneTransition(stdDate.getTime(), dstRule, stdRule);
}
if (dstDate != null && (stdDate == null || dstDate.before(stdDate))) {
return new TimeZoneTransition(dstDate.getTime(), stdRule, dstRule);
}
return null;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public TimeZoneTransition getPreviousTransition(long base, boolean inclusive) {
if (!useDaylight) {
return null;
}
initTransitionRules();
long firstTransitionTime = firstTransition.getTime();
if (base < firstTransitionTime || (!inclusive && base == firstTransitionTime)) {
return null;
}
Date stdDate = stdRule.getPreviousStart(base, dstRule.getRawOffset(), dstRule.getDSTSavings(), inclusive);
Date dstDate = dstRule.getPreviousStart(base, stdRule.getRawOffset(), stdRule.getDSTSavings(), inclusive);
if (stdDate != null && (dstDate == null || stdDate.after(dstDate))) {
return new TimeZoneTransition(stdDate.getTime(), dstRule, stdRule);
}
if (dstDate != null && (stdDate == null || dstDate.after(stdDate))) {
return new TimeZoneTransition(dstDate.getTime(), stdRule, dstRule);
}
return null;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public TimeZoneRule[] getTimeZoneRules() {
initTransitionRules();
int size = useDaylight ? 3 : 1;
TimeZoneRule[] rules = new TimeZoneRule[size];
rules[0] = initialRule;
if (useDaylight) {
rules[1] = stdRule;
rules[2] = dstRule;
}
return rules;
}
private transient boolean transitionRulesInitialized;
private transient InitialTimeZoneRule initialRule;
private transient TimeZoneTransition firstTransition;
private transient AnnualTimeZoneRule stdRule;
private transient AnnualTimeZoneRule dstRule;
private synchronized void initTransitionRules() {
if (transitionRulesInitialized) {
return;
}
if (useDaylight) {
DateTimeRule dtRule = null;
int timeRuleType;
long firstStdStart, firstDstStart;
// Create a TimeZoneRule for daylight saving time
timeRuleType = (startTimeMode == STANDARD_TIME) ? DateTimeRule.STANDARD_TIME :
((startTimeMode == UTC_TIME) ? DateTimeRule.UTC_TIME : DateTimeRule.WALL_TIME);
switch (startMode) {
case DOM_MODE:
dtRule = new DateTimeRule(startMonth, startDay, startTime, timeRuleType);
break;
case DOW_IN_MONTH_MODE:
dtRule = new DateTimeRule(startMonth, startDay, startDayOfWeek, startTime, timeRuleType);
break;
case DOW_GE_DOM_MODE:
dtRule = new DateTimeRule(startMonth, startDay, startDayOfWeek, true, startTime, timeRuleType);
break;
case DOW_LE_DOM_MODE:
dtRule = new DateTimeRule(startMonth, startDay, startDayOfWeek, false, startTime, timeRuleType);
break;
}
// For now, use ID + "(DST)" as the name
dstRule = new AnnualTimeZoneRule(getID() + "(DST)", getRawOffset(), getDSTSavings(),
dtRule, startYear, AnnualTimeZoneRule.MAX_YEAR);
// Calculate the first DST start time
firstDstStart = dstRule.getFirstStart(getRawOffset(), 0).getTime();
// Create a TimeZoneRule for standard time
timeRuleType = (endTimeMode == STANDARD_TIME) ? DateTimeRule.STANDARD_TIME :
((endTimeMode == UTC_TIME) ? DateTimeRule.UTC_TIME : DateTimeRule.WALL_TIME);
switch (endMode) {
case DOM_MODE:
dtRule = new DateTimeRule(endMonth, endDay, endTime, timeRuleType);
break;
case DOW_IN_MONTH_MODE:
dtRule = new DateTimeRule(endMonth, endDay, endDayOfWeek, endTime, timeRuleType);
break;
case DOW_GE_DOM_MODE:
dtRule = new DateTimeRule(endMonth, endDay, endDayOfWeek, true, endTime, timeRuleType);
break;
case DOW_LE_DOM_MODE:
dtRule = new DateTimeRule(endMonth, endDay, endDayOfWeek, false, endTime, timeRuleType);
break;
}
// For now, use ID + "(STD)" as the name
stdRule = new AnnualTimeZoneRule(getID() + "(STD)", getRawOffset(), 0,
dtRule, startYear, AnnualTimeZoneRule.MAX_YEAR);
// Calculate the first STD start time
firstStdStart = stdRule.getFirstStart(getRawOffset(), dstRule.getDSTSavings()).getTime();
// Create a TimeZoneRule for initial time
if (firstStdStart < firstDstStart) {
initialRule = new InitialTimeZoneRule(getID() + "(DST)", getRawOffset(), dstRule.getDSTSavings());
firstTransition = new TimeZoneTransition(firstStdStart, initialRule, stdRule);
} else {
initialRule = new InitialTimeZoneRule(getID() + "(STD)", getRawOffset(), 0);
firstTransition = new TimeZoneTransition(firstDstStart, initialRule, dstRule);
}
} else {
// Create a TimeZoneRule for initial time
initialRule = new InitialTimeZoneRule(getID(), getRawOffset(), 0);
}
transitionRulesInitialized = true;
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/CompactCharArray.java 0000644 0001750 0001750 00000033030 10666355147 022544 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2007, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import com.ibm.icu.impl.Utility;
/**
* class CompactATypeArray : use only on primitive data types
* Provides a compact way to store information that is indexed by Unicode
* values, such as character properties, types, keyboard values, etc.This
* is very useful when you have a block of Unicode data that contains
* significant values while the rest of the Unicode data is unused in the
* application or when you have a lot of redundance, such as where all 21,000
* Han ideographs have the same value. However, lookup is much faster than a
* hash table.
* A compact array of any primitive data type serves two purposes:
* This class defines one addition field beyond those defined by
* Calendar: The IS_LEAP_MONTH field takes the
* value of 0 for normal months, or 1 for leap months.
*
*
All astronomical computations are performed with respect to a time * zone of GMT+8:00 and a longitude of 120 degrees east. Although some * calendars implement a historically more accurate convention of using * Beijing's local longitude (116 degrees 25 minutes east) and time zone * (GMT+7:45:40) for dates before 1929, we do not implement this here. * *
Years are counted in two different ways in the Chinese calendar. The
* first method is by sequential numbering from the 61st year of the reign
* of Huang Di, 2637 BCE, which is designated year 1 on the Chinese
* calendar. The second method uses 60-year cycles from the same starting
* point, which is designated year 1 of cycle 1. In this class, the
* EXTENDED_YEAR field contains the sequential year count.
* The ERA field contains the cycle number, and the
* YEAR field contains the year of the cycle, a value between
* 1 and 60.
*
*
There is some variation in what is considered the starting point of * the calendar, with some sources starting in the first year of the reign * of Huang Di, rather than the 61st. This gives continuous year numbers * 60 years greater and cycle numbers one greater than what this class * implements. * *
Because ChineseCalendar defines an additional field and
* redefines the way the ERA field is used, it requires a new
* format class, ChineseDateFormat. As always, use the
* methods DateFormat.getXxxInstance(Calendar cal,...) to
* obtain a formatter for this calendar.
*
*
References:
* This class should not be subclassed.
*
* ChineseCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a ULocale
* with the tag "@calendar=chinese".
ChineseCalendar with the default time zone and locale.
* @stable ICU 2.8
*/
public ChineseCalendar() {
super();
setTimeInMillis(System.currentTimeMillis());
}
/**
* Construct a ChineseCalendar with the give date set in the default time zone
* with the default locale.
* @param date The date to which the new calendar is set.
* @stable ICU 4.0
*/
public ChineseCalendar(Date date) {
super();
setTime(date);
}
/**
* Constructs a ChineseCalendar with the given date set
* in the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for January.
* @param isLeapMonth The value used to set the Chiense calendar's (@link #IS_LEAP_MONTH)
* time field.
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @stable ICU 4.0
*/
public ChineseCalendar(int year, int month, int isLeapMonth, int date) {
super(TimeZone.getDefault(), ULocale.getDefault());
// We need to set the current time once to initialize the ChineseCalendar's
// ERA field to be the current era.
setTimeInMillis(System.currentTimeMillis());
// Then we need to clean up time fields
this.set(MILLISECONDS_IN_DAY, 0);
// Then set the given field values.
this.set(YEAR, year);
this.set(MONTH, month);
this.set(IS_LEAP_MONTH, isLeapMonth);
this.set(DATE, date);
}
/**
* Constructs a ChineseCalendar with the given date
* and time set for the default time zone with the default locale.
*
* @param year the value used to set the {@link #YEAR YEAR} time field in the calendar.
* @param month the value used to set the {@link #MONTH MONTH} time field in the calendar.
* Note that the month value is 0-based. e.g., 0 for January.
* @param isLeapMonth the value used to set the {@link #IS_LEAP_MONTH} time field
* in the calendar.
* @param date the value used to set the {@link #DATE DATE} time field in the calendar.
* @param hour the value used to set the {@link #HOUR_OF_DAY HOUR_OF_DAY} time field
* in the calendar.
* @param minute the value used to set the {@link #MINUTE MINUTE} time field
* in the calendar.
* @param second the value used to set the {@link #SECOND SECOND} time field
* in the calendar.
* @stable ICU 4.0
*/
public ChineseCalendar(int year, int month, int isLeapMonth, int date, int hour,
int minute, int second)
{
super(TimeZone.getDefault(), ULocale.getDefault());
// We need to set the current time once to initialize the ChineseCalendar's
// ERA field to be the current era.
setTimeInMillis(System.currentTimeMillis());
// Then set 0 to millisecond field
this.set(MILLISECOND, 0);
// Then, set the given field values.
this.set(YEAR, year);
this.set(MONTH, month);
this.set(IS_LEAP_MONTH, isLeapMonth);
this.set(DATE, date);
this.set(HOUR_OF_DAY, hour);
this.set(MINUTE, minute);
this.set(SECOND, second);
}
/**
* Constructs a ChineseCalendar based on the current time
* in the default time zone with the given locale.
* @param aLocale The given locale
* @stable ICU 4.0
*/
public ChineseCalendar(Locale aLocale) {
this(TimeZone.getDefault(), aLocale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Construct a ChineseCalendar based on the current time
* in the given time zone with the default locale.
* @param zone the given time zone
* @stable ICU 4.0
*/
public ChineseCalendar(TimeZone zone) {
super(zone, ULocale.getDefault());
setTimeInMillis(System.currentTimeMillis());
}
/**
* Construct a ChineseCalendar based on the current time
* in the given time zone with the given locale.
* @param zone the given time zone
* @param aLocale the given locale
* @stable ICU 2.8
*/
public ChineseCalendar(TimeZone zone, Locale aLocale) {
super(zone, aLocale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs a ChineseCalendar based on the current time
* in the default time zone with the given locale.
*
* @param locale the given ulocale
* @stable ICU 4.0
*/
public ChineseCalendar(ULocale locale) {
this(TimeZone.getDefault(), locale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Construct a ChineseCalendar based on the current time
* with the given time zone with the given locale.
* @param zone the given time zone
* @param locale the given ulocale
* @stable ICU 3.2
*/
public ChineseCalendar(TimeZone zone, ULocale locale) {
super(zone, locale);
setTimeInMillis(System.currentTimeMillis());
}
//------------------------------------------------------------------
// Public constants
//------------------------------------------------------------------
/**
* Field indicating whether or not the current month is a leap month.
* Should have a value of 0 for non-leap months, and 1 for leap months.
* @stable ICU 2.8
*/
public static int IS_LEAP_MONTH = BASE_FIELD_COUNT;
/**
* Count of fields in this class.
*/
private static final int FIELD_COUNT = IS_LEAP_MONTH + 1;
//------------------------------------------------------------------
// Calendar framework
//------------------------------------------------------------------
/**
* Override Calendar to allocate our additional field.
* @stable ICU 2.8
*/
protected int[] handleCreateFields() {
return new int[FIELD_COUNT];
}
/**
* Array defining the limits of field values for this class. Field
* limits which are invariant with respect to calendar system and
* defined by Calendar are left blank.
*
* Notes:
*
* ERA 5000000 / 60 = 83333.
*
* MONTH There are 12 or 13 lunar months in a year. However, we always
* number them 0..11, with an intercalated, identically numbered leap
* month, when necessary.
*
* DAY_OF_YEAR In a non-leap year there are 353, 354, or 355 days. In
* a leap year there are 383, 384, or 385 days.
*
* WEEK_OF_YEAR The least maximum occurs if there are 353 days in the
* year, and the first 6 are the last week of the previous year. Then
* we have 49 full weeks and 4 days in the last week: 6 + 49*7 + 4 =
* 353. So the least maximum is 50. The maximum occurs if there are
* 385 days in the year, and WOY 1 extends 6 days into the prior year.
* Then there are 54 full weeks, and 6 days in the last week: 1 + 54*7
* + 6 = 385. The 6 days of the last week will fall into WOY 1 of the
* next year. Maximum is 55.
*
* WEEK_OF_MONTH In a 29 day month, if the first 7 days make up week 1
* that leaves 3 full weeks and 1 day at the end. The least maximum is
* thus 5. In a 30 days month, if the previous 6 days belong WOM 1 of
* this month, we have 4 full weeks and 1 days at the end (which
* technically will be WOM 1 of the next month, but will be reported by
* time->fields and hence by getActualMaximum as WOM 6 of this month).
* Maximum is 6.
*
* DAY_OF_WEEK_IN_MONTH In a 29 or 30 day month, there are 4 full weeks
* plus 1 or 2 days at the end, so the maximum is always 5.
*/
private static final int LIMITS[][] = {
// Minimum Greatest Least Maximum
// Minimum Maximum
{ 1, 1, 83333, 83333 }, // ERA
{ 1, 1, 60, 60 }, // YEAR
{ 0, 0, 11, 11 }, // MONTH
{ 1, 1, 50, 55 }, // WEEK_OF_YEAR
{/* */}, // WEEK_OF_MONTH
{ 1, 1, 29, 30 }, // DAY_OF_MONTH
{ 1, 1, 353, 385 }, // DAY_OF_YEAR
{/* */}, // DAY_OF_WEEK
{ -1, -1, 5, 5 }, // DAY_OF_WEEK_IN_MONTH
{/* */}, // AM_PM
{/* */}, // HOUR
{/* */}, // HOUR_OF_DAY
{/* */}, // MINUTE
{/* */}, // SECOND
{/* */}, // MILLISECOND
{/* */}, // ZONE_OFFSET
{/* */}, // DST_OFFSET
{ -5000000, -5000000, 5000000, 5000000 }, // YEAR_WOY
{/* */}, // DOW_LOCAL
{ -5000000, -5000000, 5000000, 5000000 }, // EXTENDED_YEAR
{/* */}, // JULIAN_DAY
{/* */}, // MILLISECONDS_IN_DAY
{ 0, 0, 1, 1 }, // IS_LEAP_MONTH
};
/**
* Override Calendar to return the limit value for the given field.
* @stable ICU 2.8
*/
protected int handleGetLimit(int field, int limitType) {
return LIMITS[field][limitType];
}
/**
* Implement abstract Calendar method to return the extended year
* defined by the current fields. This will use either the ERA and
* YEAR field as the cycle and year-of-cycle, or the EXTENDED_YEAR
* field as the continuous year count, depending on which is newer.
* @stable ICU 2.8
*/
protected int handleGetExtendedYear() {
int year;
if (newestStamp(ERA, YEAR, UNSET) <= getStamp(EXTENDED_YEAR)) {
year = internalGet(EXTENDED_YEAR, 1); // Default to year 1
} else {
int cycle = internalGet(ERA, 1) - 1; // 0-based cycle
year = cycle * 60 + internalGet(YEAR, 1);
}
return year;
}
/**
* Override Calendar method to return the number of days in the given
* extended year and month.
*
* Note: This method also reads the IS_LEAP_MONTH field to determine
* whether or not the given month is a leap month.
* @stable ICU 2.8
*/
protected int handleGetMonthLength(int extendedYear, int month) {
int thisStart = handleComputeMonthStart(extendedYear, month, true) -
EPOCH_JULIAN_DAY + 1; // Julian day -> local days
int nextStart = newMoonNear(thisStart + SYNODIC_GAP, true);
return nextStart - thisStart;
}
/**
* Framework method to create a calendar-specific DateFormat object
* using the the given pattern. This method is responsible for
* creating the calendar- specific DateFormat and DateFormatSymbols
* objects as needed.
* @stable ICU 2.8
*/
protected DateFormat handleGetDateFormat(String pattern, String override, ULocale locale) {
return new ChineseDateFormat(pattern, override, locale);
}
/**
* Field resolution table that incorporates IS_LEAP_MONTH.
*/
static final int[][][] CHINESE_DATE_PRECEDENCE = {
{
{ DAY_OF_MONTH },
{ WEEK_OF_YEAR, DAY_OF_WEEK },
{ WEEK_OF_MONTH, DAY_OF_WEEK },
{ DAY_OF_WEEK_IN_MONTH, DAY_OF_WEEK },
{ WEEK_OF_YEAR, DOW_LOCAL },
{ WEEK_OF_MONTH, DOW_LOCAL },
{ DAY_OF_WEEK_IN_MONTH, DOW_LOCAL },
{ DAY_OF_YEAR },
{ RESOLVE_REMAP | DAY_OF_MONTH, IS_LEAP_MONTH },
},
{
{ WEEK_OF_YEAR },
{ WEEK_OF_MONTH },
{ DAY_OF_WEEK_IN_MONTH },
{ RESOLVE_REMAP | DAY_OF_WEEK_IN_MONTH, DAY_OF_WEEK },
{ RESOLVE_REMAP | DAY_OF_WEEK_IN_MONTH, DOW_LOCAL },
},
};
/**
* Override Calendar to add IS_LEAP_MONTH to the field resolution
* table.
* @stable ICU 2.8
*/
protected int[][][] getFieldResolutionTable() {
return CHINESE_DATE_PRECEDENCE;
}
/**
* Adjust this calendar to be delta months before or after a given
* start position, pinning the day of month if necessary. The start
* position is given as a local days number for the start of the month
* and a day-of-month. Used by add() and roll().
* @param newMoon the local days of the first day of the month of the
* start position (days after January 1, 1970 0:00 Asia/Shanghai)
* @param dom the 1-based day-of-month of the start position
* @param delta the number of months to move forward or backward from
* the start position
*/
private void offsetMonth(int newMoon, int dom, int delta) {
// Move to the middle of the month before our target month.
newMoon += (int) (CalendarAstronomer.SYNODIC_MONTH * (delta - 0.5));
// Search forward to the target month's new moon
newMoon = newMoonNear(newMoon, true);
// Find the target dom
int jd = newMoon + EPOCH_JULIAN_DAY - 1 + dom;
// Pin the dom. In this calendar all months are 29 or 30 days
// so pinning just means handling dom 30.
if (dom > 29) {
set(JULIAN_DAY, jd-1);
// TODO Fix this. We really shouldn't ever have to
// explicitly call complete(). This is either a bug in
// this method, in ChineseCalendar, or in
// Calendar.getActualMaximum(). I suspect the last.
complete();
if (getActualMaximum(DAY_OF_MONTH) >= dom) {
set(JULIAN_DAY, jd);
}
} else {
set(JULIAN_DAY, jd);
}
}
/**
* Override Calendar to handle leap months properly.
* @stable ICU 2.8
*/
public void add(int field, int amount) {
switch (field) {
case MONTH:
if (amount != 0) {
int dom = get(DAY_OF_MONTH);
int day = get(JULIAN_DAY) - EPOCH_JULIAN_DAY; // Get local day
int moon = day - dom + 1; // New moon
offsetMonth(moon, dom, amount);
}
break;
default:
super.add(field, amount);
break;
}
}
/**
* Override Calendar to handle leap months properly.
* @stable ICU 2.8
*/
public void roll(int field, int amount) {
switch (field) {
case MONTH:
if (amount != 0) {
int dom = get(DAY_OF_MONTH);
int day = get(JULIAN_DAY) - EPOCH_JULIAN_DAY; // Get local day
int moon = day - dom + 1; // New moon (start of this month)
// Note throughout the following: Months 12 and 1 are never
// followed by a leap month (D&R p. 185).
// Compute the adjusted month number m. This is zero-based
// value from 0..11 in a non-leap year, and from 0..12 in a
// leap year.
int m = get(MONTH); // 0-based month
if (isLeapYear) { // (member variable)
if (get(IS_LEAP_MONTH) == 1) {
++m;
} else {
// Check for a prior leap month. (In the
// following, month 0 is the first month of the
// year.) Month 0 is never followed by a leap
// month, and we know month m is not a leap month.
// moon1 will be the start of month 0 if there is
// no leap month between month 0 and month m;
// otherwise it will be the start of month 1.
int moon1 = moon -
(int) (CalendarAstronomer.SYNODIC_MONTH * (m - 0.5));
moon1 = newMoonNear(moon1, true);
if (isLeapMonthBetween(moon1, moon)) {
++m;
}
}
}
// Now do the standard roll computation on m, with the
// allowed range of 0..n-1, where n is 12 or 13.
int n = isLeapYear ? 13 : 12; // Months in this year
int newM = (m + amount) % n;
if (newM < 0) {
newM += n;
}
if (newM != m) {
offsetMonth(moon, dom, newM - m);
}
}
break;
default:
super.roll(field, amount);
break;
}
}
//------------------------------------------------------------------
// Support methods and constants
//------------------------------------------------------------------
/**
* The start year of the Chinese calendar, the 61st year of the reign
* of Huang Di. Some sources use the first year of his reign,
* resulting in EXTENDED_YEAR values 60 years greater and ERA (cycle)
* values one greater.
*/
private static final int CHINESE_EPOCH_YEAR = -2636; // Gregorian year
/**
* The offset from GMT in milliseconds at which we perform astronomical
* computations. Some sources use a different historically accurate
* offset of GMT+7:45:40 for years before 1929; we do not do this.
*/
private static final long CHINA_OFFSET = 8*ONE_HOUR;
/**
* Value to be added or subtracted from the local days of a new moon to
* get close to the next or prior new moon, but not cross it. Must be
* >= 1 and < CalendarAstronomer.SYNODIC_MONTH.
*/
private static final int SYNODIC_GAP = 25;
/**
* Convert local days to UTC epoch milliseconds.
* @param days days after January 1, 1970 0:00 Asia/Shanghai
* @return milliseconds after January 1, 1970 0:00 GMT
*/
private static final long daysToMillis(int days) {
return (days * ONE_DAY) - CHINA_OFFSET;
}
/**
* Convert UTC epoch milliseconds to local days.
* @param millis milliseconds after January 1, 1970 0:00 GMT
* @return days after January 1, 1970 0:00 Asia/Shanghai
*/
private static final int millisToDays(long millis) {
return (int) floorDivide(millis + CHINA_OFFSET, ONE_DAY);
}
//------------------------------------------------------------------
// Astronomical computations
//------------------------------------------------------------------
/**
* Return the major solar term on or after December 15 of the given
* Gregorian year, that is, the winter solstice of the given year.
* Computations are relative to Asia/Shanghai time zone.
* @param gyear a Gregorian year
* @return days after January 1, 1970 0:00 Asia/Shanghai of the
* winter solstice of the given year
*/
private int winterSolstice(int gyear) {
long cacheValue = winterSolsticeCache.get(gyear);
if (cacheValue == CalendarCache.EMPTY) {
// In books December 15 is used, but it fails for some years
// using our algorithms, e.g.: 1298 1391 1492 1553 1560. That
// is, winterSolstice(1298) starts search at Dec 14 08:00:00
// PST 1298 with a final result of Dec 14 10:31:59 PST 1299.
long ms = daysToMillis(computeGregorianMonthStart(gyear, DECEMBER) +
1 - EPOCH_JULIAN_DAY);
astro.setTime(ms);
// Winter solstice is 270 degrees solar longitude aka Dongzhi
long solarLong = astro.getSunTime(CalendarAstronomer.WINTER_SOLSTICE,
true);
cacheValue = millisToDays(solarLong);
winterSolsticeCache.put(gyear, cacheValue);
}
return (int) cacheValue;
}
/**
* Return the closest new moon to the given date, searching either
* forward or backward in time.
* @param days days after January 1, 1970 0:00 Asia/Shanghai
* @param after if true, search for a new moon on or after the given
* date; otherwise, search for a new moon before it
* @return days after January 1, 1970 0:00 Asia/Shanghai of the nearest
* new moon after or before days
*/
private int newMoonNear(int days, boolean after) {
astro.setTime(daysToMillis(days));
long newMoon = astro.getMoonTime(CalendarAstronomer.NEW_MOON, after);
return millisToDays(newMoon);
}
/**
* Return the nearest integer number of synodic months between
* two dates.
* @param day1 days after January 1, 1970 0:00 Asia/Shanghai
* @param day2 days after January 1, 1970 0:00 Asia/Shanghai
* @return the nearest integer number of months between day1 and day2
*/
private int synodicMonthsBetween(int day1, int day2) {
return (int) Math.round((day2 - day1) / CalendarAstronomer.SYNODIC_MONTH);
}
/**
* Return the major solar term on or before a given date. This
* will be an integer from 1..12, with 1 corresponding to 330 degrees,
* 2 to 0 degrees, 3 to 30 degrees,..., and 12 to 300 degrees.
* @param days days after January 1, 1970 0:00 Asia/Shanghai
*/
private int majorSolarTerm(int days) {
astro.setTime(daysToMillis(days));
// Compute (floor(solarLongitude / (pi/6)) + 2) % 12
int term = ((int) Math.floor(6 * astro.getSunLongitude() / Math.PI) + 2) % 12;
if (term < 1) {
term += 12;
}
return term;
}
/**
* Return true if the given month lacks a major solar term.
* @param newMoon days after January 1, 1970 0:00 Asia/Shanghai of a new
* moon
*/
private boolean hasNoMajorSolarTerm(int newMoon) {
int mst = majorSolarTerm(newMoon);
int nmn = newMoonNear(newMoon + SYNODIC_GAP, true);
int mstt = majorSolarTerm(nmn);
return mst == mstt;
/*
return majorSolarTerm(newMoon) ==
majorSolarTerm(newMoonNear(newMoon + SYNODIC_GAP, true));
*/
}
//------------------------------------------------------------------
// Time to fields
//------------------------------------------------------------------
/**
* Return true if there is a leap month on or after month newMoon1 and
* at or before month newMoon2.
* @param newMoon1 days after January 1, 1970 0:00 Asia/Shanghai of a
* new moon
* @param newMoon2 days after January 1, 1970 0:00 Asia/Shanghai of a
* new moon
*/
private boolean isLeapMonthBetween(int newMoon1, int newMoon2) {
// This is only needed to debug the timeOfAngle divergence bug.
// Remove this later. Liu 11/9/00
// DEBUG
if (synodicMonthsBetween(newMoon1, newMoon2) >= 50) {
throw new IllegalArgumentException("isLeapMonthBetween(" + newMoon1 +
", " + newMoon2 +
"): Invalid parameters");
}
return (newMoon2 >= newMoon1) &&
(isLeapMonthBetween(newMoon1, newMoonNear(newMoon2 - SYNODIC_GAP, false)) ||
hasNoMajorSolarTerm(newMoon2));
}
/**
* Override Calendar to compute several fields specific to the Chinese
* calendar system. These are:
*
*
Compute the ChineseCalendar-specific field IS_LEAP_MONTH.
* @stable ICU 2.8
*/
protected void handleComputeFields(int julianDay) {
computeChineseFields(julianDay - EPOCH_JULIAN_DAY, // local days
getGregorianYear(), getGregorianMonth(),
true); // set all fields
}
/**
* Compute fields for the Chinese calendar system. This method can
* either set all relevant fields, as required by
* handleComputeFields(), or it can just set the MONTH and
* IS_LEAP_MONTH fields, as required by
* handleComputeMonthStart().
*
*
As a side effect, this method sets {@link #isLeapYear}. * @param days days after January 1, 1970 0:00 Asia/Shanghai of the * date to compute fields for * @param gyear the Gregorian year of the given date * @param gmonth the Gregorian month of the given date * @param setAllFields if true, set the EXTENDED_YEAR, ERA, YEAR, * DAY_OF_MONTH, and DAY_OF_YEAR fields. In either case set the MONTH * and IS_LEAP_MONTH fields. */ private void computeChineseFields(int days, int gyear, int gmonth, boolean setAllFields) { // Find the winter solstices before and after the target date. // These define the boundaries of this Chinese year, specifically, // the position of month 11, which always contains the solstice. // We want solsticeBefore <= date < solsticeAfter. int solsticeBefore; int solsticeAfter = winterSolstice(gyear); if (days < solsticeAfter) { solsticeBefore = winterSolstice(gyear - 1); } else { solsticeBefore = solsticeAfter; solsticeAfter = winterSolstice(gyear + 1); } // Find the start of the month after month 11. This will be either // the prior month 12 or leap month 11 (very rare). Also find the // start of the following month 11. int firstMoon = newMoonNear(solsticeBefore + 1, true); int lastMoon = newMoonNear(solsticeAfter + 1, false); int thisMoon = newMoonNear(days + 1, false); // Start of this month // Note: isLeapYear is a member variable isLeapYear = synodicMonthsBetween(firstMoon, lastMoon) == 12; int month = synodicMonthsBetween(firstMoon, thisMoon); if (isLeapYear && isLeapMonthBetween(firstMoon, thisMoon)) { month--; } if (month < 1) { month += 12; } boolean isLeapMonth = isLeapYear && hasNoMajorSolarTerm(thisMoon) && !isLeapMonthBetween(firstMoon, newMoonNear(thisMoon - SYNODIC_GAP, false)); internalSet(MONTH, month-1); // Convert from 1-based to 0-based internalSet(IS_LEAP_MONTH, isLeapMonth?1:0); if (setAllFields) { int year = gyear - CHINESE_EPOCH_YEAR; if (month < 11 || gmonth >= JULY) { year++; } int dayOfMonth = days - thisMoon + 1; internalSet(EXTENDED_YEAR, year); // 0->0,60 1->1,1 60->1,60 61->2,1 etc. int[] yearOfCycle = new int[1]; int cycle = floorDivide(year-1, 60, yearOfCycle); internalSet(ERA, cycle+1); internalSet(YEAR, yearOfCycle[0]+1); internalSet(DAY_OF_MONTH, dayOfMonth); // Days will be before the first new year we compute if this // date is in month 11, leap 11, 12. There is never a leap 12. // New year computations are cached so this should be cheap in // the long run. int newYear = newYear(gyear); if (days < newYear) { newYear = newYear(gyear-1); } internalSet(DAY_OF_YEAR, days - newYear + 1); } } //------------------------------------------------------------------ // Fields to time //------------------------------------------------------------------ /** * Return the Chinese new year of the given Gregorian year. * @param gyear a Gregorian year * @return days after January 1, 1970 0:00 Asia/Shanghai of the * Chinese new year of the given year (this will be a new moon) */ private int newYear(int gyear) { long cacheValue = newYearCache.get(gyear); if (cacheValue == CalendarCache.EMPTY) { int solsticeBefore= winterSolstice(gyear - 1); int solsticeAfter = winterSolstice(gyear); int newMoon1 = newMoonNear(solsticeBefore + 1, true); int newMoon2 = newMoonNear(newMoon1 + SYNODIC_GAP, true); int newMoon11 = newMoonNear(solsticeAfter + 1, false); if (synodicMonthsBetween(newMoon1, newMoon11) == 12 && (hasNoMajorSolarTerm(newMoon1) || hasNoMajorSolarTerm(newMoon2))) { cacheValue = newMoonNear(newMoon2 + SYNODIC_GAP, true); } else { cacheValue = newMoon2; } newYearCache.put(gyear, cacheValue); } return (int) cacheValue; } /** * Return the Julian day number of day before the first day of the * given month in the given extended year. * *
Note: This method reads the IS_LEAP_MONTH field to determine
* whether the given month is a leap month.
* @param eyear the extended year
* @param month the zero-based month. The month is also determined
* by reading the IS_LEAP_MONTH field.
* @return the Julian day number of the day before the first
* day of the given month and year
* @stable ICU 2.8
*/
protected int handleComputeMonthStart(int eyear, int month, boolean useMonth) {
// If the month is out of range, adjust it into range, and
// modify the extended year value accordingly.
if (month < 0 || month > 11) {
int[] rem = new int[1];
eyear += floorDivide(month, 12, rem);
month = rem[0];
}
int gyear = eyear + CHINESE_EPOCH_YEAR - 1; // Gregorian year
int newYear = newYear(gyear);
int newMoon = newMoonNear(newYear + month * 29, true);
int julianDay = newMoon + EPOCH_JULIAN_DAY;
// Save fields for later restoration
int saveMonth = internalGet(MONTH);
int saveIsLeapMonth = internalGet(IS_LEAP_MONTH);
// Ignore IS_LEAP_MONTH field if useMonth is false
int isLeapMonth = useMonth ? saveIsLeapMonth : 0;
computeGregorianFields(julianDay);
// This will modify the MONTH and IS_LEAP_MONTH fields (only)
computeChineseFields(newMoon, getGregorianYear(),
getGregorianMonth(), false);
if (month != internalGet(MONTH) ||
isLeapMonth != internalGet(IS_LEAP_MONTH)) {
newMoon = newMoonNear(newMoon + SYNODIC_GAP, true);
julianDay = newMoon + EPOCH_JULIAN_DAY;
}
internalSet(MONTH, saveMonth);
internalSet(IS_LEAP_MONTH, saveIsLeapMonth);
return julianDay - 1;
}
/**
* Return the current Calendar type.
* @return type of calendar
* @stable ICU 3.8
*/
public String getType() {
return "chinese";
}
/**
* Override readObject.
*/
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException
{
stream.defaultReadObject();
/* set up the transient caches... */
astro = new CalendarAstronomer();
winterSolsticeCache = new CalendarCache();
newYearCache = new CalendarCache();
}
/*
private static CalendarFactory factory;
public static CalendarFactory factory() {
if (factory == null) {
factory = new CalendarFactory() {
public Calendar create(TimeZone tz, ULocale loc) {
return new ChineseCalendar(tz, loc);
}
public String factoryName() {
return "Chinese";
}
};
}
return factory;
}
*/
}
icu4j-4.2.1.1/src/com/ibm/icu/util/OverlayBundle.java 0000644 0001750 0001750 00000014300 10666355147 022133 0 ustar twerner twerner /**
*******************************************************************************
* Copyright (C) 2001-2004, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.*;
/**
* A ResourceBundle that overlays one hierarchy atop another. This is
* best explained by example. Suppose one wants to use the
* resource hiararchy (in JDK 1.2 and 1.3, but not 1.4) at
* "java.text.resources.LocaleElements", but one wants to use
* a modified version of the "NumberPatterns" resource in the
* fr_FR locale. One way to do this is to add special case code
* to the lookup operation to check for fr_FR and the key
* "NumberPatterns", and in that case, load up custom data. However,
* this becomes unwieldy and places some information about the
* effective resource hierarchy into the code.
*
* The OverlayBundle solves this problem by layering another
* hierarchy, e.g, "com.acme.resources.LocaleElements", on top of a
* base hierarchy. When a resource is requested, it is first sought
* in the overlay hierarchy, and if not found there, it is sought in
* the base hierarchy. Multiple overlays are supported, but in
* practice one is usually sufficient.
*
* The OverlayBundle also addresses the problem of country-oriented
* data. To specify the default data for a language, one just sets
* the language resource bundle data. However, specifying the default
* data for a country using the standard ResourceBundle mechanism is
* impossible. The OverlayBundle recognizes "wildcard" locales with
* the special language code "xx". When looking up data for a locale
* with a non-empty country, if an exact locale match cannot be found,
* the OverlayBundle looks for data in the locale xx_YY, where YY is
* the country being sought. This effectively adds another entry in
* the fallback sequence for a locale aa_BB: aa_BB, xx_BB, aa, root.
* Wildcard locales are not implemented for the base hierarchy, only
* for overlays.
*
* The OverlayBundle is implemented as an array of n ResourceBundle
* base names. The base names are searched from 0 to n-1. Base name
* n-1 is special; it is the base hierarchy. This should be a
* well-populated hierarchy with most of the default data, typically,
* the icu or sun core hierarchies. The base hierarchy is
* treated differently from the overlays above it. It does not get
* wildcard resolution, and the getKeys() framework method is
* delegated to the base hierarchy bundle.
*
* Usage: Instantiate an OverlayBundle directly (not via a factory
* method as in ResourceBundle). Instead of specifying a single base
* name, pass it an array of 2 or more base names. After that, use it
* exactly as you would use ResourceBundle.
*
* @see java.util.ResourceBundle
* @author Alan Liu
* @internal
* @deprecated ICU 2.4. This class may be removed or modified.
*/
// prepare to deprecate in next release
///CLOVER:OFF
public class OverlayBundle extends ResourceBundle {
/**
* The array of base names, with the length-1 entry being the base
* hierarchy, typically "sun.text.resources.LocaleElements".
*/
private String[] baseNames;
/**
* The requested locale.
*/
private Locale locale;
/**
* Loaded bundles. These will be null until they are loaded on
* demand.
*/
private ResourceBundle[] bundles;
/**
* Construct an overlay bundle given a sequence of base names and
* a locale.
* @internal
* @deprecated ICU 2.4. This class may be removed or modified.
*/
public OverlayBundle(String[] baseNames,
Locale locale) {
this.baseNames = baseNames;
this.locale = locale;
bundles = new ResourceBundle[baseNames.length];
}
/**
* ResourceBundle framework method. Delegates to
* bundles[i].getObject().
* @internal
* @deprecated ICU 2.4. This class may be removed or modified.
*/
protected Object handleGetObject(String key)
throws MissingResourceException {
Object o = null;
for (int i=0; i Immutable.
* @see TimeUnitAmount
* @see com.ibm.icu.text.TimeUnitFormat
* @author markdavis
* @stable ICU 4.0
*/
public class TimeUnitAmount extends Measure {
/**
* Create from a number and unit.
* @stable ICU 4.0
*/
public TimeUnitAmount(Number number, TimeUnit unit) {
super(number, unit);
}
/**
* Create from a number and unit.
* @stable ICU 4.0
*/
public TimeUnitAmount(double number, TimeUnit unit) {
super(new Double(number), unit);
}
/**
* Get the unit (convenience to avoid cast).
* @stable ICU 4.0
*/
public TimeUnit getTimeUnit() {
return (TimeUnit) getUnit();
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/UResourceBundle.java 0000644 0001750 0001750 00000111515 11135716003 022414 0 ustar twerner twerner //##header
/*
*******************************************************************************
* Copyright (C) 2004-2009, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.lang.ref.SoftReference;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.Vector;
import com.ibm.icu.impl.ICUCache;
import com.ibm.icu.impl.ICUResourceBundle;
import com.ibm.icu.impl.ICUResourceBundleReader;
import com.ibm.icu.impl.ResourceBundleWrapper;
import com.ibm.icu.impl.SimpleCache;
import com.ibm.icu.util.ULocale;
//#if defined(FOUNDATION10) || defined(J2SE13) || defined(ECLIPSE_FRAGMENT)
//##import com.ibm.icu.impl.ByteBuffer;
//#else
import java.nio.ByteBuffer;
//#endif
/**
* A class representing a collection of resource information pertaining to a given
* locale. A resource bundle provides a way of accessing locale- specific information in
* a data file. You create a resource bundle that manages the resources for a given
* locale and then ask it for individual resources.
*
* In ResourceBundle class, an object is created
* and the sub items are fetched using getString, getObject methods.
* In UResourceBundle,each individual element of a resource is a resource by itself.
*
*
* Resource bundles in ICU are currently defined using text files which conform to the following
* BNF definition.
* More on resource bundle concepts and syntax can be found in the
* Users Guide.
*
*
* The packaging of ICU *.res files can be of two types
* ICU4C:
*
* Typically, you get a
* You can also get a
* For compatibility with JDK 1.1.x, some other three-letter time zone IDs
* (such as "PST", "CTT", "AST") are also supported. However, their
* use is deprecated because the same abbreviation is often used
* for multiple time zones (for example, "CST" could be U.S. "Central Standard
* Time" and "China Standard Time"), and the Java platform can then only
* recognize one of them.
*
* Note: Starting from ICU4J 4.0, you can optionally choose
* JDK This property is included in ICUConfig.properties in com.ibm.icu package.
* When
* The default implementation always returns 3600000 milliseconds
* (i.e., one hour) if this time zone observes Daylight Saving
* Time. Otherwise, 0 (zero) is returned.
*
* If an underlying TimeZone implementation subclass supports
* historical Daylight Saving Time changes, this method returns
* the known latest daylight saving value.
*
* @return the amount of saving time in milliseconds
* @stable ICU 2.8
*/
public int getDSTSavings() {
if (useDaylightTime()) {
return 3600000;
}
return 0;
}
/**
* Queries if this time zone uses daylight savings time.
* @return true if this time zone uses daylight savings time,
* false, otherwise.
* @stable ICU 2.0
*/
abstract public boolean useDaylightTime();
/**
* Queries if the given date is in daylight savings time in
* this time zone.
* @param date the given Date.
* @return true if the given date is in daylight savings time,
* false, otherwise.
* @stable ICU 2.0
*/
abstract public boolean inDaylightTime(Date date);
/**
* Gets the The returned count includes the given ID; it is always >= 1
* for valid IDs. The given ID must be a system time zone. If it
* is not, returns zero.
* @param id a system time zone ID
* @return the number of zones in the equivalency group containing
* 'id', or zero if 'id' is not a valid system ID
* @see #getEquivalentID
* @stable ICU 2.0
*/
public static int countEquivalentIDs(String id) {
return ZoneMeta.countEquivalentIDs(id);
}
/**
* Returns an ID in the equivalency group that
* includes the given ID. An equivalency group contains zones
* that have the same GMT offset and rules.
*
* The given index must be in the range 0..n-1, where n is the
* value returned by Class for enabling iteration over UResourceBundle objects.
* Example of use:
* There are often times when you need objects to be objects 'safe', so that
* they can't be modified. Examples are when objects need to be thread-safe, or
* in writing robust code, or in caches. If you are only creating your own
* objects, you can guarantee this, of course -- but only if you don't make a
* mistake. If you have objects handed into you, or are creating objects using
* others handed into you, it is a different story. It all comes down to whether
* you want to take the Blanche Dubois approach ("depend on the kindness of
* strangers") or the Andy Grove approach ("Only the Paranoid
* Survive").
*
* For example, suppose we have a simple class:
*
* Since the class doesn't have any setters, someone might think that it is
* immutable. You know where this is leading, of course; this class is unsafe in
* a number of ways. The following illustrates that.
*
* There are a few different techniques for having safe classes.
*
* There are advantages and disadvantages of each of these.
*
* The
* Here is what needs to be done to implement this interface, depending on the
* type of the object.
*
* These are the easiest. You just use the interface to reflect that, by adding
* the following:
*
* These can be final methods because subclasses of immutable objects must
* themselves be immutable. (Note:
* Add a protected 'flagging' field:
*
* Add the following methods:
*
* Add a
* Then take the setters (that is, any method that can change the internal state
* of the object), and add the following as the first statement:
*
* Any subclass of a
* Internal caches are cases where the object is logically unmodified, but
* internal state of the object changes. For example, there are const C++
* functions that cast away the const on the "this" pointer in order
* to modify an object cache. These cases are handled by mutexing the internal
* cache to ensure thread-safety. For example, suppose that UnicodeSet had an
* internal marker to the last code point accessed. In this case, the field is
* not externally visible, so the only thing you need to do is to synchronize
* the field for thread safety.
*
* Internal fields are called safe if they are either
*
* These also illustrated in the code sample in Background above.
*
* To deal with unsafe internals, the simplest course of action is to do the
* work in the
* If the field is a
* If you have ever allowed access, then do a
* If a collection (or any other container of objects) itself can
* contain mutable objects, then for a safe clone you need to recurse through it
* to make the entire collection immutable. The recursing code should pick the
* most specific collection available, to avoid the necessity of later
* downcasing.
*
* Note: An annoying flaw in Java is that the generic collections, like
* Note: This class is similar, but not identical, to the class
*
* Subclasses of
* Like other locale-sensitive classes, When a A When a When setting or getting the When computing a
* Insufficient information. The calendar will use default
* information to specify the missing fields. This may vary by calendar; for
* the Gregorian calendar, the default for a field is the same as that of the
* start of the epoch: i.e., YEAR = 1970, MONTH = JANUARY, DATE = 1, etc.
*
*
* Inconsistent information. If fields conflict, the calendar
* will give preference to fields set more recently. For example, when
* determining the day, the calendar will look for one of the following
* combinations of fields. The most recent combination, as determined by the
* most recently set single field, will be used.
*
*
* Note: for some non-Gregorian calendars, different
* fields may be necessary for complete disambiguation. For example, a full
* specification of the historial Arabic astronomical calendar requires year,
* month, day-of-month and day-of-week in some cases.
*
*
* Note: There are certain possible ambiguities in
* interpretation of certain singular times, which are resolved in the
* following ways:
*
* The date or time format strings are not part of the definition of a
* calendar, as those must be modifiable or overridable by the user at
* runtime. Use {@link DateFormat}
* to format dates.
*
* Field manipulation methods Example: Consider a Add rule 1. The value of field Add rule 2. If a smaller field is expected to be
* invariant, but it is impossible for it to be equal to its
* prior value because of changes in its minimum or maximum after field
* In addition, unlike Example: Consider a Roll rule. Larger fields are unchanged after the
* call. A larger field represents a larger unit of
* time. Example: Consider a Example: Consider a Usage model. To motivate the behavior of
* Note: You should always use {@link #roll roll} and {@link #add add} rather
* than attempting to perform arithmetic operations directly on the fields
* of a Calendar. It is quite possible for Calendar subclasses
* to have fields with non-linear behavior, for example missing months
* or days during non-leap years. The subclasses' add and roll
* methods will take this into account, while simple arithmetic manipulations
* may give invalid results.
*
* Calendar Architecture in ICU4J Recently the implementation of Changes Overview of changes between the classic Subclass API The original More functionality has been moved into the base class. The base
* class now contains much of the computational machinery to support the
* Gregorian calendar. This is based on two things: (1) Many calendars
* are based on the Gregorian calendar (such as the Buddhist and Japanese
* imperial calendars). (2) All calendars require basic
* Gregorian support in order to handle timezone computations. Common computations have been moved into
* Subclass computation of time => fields
*
* The {@link #ERA}, {@link #YEAR},
* {@link #EXTENDED_YEAR}, {@link #MONTH},
* {@link #DAY_OF_MONTH}, and {@link #DAY_OF_YEAR} fields are
* computed by the subclass, based on the Julian day. All other fields
* are computed by Subclass computation of fields => time
*
* The interpretation of most field values is handled entirely by
* Other methods
*
* Normalized behavior
*
* The behavior of certain fields has been made consistent across all
* calendar systems and implemented in Supported range
*
* The allowable range of General notes
*
* The actual maximum computation ignores smaller fields and the
* current value of like-sized fields. For example, the actual maximum
* of the DAY_OF_YEAR or MONTH depends only on the year and supra-year
* fields. The actual maximum of the DAY_OF_MONTH depends, in
* addition, on the MONTH field and any other fields at that
* granularity (such as ChineseCalendar.IS_LEAP_MONTH). The
* DAY_OF_WEEK_IN_MONTH field does not depend on the current
* DAY_OF_WEEK; it returns the maximum for any day of week in the
* current month. Likewise for the WEEK_OF_MONTH and WEEK_OF_YEAR
* fields.
*
* @param field the field whose maximum is desired
* @return the maximum of the given field for the current date of this calendar
* @see #getMaximum
* @see #getLeastMaximum
* @stable ICU 2.0
*/
public int getActualMaximum(int field) {
int result;
switch (field) {
case DAY_OF_MONTH:
{
Calendar cal = (Calendar) clone();
cal.prepareGetActual(field, false);
result = handleGetMonthLength(cal.get(EXTENDED_YEAR), cal.get(MONTH));
}
break;
case DAY_OF_YEAR:
{
Calendar cal = (Calendar) clone();
cal.prepareGetActual(field, false);
result = handleGetYearLength(cal.get(EXTENDED_YEAR));
}
break;
case ERA:
case DAY_OF_WEEK:
case AM_PM:
case HOUR:
case HOUR_OF_DAY:
case MINUTE:
case SECOND:
case MILLISECOND:
case ZONE_OFFSET:
case DST_OFFSET:
case DOW_LOCAL:
case JULIAN_DAY:
case MILLISECONDS_IN_DAY:
// These fields all have fixed minima/maxima
result = getMaximum(field);
break;
default:
// For all other fields, do it the hard way....
result = getActualHelper(field, getLeastMaximum(field), getMaximum(field));
break;
}
return result;
}
/**
* Return the minimum value that this field could have, given the current date.
* For most fields, this is the same as {@link #getMinimum getMinimum}
* and {@link #getGreatestMinimum getGreatestMinimum}. However, some fields,
* especially those related to week number, are more complicated.
*
* For example, assume {@link #getMinimalDaysInFirstWeek getMinimalDaysInFirstWeek}
* returns 4 and {@link #getFirstDayOfWeek getFirstDayOfWeek} returns SUNDAY.
* If the first day of the month is Sunday, Monday, Tuesday, or Wednesday
* there will be four or more days in the first week, so it will be week number 1,
* and
* @param field the field whose actual minimum value is desired.
* @return the minimum of the given field for the current date of this calendar
*
* @see #getMinimum
* @see #getGreatestMinimum
* @stable ICU 2.0
*/
public int getActualMinimum(int field) {
int result;
switch (field) {
case DAY_OF_WEEK:
case AM_PM:
case HOUR:
case HOUR_OF_DAY:
case MINUTE:
case SECOND:
case MILLISECOND:
case ZONE_OFFSET:
case DST_OFFSET:
case DOW_LOCAL:
case JULIAN_DAY:
case MILLISECONDS_IN_DAY:
// These fields all have fixed minima/maxima
result = getMinimum(field);
break;
default:
// For all other fields, do it the hard way....
result = getActualHelper(field, getGreatestMinimum(field), getMinimum(field));
break;
}
return result;
}
/**
* Prepare this calendar for computing the actual minimum or maximum.
* This method modifies this calendar's fields; it is called on a
* temporary calendar.
*
* Rationale: The semantics of getActualXxx() is to return the
* maximum or minimum value that the given field can take, taking into
* account other relevant fields. In general these other fields are
* larger fields. For example, when computing the actual maximum
* DAY_OF_MONTH, the current value of DAY_OF_MONTH itself is ignored,
* as is the value of any field smaller.
*
* The time fields all have fixed minima and maxima, so we don't
* need to worry about them. This also lets us set the
* MILLISECONDS_IN_DAY to zero to erase any effects the time fields
* might have when computing date fields.
*
* DAY_OF_WEEK is adjusted specially for the WEEK_OF_MONTH and
* WEEK_OF_YEAR fields to ensure that they are computed correctly.
* @stable ICU 2.0
*/
protected void prepareGetActual(int field, boolean isMinimum) {
set(MILLISECONDS_IN_DAY, 0);
switch (field) {
case YEAR:
case EXTENDED_YEAR:
set(DAY_OF_YEAR, getGreatestMinimum(DAY_OF_YEAR));
break;
case YEAR_WOY:
set(WEEK_OF_YEAR, getGreatestMinimum(WEEK_OF_YEAR));
break;
case MONTH:
set(DAY_OF_MONTH, getGreatestMinimum(DAY_OF_MONTH));
break;
case DAY_OF_WEEK_IN_MONTH:
// For dowim, the maximum occurs for the DOW of the first of the
// month.
set(DAY_OF_MONTH, 1);
set(DAY_OF_WEEK, get(DAY_OF_WEEK)); // Make this user set
break;
case WEEK_OF_MONTH:
case WEEK_OF_YEAR:
// If we're counting weeks, set the day of the week to either the
// first or last localized DOW. We know the last week of a month
// or year will contain the first day of the week, and that the
// first week will contain the last DOW.
{
int dow = firstDayOfWeek;
if (isMinimum) {
dow = (dow + 6) % 7; // set to last DOW
if (dow < SUNDAY) {
dow += 7;
}
}
set(DAY_OF_WEEK, dow);
}
break;
}
// Do this last to give it the newest time stamp
set(field, getGreatestMinimum(field));
}
private int getActualHelper(int field, int startValue, int endValue) {
if (startValue == endValue) {
// if we know that the maximum value is always the same, just return it
return startValue;
}
final int delta = (endValue > startValue) ? 1 : -1;
// clone the calendar so we don't mess with the real one, and set it to
// accept anything for the field values
Calendar work = (Calendar) clone();
work.setLenient(true);
work.prepareGetActual(field, delta < 0);
// now try each value from the start to the end one by one until
// we get a value that normalizes to another value. The last value that
// normalizes to itself is the actual maximum for the current date
work.set(field, startValue);
// prepareGetActual sets the first day of week in the same week with
// the first day of a month. Unlike WEEK_OF_YEAR, week number for the
// which week contains days from both previous and current month is
// not unique. For example, last several days in the previous month
// is week 5, and the rest of week is week 1.
if (work.get(field) != startValue
&& field != WEEK_OF_MONTH && delta > 0) {
return startValue;
}
int result = startValue;
do {
startValue += delta;
work.add(field, delta);
if (work.get(field) != startValue) {
break;
}
result = startValue;
} while (startValue != endValue);
return result;
}
/**
* Rolls (up/down) a single unit of time on the given field. If the
* field is rolled past its maximum allowable value, it will "wrap" back
* to its minimum and continue rolling. For
* example, to roll the current date up by one day, you can call:
*
*
* When rolling on the {@link #YEAR} field, it will roll the year
* value in the range between 1 and the value returned by calling
* {@link #getMaximum getMaximum}({@link #YEAR}).
*
* When rolling on certain fields, the values of other fields may conflict and
* need to be changed. For example, when rolling the
* Note: Calling roll(field, true) N times is not
* necessarily equivalent to calling roll(field, N). For example,
* imagine that you start with the date Gregorian date January 31, 1995. If you call
* roll(Calendar.MONTH, 2), the result will be March 31, 1995.
* But if you call roll(Calendar.MONTH, true), the result will be
* February 28, 1995. Calling it one more time will give March 28, 1995, which
* is usually not the desired result.
*
* Note: You should always use roll and add rather
* than attempting to perform arithmetic operations directly on the fields
* of a Calendar. It is quite possible for Calendar subclasses
* to have fields with non-linear behavior, for example missing months
* or days during non-leap years. The subclasses' add and roll
* methods will take this into account, while simple arithmetic manipulations
* may give invalid results.
*
* @param field the calendar field to roll.
*
* @param up indicates if the value of the specified time field is to be
* rolled up or rolled down. Use
* When rolling on certain fields, the values of other fields may conflict and
* need to be changed. For example, when rolling the {@link #MONTH MONTH} field
* for the Gregorian date 1/31/96 by +1, the {@link #DAY_OF_MONTH DAY_OF_MONTH} field
* must be adjusted so that the result is 2/29/96 rather than the invalid
* 2/31/96.
*
* The
* Note: You should always use roll and add rather
* than attempting to perform arithmetic operations directly on the fields
* of a Calendar. It is quite possible for Calendar subclasses
* to have fields with non-linear behavior, for example missing months
* or days during non-leap years. The subclasses' add and roll
* methods will take this into account, while simple arithmetic manipulations
* may give invalid results.
*
* Subclassing:
* Subclasses that have fields for which the assumption of continuity breaks
* down must overide
* @param field the calendar field to roll.
* @param amount the amount by which the field should be rolled.
*
* @exception IllegalArgumentException if the field is invalid or refers
* to a field that cannot be handled by this method.
* @see #roll(int, boolean)
* @see #add
* @stable ICU 2.0
*/
public void roll(int field, int amount) {
if (amount == 0) {
return; // Nothing to do
}
complete();
switch (field) {
case DAY_OF_MONTH:
case AM_PM:
case MINUTE:
case SECOND:
case MILLISECOND:
case MILLISECONDS_IN_DAY:
case ERA:
// These are the standard roll instructions. These work for all
// simple cases, that is, cases in which the limits are fixed, such
// as the hour, the day of the month, and the era.
{
int min = getActualMinimum(field);
int max = getActualMaximum(field);
int gap = max - min + 1;
int value = internalGet(field) + amount;
value = (value - min) % gap;
if (value < 0) {
value += gap;
}
value += min;
set(field, value);
return;
}
case HOUR:
case HOUR_OF_DAY:
// Rolling the hour is difficult on the ONSET and CEASE days of
// daylight savings. For example, if the change occurs at
// 2 AM, we have the following progression:
// ONSET: 12 Std -> 1 Std -> 3 Dst -> 4 Dst
// CEASE: 12 Dst -> 1 Dst -> 1 Std -> 2 Std
// To get around this problem we don't use fields; we manipulate
// the time in millis directly.
{
// Assume min == 0 in calculations below
long start = getTimeInMillis();
int oldHour = internalGet(field);
int max = getMaximum(field);
int newHour = (oldHour + amount) % (max + 1);
if (newHour < 0) {
newHour += max + 1;
}
setTimeInMillis(start + ONE_HOUR * (newHour - oldHour));
return;
}
case MONTH:
// Rolling the month involves both pinning the final value
// 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.,
* When adding to certain fields, the values of other fields may conflict and
* need to be changed. For example, when adding one to the {@link #MONTH MONTH} field
* for the Gregorian date 1/31/96, the {@link #DAY_OF_MONTH DAY_OF_MONTH} field
* must be adjusted so that the result is 2/29/96 rather than the invalid
* 2/31/96.
*
* The
* Note: You should always use roll and add rather
* than attempting to perform arithmetic operations directly on the fields
* of a Calendar. It is quite possible for Calendar subclasses
* to have fields with non-linear behavior, for example missing months
* or days during non-leap years. The subclasses' add and roll
* methods will take this into account, while simple arithmetic manipulations
* may give invalid results.
*
* Subclassing:
* Subclasses that have fields for which this assumption of continuity breaks
* down must overide
* @param field the time field.
* @param amount the amount to add to the field.
*
* @exception IllegalArgumentException if the field is invalid or refers
* to a field that cannot be handled by this method.
* @see #roll(int, int)
* @stable ICU 2.0
*/
public void add(int field, int amount) {
if (amount == 0) {
return; // Do nothing!
}
// We handle most fields in the same way. The algorithm is to add
// a computed amount of millis to the current millis. The only
// wrinkle is with DST -- for some fields, like the DAY_OF_MONTH,
// we don't want the HOUR to shift due to changes in DST. If the
// result of the add operation is to move from DST to Standard, or
// vice versa, we need to adjust by an hour forward or back,
// respectively. For such fields we set keepHourInvariant to true.
// We only adjust the DST for fields larger than an hour. For
// fields smaller than an hour, we cannot adjust for DST without
// causing problems. for instance, if you add one hour to April 5,
// 1998, 1:00 AM, in PST, the time becomes "2:00 AM PDT" (an
// illegal value), but then the adjustment sees the change and
// compensates by subtracting an hour. As a result the time
// doesn't advance at all.
// For some fields larger than a day, such as a MONTH, we pin the
// DAY_OF_MONTH. This allows
* Subclassing:
*
* Note:
*
* @param field The calendar field whose value should be pinned.
*
* @see #getActualMinimum
* @see #getActualMaximum
* @stable ICU 2.0
*/
protected void pinField(int field) {
int max = getActualMaximum(field);
int min = getActualMinimum(field);
if (fields[field] > max) {
set(field, max);
} else if (fields[field] < min) {
set(field, min);
}
}
/**
* Return the week number of a day, within a period. This may be the week number in
* a year or the week number in a month. Usually this will be a value >= 1, but if
* some initial days of the period are excluded from week 1, because
* {@link #getMinimalDaysInFirstWeek getMinimalDaysInFirstWeek} is > 1, then
* the week number will be zero for those
* initial days. This method requires the day number and day of week for some
* known date in the period in order to determine the day of week
* on the desired day.
*
* Subclassing:
*
* This variant is handy for computing the week number of some other
* day of a period (often the first or last day of the period) when its day
* of the week is not known but the day number and day of week for some other
* day in the period (e.g. the current date) is known.
*
* @param desiredDay The {@link #DAY_OF_YEAR DAY_OF_YEAR} or
* {@link #DAY_OF_MONTH DAY_OF_MONTH} whose week number is desired.
* Should be 1 for the first day of the period.
*
* @param dayOfPeriod The {@link #DAY_OF_YEAR DAY_OF_YEAR}
* or {@link #DAY_OF_MONTH DAY_OF_MONTH} for a day in the period whose
* {@link #DAY_OF_WEEK DAY_OF_WEEK} is specified by the
*
* Subclassing:
*
* @param dayOfPeriod The {@link #DAY_OF_YEAR DAY_OF_YEAR} or
* {@link #DAY_OF_MONTH DAY_OF_MONTH} whose week number is desired.
* Should be 1 for the first day of the period.
*
* @param dayOfWeek The {@link #DAY_OF_WEEK DAY_OF_WEEK} for the day
* corresponding to the As a side effect of this call, this calendar is advanced
* toward Usage: To use this method, call it first with the largest
* field of interest, then with progressively smaller fields. For
* example:
*
* Note: The YEAR_WOY field is computed simplistically. It is equal to YEAR
* most of the time, but at the year boundary it may be adjusted to YEAR-1
* or YEAR+1 to reflect the overlap of a week into an adjacent year. In
* this case, a simple increment or decrement is performed on YEAR, even
* though this may yield an invalid YEAR value. For instance, if the YEAR
* is part of a calendar system with an N-year cycle field CYCLE, then
* incrementing the YEAR may involve incrementing CYCLE and setting YEAR
* back to 0 or 1. This is not handled by this code, and in fact cannot be
* simply handled without having subclasses define an entire parallel set of
* fields for fields larger than or equal to a year. This additional
* complexity is not warranted, since the intention of the YEAR_WOY field is
* to support ISO 8601 notation, so it will typically be used with a
* proleptic Gregorian calendar, which has no field larger than a year.
*/
private final void computeWeekFields() {
int eyear = fields[EXTENDED_YEAR];
int dayOfWeek = fields[DAY_OF_WEEK];
int dayOfYear = fields[DAY_OF_YEAR];
// WEEK_OF_YEAR start
// Compute the week of the year. For the Gregorian calendar, valid week
// numbers run from 1 to 52 or 53, depending on the year, the first day
// of the week, and the minimal days in the first week. For other
// calendars, the valid range may be different -- it depends on the year
// length. Days at the start of the year may fall into the last week of
// the previous year; days at the end of the year may fall into the
// first week of the next year. ASSUME that the year length is less than
// 7000 days.
int yearOfWeekOfYear = eyear;
int relDow = (dayOfWeek + 7 - getFirstDayOfWeek()) % 7; // 0..6
int relDowJan1 = (dayOfWeek - dayOfYear + 7001 - getFirstDayOfWeek()) % 7; // 0..6
int woy = (dayOfYear - 1 + relDowJan1) / 7; // 0..53
if ((7 - relDowJan1) >= getMinimalDaysInFirstWeek()) {
++woy;
}
// Adjust for weeks at the year end that overlap into the previous or
// next calendar year.
if (woy == 0) {
// We are the last week of the previous year.
// Check to see if we are in the last week; if so, we need
// to handle the case in which we are the first week of the
// next year.
int prevDoy = dayOfYear + handleGetYearLength(eyear - 1);
woy = weekNumber(prevDoy, dayOfWeek);
yearOfWeekOfYear--;
} else {
int lastDoy = handleGetYearLength(eyear);
// Fast check: For it to be week 1 of the next year, the DOY
// must be on or after L-5, where L is yearLength(), then it
// cannot possibly be week 1 of the next year:
// L-5 L
// doy: 359 360 361 362 363 364 365 001
// dow: 1 2 3 4 5 6 7
if (dayOfYear >= (lastDoy - 5)) {
int lastRelDow = (relDow + lastDoy - dayOfYear) % 7;
if (lastRelDow < 0) {
lastRelDow += 7;
}
if (((6 - lastRelDow) >= getMinimalDaysInFirstWeek()) &&
((dayOfYear + 7 - relDow) > lastDoy)) {
woy = 1;
yearOfWeekOfYear++;
}
}
}
fields[WEEK_OF_YEAR] = woy;
fields[YEAR_WOY] = yearOfWeekOfYear;
// WEEK_OF_YEAR end
int dayOfMonth = fields[DAY_OF_MONTH];
fields[WEEK_OF_MONTH] = weekNumber(dayOfMonth, dayOfWeek);
fields[DAY_OF_WEEK_IN_MONTH] = (dayOfMonth-1) / 7 + 1;
}
//----------------------------------------------------------------------
// Fields -> Time
//----------------------------------------------------------------------
/**
* Value to OR against resolve table field values for remapping.
* @see #resolveFields
* @stable ICU 2.0
*/
protected static final int RESOLVE_REMAP = 32;
// A power of 2 greater than or equal to MAX_FIELD_COUNT
// Default table for day in year
static final int[][][] DATE_PRECEDENCE = {
{
{ DAY_OF_MONTH },
{ WEEK_OF_YEAR, DAY_OF_WEEK },
{ WEEK_OF_MONTH, DAY_OF_WEEK },
{ DAY_OF_WEEK_IN_MONTH, DAY_OF_WEEK },
{ WEEK_OF_YEAR, DOW_LOCAL },
{ WEEK_OF_MONTH, DOW_LOCAL },
{ DAY_OF_WEEK_IN_MONTH, DOW_LOCAL },
{ DAY_OF_YEAR },
},
{
{ WEEK_OF_YEAR },
{ WEEK_OF_MONTH },
{ DAY_OF_WEEK_IN_MONTH },
{ RESOLVE_REMAP | DAY_OF_WEEK_IN_MONTH, DAY_OF_WEEK },
{ RESOLVE_REMAP | DAY_OF_WEEK_IN_MONTH, DOW_LOCAL },
},
};
static final int[][][] DOW_PRECEDENCE = {
{
{ DAY_OF_WEEK },
{ DOW_LOCAL },
},
};
/**
* Given a precedence table, return the newest field combination in
* the table, or -1 if none is found.
*
* The precedence table is a 3-dimensional array of integers. It
* may be thought of as an array of groups. Each group is an array of
* lines. Each line is an array of field numbers. Within a line, if
* all fields are set, then the time stamp of the line is taken to be
* the stamp of the most recently set field. If any field of a line is
* unset, then the line fails to match. Within a group, the line with
* the newest time stamp is selected. The first field of the line is
* returned to indicate which line matched.
*
* In some cases, it may be desirable to map a line to field that
* whose stamp is NOT examined. For example, if the best field is
* DAY_OF_WEEK then the DAY_OF_WEEK_IN_MONTH algorithm may be used. In
* order to do this, insert the value If all lines of a group contain at least one unset field, then no
* line will match, and the group as a whole will fail to match. In
* that case, the next group will be processed. If all groups fail to
* match, then -1 is returned.
* @stable ICU 2.0
*/
protected int resolveFields(int[][][] precedenceTable) {
int bestField = -1;
for (int g=0; g In addition, subclasses should compute any subclass-specific
* fields, that is, fields from BASE_FIELD_COUNT to
* getFieldCount() - 1.
*
* The default implementation in
* Unlike the built-in division, this is mathematically well-behaved.
* E.g.,
* Unlike the built-in division, this is mathematically well-behaved.
* E.g.,
* Unlike the built-in division, this is mathematically well-behaved.
* E.g.,
* Unlike the built-in division, this is mathematically well-behaved.
* E.g., Note: This method will be implemented in ICU 3.0; ICU 2.8
* contains a partial preview implementation. The * actual
* locale is returned correctly, but the valid locale is
* not, in most cases.
* @param type type of information requested, either {@link
* com.ibm.icu.util.ULocale#VALID_LOCALE} or {@link
* com.ibm.icu.util.ULocale#ACTUAL_LOCALE}.
* @return the information specified by type, or null if
* this object was not constructed from locale data.
* @see com.ibm.icu.util.ULocale
* @see com.ibm.icu.util.ULocale#VALID_LOCALE
* @see com.ibm.icu.util.ULocale#ACTUAL_LOCALE
* @draft ICU 2.8 (retain)
* @provisional This API might change or be removed in a future release.
*/
public final ULocale getLocale(ULocale.Type type) {
return type == ULocale.ACTUAL_LOCALE ?
this.actualLocale : this.validLocale;
}
/**
* Set information about the locales that were used to create this
* object. If the object was not constructed from locale data,
* both arguments should be set to null. Otherwise, neither
* should be null. The actual locale must be at the same level or
* less specific than the valid locale. This method is intended
* for use by factories or other entities that create objects of
* this class.
* @param valid the most specific locale containing any resource
* data, or null
* @param actual the locale containing data used to construct this
* object, or null
* @see com.ibm.icu.util.ULocale
* @see com.ibm.icu.util.ULocale#VALID_LOCALE
* @see com.ibm.icu.util.ULocale#ACTUAL_LOCALE
* @internal
*/
final void setLocale(ULocale valid, ULocale actual) {
// Change the following to an assertion later
if ((valid == null) != (actual == null)) {
///CLOVER:OFF
throw new IllegalArgumentException();
///CLOVER:ON
}
// Another check we could do is that the actual locale is at
// the same level or less specific than the valid locale.
this.validLocale = valid;
this.actualLocale = actual;
}
/**
* The most specific locale containing any resource data, or null.
* @see com.ibm.icu.util.ULocale
* @internal
*/
private ULocale validLocale;
/**
* The locale containing data used to construct this object, or
* null.
* @see com.ibm.icu.util.ULocale
* @internal
*/
private ULocale actualLocale;
// -------- END ULocale boilerplate --------
}
icu4j-4.2.1.1/src/com/ibm/icu/util/GregorianCalendar.java 0000644 0001750 0001750 00000107236 11161120764 022724 0 ustar twerner twerner /*
* Copyright (C) 1996-2009, International Business Machines
* Corporation and others. All Rights Reserved.
*/
package com.ibm.icu.util;
import java.util.Date;
import java.util.Locale;
/**
*
* The standard (Gregorian) calendar has 2 eras, BC and AD.
*
*
* This implementation handles a single discontinuity, which corresponds by
* default to the date the Gregorian calendar was instituted (October 15, 1582
* in some countries, later in others). The cutover date may be changed by the
* caller by calling
* Historically, in those countries which adopted the Gregorian calendar first,
* October 4, 1582 was thus followed by October 15, 1582. This calendar models
* this correctly. Before the Gregorian cutover,
*
* Prior to the institution of the Gregorian calendar, New Year's Day was
* March 25. To avoid confusion, this calendar always uses January 1. A manual
* adjustment may be made if desired for dates that are prior to the Gregorian
* changeover and which fall between January 1 and March 24.
*
* Values calculated for the For example, January 1, 1998 was a Thursday. If
* Values calculated for the For example, if
* Example:
*
* GregorianCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a
* To obtain a pure Julian calendar, set the change date to
*
* The Islamic calendar is strictly lunar, and thus an Islamic year of twelve
* lunar months does not correspond to the solar year used by most other
* calendar systems, including the Gregorian. An Islamic year is, on average,
* about 354 days long, so each successive Islamic year starts about 11 days
* earlier in the corresponding Gregorian year.
*
* Each month of the calendar starts when the new moon's crescent is visible
* at sunset. However, in order to keep the time fields in this class
* synchronized with those of the other calendars and with local clock time,
* we treat days and months as beginning at midnight,
* roughly 6 hours after the corresponding sunset.
*
* There are two main variants of the Islamic calendar in existence. The first
* is the civil calendar, which uses a fixed cycle of alternating 29-
* and 30-day months, with a leap day added to the last month of 11 out of
* every 30 years. This calendar is easily calculated and thus predictable in
* advance, so it is used as the civil calendar in a number of Arab countries.
* This is the default behavior of a newly-created
* The Islamic religious calendar, however, is based on the observation
* of the crescent moon. It is thus affected by the position at which the
* observations are made, seasonal variations in the time of sunset, the
* eccentricities of the moon's orbit, and even the weather at the observation
* site. This makes it impossible to calculate in advance, and it causes the
* start of a month in the religious calendar to differ from the civil calendar
* by up to three days.
*
* Using astronomical calculations for the position of the sun and moon, the
* moon's illumination, and other factors, it is possible to determine the start
* of a lunar month with a fairly high degree of certainty. However, these
* calculations are extremely complicated and thus slow, so most algorithms,
* including the one used here, are only approximations of the true astronical
* calculations. At present, the approximations used in this class are fairly
* simplistic; they will be improved in later versions of the code.
*
* The {@link #setCivil setCivil} method determines
* which approach is used to determine the start of a month. By default, the
* fixed-cycle civil calendar is used. However, if
* This class should not be subclassed.
* IslamicCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a
* To reset any explicit field so that it will get heuristic values, pass in
* null. For example, myPreferences.setLocale(null);
*
* All of the heuristics can be customized by subclasses, by overriding
* getTerritory(), guessCollator(), etc.
*
* The class also supplies display names for languages, scripts, territories,
* currencies, timezones, etc. These are computed according to the
* locale/language preference list. Thus, if the preference is Breton; French;
* English, then the display name for a language will be returned in Breton if
* available, otherwise in French if available, otherwise in English.
*
* The codes used to reference territory, currency, etc. are as defined elsewhere
* in ICU, and are taken from CLDR (which reflects RFC 3066bis usage, ISO 4217,
* and the TZ Timezone database identifiers).
*
* This is at a prototype stage, and has not incorporated all the design
* changes that we would like yet; further feedback is welcome. Note: This class deliberately resembles
* java.util.Currency but it has a completely independent
* implementation, and adds features not present in the JDK.
* @author Alan Liu
* @stable ICU 2.2
*/
public class Currency extends MeasureUnit implements Serializable {
// using serialver from jdk1.4.2_05
private static final long serialVersionUID = -5839973855554750484L;
private static final boolean DEBUG = ICUDebug.enabled("currency");
// Cache to save currency name trie
private static ICUCache CURRENCY_NAME_CACHE = new SimpleCache();
/**
* ISO 4217 3-letter code.
*/
private String isoCode;
/**
* Selector for getName() indicating a symbolic name for a
* currency, such as "$" for USD.
* @stable ICU 2.6
*/
public static final int SYMBOL_NAME = 0;
/**
* Selector for ucurr_getName indicating the long name for a
* currency, such as "US Dollar" for USD.
* @stable ICU 2.6
*/
public static final int LONG_NAME = 1;
/**
* Selector for getName() indicating the plural long name for a
* currency, such as "US dollar" for USD in "1 US dollar",
* and "US dollars" for USD in "2 US dollars".
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public static final int PLURAL_LONG_NAME = 2;
// begin registry stuff
// shim for service code
/* package */ static abstract class ServiceShim {
abstract ULocale[] getAvailableULocales();
abstract Locale[] getAvailableLocales();
abstract Currency createInstance(ULocale l);
abstract Object registerInstance(Currency c, ULocale l);
abstract boolean unregister(Object f);
}
private static ServiceShim shim;
private static ServiceShim getShim() {
// Note: this instantiation is safe on loose-memory-model configurations
// despite lack of synchronization, since the shim instance has no state--
// it's all in the class init. The worst problem is we might instantiate
// two shim instances, but they'll share the same state so that's ok.
if (shim == null) {
try {
Class cls = Class.forName("com.ibm.icu.util.CurrencyServiceShim");
shim = (ServiceShim)cls.newInstance();
}
catch (Exception e) {
if(DEBUG){
e.printStackTrace();
}
throw new RuntimeException(e.getMessage());
}
}
return shim;
}
/**
* Returns a currency object for the default currency in the given
* locale.
* @param locale the locale
* @return the currency object for this locale
* @stable ICU 2.2
*/
public static Currency getInstance(Locale locale) {
return getInstance(ULocale.forLocale(locale));
}
/**
* Returns a currency object for the default currency in the given
* locale.
* @stable ICU 3.2
*/
public static Currency getInstance(ULocale locale) {
String currency = locale.getKeywordValue("currency");
if (currency != null) {
return getInstance(currency);
}
if (shim == null) {
return createCurrency(locale);
}
return shim.createInstance(locale);
}
/**
* Returns an array of Strings which contain the currency
* identifiers which are valid for the given locale on the
* given date.
* @param loc the locale for which to retrieve currency codes.
* @param d the date for which to retrieve currency codes for the given locale.
* @return The array of ISO currency codes.
* @stable ICU 4.0
*/
public static String[] getAvailableCurrencyCodes(ULocale loc, Date d)
{
// local variables
String country = loc.getCountry();
long dateL = d.getTime();
long mask = 4294967295L;
Vector currCodeVector = new Vector();
// Get supplementalData
ICUResourceBundle bundle = (ICUResourceBundle)ICUResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME,
"supplementalData",
ICUResourceBundle.ICU_DATA_CLASS_LOADER);
if (bundle == null)
{
// no data
return null;
}
// Work with the supplementalData
try
{
// Process each currency to see which one is valid for the given date.
// Some regions can have more than one current currency in use for
// a given date.
UResourceBundle cm = bundle.get("CurrencyMap");
UResourceBundle countryArray = cm.get(country);
// Get valid currencies
for (int i = 0; i < countryArray.getSize(); i++)
{
// get the currency resource
UResourceBundle currencyReq = countryArray.get(i);
String curriso = null;
curriso = currencyReq.getString("id");
// get the from date
long fromDate = 0;
UResourceBundle fromRes = currencyReq.get("from");
int[] fromArray = fromRes.getIntVector();
fromDate = (long)fromArray[0] << 32;
fromDate |= ((long)fromArray[1] & mask);
// get the to date and check the date range
if (currencyReq.getSize() > 2)
{
long toDate = 0;
UResourceBundle toRes = currencyReq.get("to");
int[] toArray = toRes.getIntVector();
toDate = (long)toArray[0] << 32;
toDate |= ((long)toArray[1] & mask);
if ((fromDate <= dateL) && (dateL < toDate))
{
currCodeVector.addElement(curriso);
}
}
else
{
if (fromDate <= dateL)
{
currCodeVector.addElement(curriso);
}
}
} // end For loop
// return the String array if we have matches
currCodeVector.trimToSize();
if (currCodeVector.size() != 0)
{
return ((String[])currCodeVector.toArray(new String[0]));
}
}
catch (MissingResourceException ex)
{
// We don't know about this region.
// As of CLDR 1.5.1, the data includes deprecated region history too.
// So if we get here, either the region doesn't exist, or the data is really bad.
// Deprecated regions should return the last valid currency for that region in the data.
// We don't try to resolve it to a new region.
}
// if we get this far, return nothing
return null;
}
private static final String EUR_STR = "EUR";
/**
* Instantiate a currency from a resource bundle found in Locale loc.
*/
/* package */ static Currency createCurrency(ULocale loc) {
String country = loc.getCountry();
String variant = loc.getVariant();
boolean isPreEuro = variant.equals("PREEURO");
boolean isEuro = variant.equals("EURO");
// TODO: ICU4C has service registration, and the currency is requested from the service here.
ICUResourceBundle bundle = (ICUResourceBundle) ICUResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME,"supplementalData", ICUResourceBundle.ICU_DATA_CLASS_LOADER);
if(bundle==null){
//throw new MissingResourceException()
return null;
}
try {
UResourceBundle cm = bundle.get("CurrencyMap");
String curriso = null;
UResourceBundle countryArray = cm.get(country);
// Some regions can have more than one current currency in use.
// The latest default currency is always the first one.
UResourceBundle currencyReq = countryArray.get(0);
curriso = currencyReq.getString("id");
if (isPreEuro && curriso.equals(EUR_STR)) {
currencyReq = countryArray.get(1);
curriso = currencyReq.getString("id");
}
else if (isEuro) {
curriso = EUR_STR;
}
if (curriso != null) {
return new Currency(curriso);
}
} catch (MissingResourceException ex) {
// We don't know about this region.
// As of CLDR 1.5.1, the data includes deprecated region history too.
// So if we get here, either the region doesn't exist, or the data is really bad.
// Deprecated regions should return the last valid currency for that region in the data.
// We don't try to resolve it to a new region.
}
return null;
}
/**
* Returns a currency object given an ISO 4217 3-letter code.
* @param theISOCode the iso code
* @return the currency for this iso code
* @throws NullPoninterException if Note: This method will be obsoleted. The implementation is
* no longer locale-specific and so there is no longer a valid or
* actual locale associated with the Currency object. Until
* it is removed, this method will return the root locale.
* @param type type of information requested, either {@link
* com.ibm.icu.util.ULocale#VALID_LOCALE} or {@link
* com.ibm.icu.util.ULocale#ACTUAL_LOCALE}.
* @return the information specified by type, or null if
* this object was not constructed from locale data.
* @see com.ibm.icu.util.ULocale
* @see com.ibm.icu.util.ULocale#VALID_LOCALE
* @see com.ibm.icu.util.ULocale#ACTUAL_LOCALE
* @obsolete ICU 3.2 to be removed
* @deprecated This API is obsolete.
*/
public final ULocale getLocale(ULocale.Type type) {
ULocale result = (type == ULocale.ACTUAL_LOCALE) ? actualLocale : validLocale;
if (result == null) {
return ULocale.ROOT;
}
return result;
}
/**
* Set information about the locales that were used to create this
* object. If the object was not constructed from locale data,
* both arguments should be set to null. Otherwise, neither
* should be null. The actual locale must be at the same level or
* less specific than the valid locale. This method is intended
* for use by factories or other entities that create objects of
* this class.
* @param valid the most specific locale containing any resource
* data, or null
* @param actual the locale containing data used to construct this
* object, or null
* @see com.ibm.icu.util.ULocale
* @see com.ibm.icu.util.ULocale#VALID_LOCALE
* @see com.ibm.icu.util.ULocale#ACTUAL_LOCALE
* @internal
* @deprecated This API is ICU internal only.
*/
final void setLocale(ULocale valid, ULocale actual) {
// Change the following to an assertion later
if ((valid == null) != (actual == null)) {
///CLOVER:OFF
throw new IllegalArgumentException();
///CLOVER:ON
}
// Another check we could do is that the actual locale is at
// the same level or less specific than the valid locale.
this.validLocale = valid;
this.actualLocale = actual;
}
/*
* The most specific locale containing any resource data, or null.
*/
private ULocale validLocale;
/*
* The locale containing data used to construct this object, or null.
*/
private ULocale actualLocale;
// -------- END ULocale boilerplate --------
}
//eof
icu4j-4.2.1.1/src/com/ibm/icu/util/EthiopicCalendar.java 0000644 0001750 0001750 00000030741 11015072544 022547 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2005-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.Date;
import java.util.Locale;
/**
* Implement the Ethiopic calendar system.
*
* EthiopicCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a Abstract implementation of a notification facility. Clients add
* EventListeners with addListener and remove them with removeListener.
* Notifiers call notifyChanged when they wish to notify listeners.
* This queues the listener list on the notification thread, which
* eventually dequeues the list and calls notifyListener on each
* listener in the list. Subclasses override acceptsListener and notifyListener
* to add type-safe notification. AcceptsListener should return
* true if the listener is of the appropriate type; ICUNotifier
* itself will ensure the listener is non-null and that the
* identical listener is not already registered with the Notifier.
* NotifyListener should cast the listener to the appropriate
* type and call the appropriate method on the listener.
*/
public abstract class ICUNotifier {
private final Object notifyLock = new Object();
private NotifyThread notifyThread;
private List listeners;
/**
* Add a listener to be notified when notifyChanged is called.
* The listener must not be null. AcceptsListener must return
* true for the listener. Attempts to concurrently
* register the identical listener more than once will be
* silently ignored.
*/
public void addListener(EventListener l) {
if (l == null) {
throw new NullPointerException();
}
if (acceptsListener(l)) {
synchronized (notifyLock) {
if (listeners == null) {
listeners = new ArrayList(5);
} else {
// identity equality check
Iterator iter = listeners.iterator();
while (iter.hasNext()) {
if (iter.next() == l) {
return;
}
}
}
listeners.add(l);
}
} else {
throw new IllegalStateException("Listener invalid for this notifier.");
}
}
/**
* Stop notifying this listener. The listener must
* not be null. Attemps to remove a listener that is
* not registered will be silently ignored.
*/
public void removeListener(EventListener l) {
if (l == null) {
throw new NullPointerException();
}
synchronized (notifyLock) {
if (listeners != null) {
// identity equality check
Iterator iter = listeners.iterator();
while (iter.hasNext()) {
if (iter.next() == l) {
iter.remove();
if (listeners.size() == 0) {
listeners = null;
}
return;
}
}
}
}
}
/**
* Queue a notification on the notification thread for the current
* listeners. When the thread unqueues the notification, notifyListener
* is called on each listener from the notification thread.
*/
public void notifyChanged() {
if (listeners != null) {
synchronized (notifyLock) {
if (listeners != null) {
if (notifyThread == null) {
notifyThread = new NotifyThread(this);
notifyThread.setDaemon(true);
notifyThread.start();
}
notifyThread.queue(listeners.toArray());
}
}
}
}
/**
* The notification thread.
*/
private static class NotifyThread extends Thread {
private final ICUNotifier notifier;
private final List queue = new LinkedList();
NotifyThread(ICUNotifier notifier) {
this.notifier = notifier;
}
/**
* Queue the notification on the thread.
*/
public void queue(Object[] list) {
synchronized (this) {
queue.add(list);
notify();
}
}
/**
* Wait for a notification to be queued, then notify all
* listeners listed in the notification.
*/
public void run() {
Object[] list;
while (true) {
try {
synchronized (this) {
while (queue.isEmpty()) {
wait();
}
list = (Object[])queue.remove(0);
}
for (int i = 0; i < list.length; ++i) {
notifier.notifyListener((EventListener)list[i]);
}
}
catch (InterruptedException e) {
}
}
}
}
/**
* Subclasses implement this to return true if the listener is
* of the appropriate type.
*/
protected abstract boolean acceptsListener(EventListener l);
/**
* Subclasses implement this to notify the listener.
*/
protected abstract void notifyListener(EventListener l);
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/Assert.java 0000644 0001750 0001750 00000001514 10421032307 020563 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2005-2006, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
*/
package com.ibm.icu.impl;
// 1.3 compatibility layer
public class Assert {
public static void fail(Exception e) {
fail(e.toString()); // can't wrap exceptions in jdk 1.3
}
public static void fail(String msg) {
throw new IllegalStateException("failure '" + msg + "'");
}
public static void assrt(boolean val) {
if (!val) throw new IllegalStateException("assert failed");
}
public static void assrt(String msg, boolean val) {
if (!val) throw new IllegalStateException("assert '" + msg + "' failed");
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/CalendarCache.java 0000644 0001750 0001750 00000006253 10053252401 021764 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2004, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
/**
* @internal
*/
public class CalendarCache
{
/**
* @internal
*/
public CalendarCache() {
makeArrays(arraySize);
}
private void makeArrays(int newSize) {
keys = new long[newSize];
values = new long[newSize];
for (int i = 0; i < newSize; i++) {
values[i] = EMPTY;
}
arraySize = newSize;
threshold = (int)(arraySize * 0.75);
size = 0;
}
/**
* @internal
*/
public synchronized long get(long key) {
return values[findIndex(key)];
}
/**
* @internal
*/
public synchronized void put(long key, long value)
{
if (size >= threshold) {
rehash();
}
int index = findIndex(key);
keys[index] = key;
values[index] = value;
size++;
}
private final int findIndex(long key) {
int index = hash(key);
int delta = 0;
while (values[index] != EMPTY && keys[index] != key)
{
if (delta == 0) {
delta = hash2(key);
}
index = (index + delta) % arraySize;
}
return index;
}
private void rehash()
{
int oldSize = arraySize;
long[] oldKeys = keys;
long[] oldValues = values;
if (pIndex < primes.length - 1) {
arraySize = primes[++pIndex];
} else {
arraySize = arraySize * 2 + 1;
}
size = 0;
makeArrays(arraySize);
for (int i = 0; i < oldSize; i++) {
if (oldValues[i] != EMPTY) {
put(oldKeys[i], oldValues[i]);
}
}
oldKeys = oldValues = null; // Help out the garbage collector
}
/**
* Produce a uniformly-distributed hash value from an integer key.
* This is essentially a linear congruential random number generator
* that uses the key as its seed value.
*/
private final int hash(long key)
{
int h = (int)((key * 15821 + 1) % arraySize);
if (h < 0) {
h += arraySize;
}
return h;
}
private final int hash2(long key) {
return arraySize - 2 - (int)(key % (arraySize-2) );
}
static private final int primes[] = { // 5, 17, 31, 47, // for testing
61, 127, 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521,
131071, 262139,
};
private int pIndex = 0;
private int size = 0;
private int arraySize = primes[pIndex];
private int threshold = (arraySize * 3) / 4;
private long[] keys = new long[arraySize];
private long[] values = new long[arraySize];
/**
* @internal
*/
static public long EMPTY = Long.MIN_VALUE;
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/TimeZoneAdapter.java 0000644 0001750 0001750 00000007764 10765431070 022405 0 ustar twerner twerner /*
**********************************************************************
* Copyright (c) 2003-2008, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Author: Alan Liu
* Created: October 2 2003
* Since: ICU 2.8
**********************************************************************
*/
package com.ibm.icu.impl;
import com.ibm.icu.util.TimeZone;
import java.util.Date;
/**
* Sets the currentIndex to the specified currentIndex in the text and
* returns that single UTF16 character at currentIndex.
* This assumes the text is stored as 16-bit code units. private constructor. Creates a new Trie with the settings for the trie data. Unserialize the 32-bit-aligned input stream and use the data for the
* trie. Gets the latin 1 fast path value. Note this only works if latin 1 characters have their own linear
* array. Parses the input stream and stores its trie content into a index and
* data array Protected constructor for use in UCharacter. Canonicalization adjusts the locale string so that the
* section before the first understore is in lower case, and the rest
* is in upper case, with no trailing underscores. First falls back through the primary ID, then through
* the fallbackID. The final fallback is "root"
* unless the primary id was "root", in which case
* there is no fallback.
*/
public boolean fallback() {
int x = currentID.lastIndexOf('_');
if (x != -1) {
while (--x >= 0 && currentID.charAt(x) == '_') { // handle zh__PINYIN
}
currentID = currentID.substring(0, x+1);
return true;
}
if (fallbackID != null) {
if (fallbackID.length() == 0) {
currentID = "root";
fallbackID = null;
} else {
currentID = fallbackID;
fallbackID = "";
}
return true;
}
currentID = null;
return false;
}
/**
* If a key created from id would eventually fallback to match the
* canonical ID of this key, return true.
*/
public boolean isFallbackOf(String id) {
return LocaleUtility.isFallbackOf(canonicalID(), id);
}
}
/**
* A subclass of Factory that uses LocaleKeys. If 'visible' the
* factory reports its IDs.
*/
public static abstract class LocaleKeyFactory implements Factory {
protected final String name;
protected final boolean visible;
public static final boolean VISIBLE = true;
public static final boolean INVISIBLE = false;
/**
* Constructor used by subclasses.
*/
protected LocaleKeyFactory(boolean visible) {
this.visible = visible;
this.name = null;
}
/**
* Constructor used by subclasses.
*/
protected LocaleKeyFactory(boolean visible, String name) {
this.visible = visible;
this.name = name;
}
/**
* Implement superclass abstract method. This checks the currentID of
* the key against the supported IDs, and passes the canonicalLocale and
* kind off to handleCreate (which subclasses must implement).
*/
public Object create(Key key, ICUService service) {
if (handlesKey(key)) {
LocaleKey lkey = (LocaleKey)key;
int kind = lkey.kind();
ULocale uloc = lkey.currentLocale();
return handleCreate(uloc, kind, service);
} else {
// System.out.println("factory: " + this + " did not support id: " + key.currentID());
// System.out.println("supported ids: " + getSupportedIDs());
}
return null;
}
protected boolean handlesKey(Key key) {
if (key != null) {
String id = key.currentID();
Set supported = getSupportedIDs();
return supported.contains(id);
}
return false;
}
/**
* Override of superclass method.
*/
public void updateVisibleIDs(Map result) {
Set cache = getSupportedIDs();
Iterator iter = cache.iterator();
while (iter.hasNext()) {
String id = (String)iter.next();
if (visible) {
result.put(id, this);
} else {
result.remove(id);
}
}
}
/**
* Return a localized name for the locale represented by id.
*/
public String getDisplayName(String id, ULocale locale) {
// assume if the user called this on us, we must have handled some fallback of this id
// if (isSupportedID(id)) {
if (locale == null) {
return id;
}
ULocale loc = new ULocale(id);
return loc.getDisplayName(locale);
// }
// return null;
}
///CLOVER:OFF
/**
* Utility method used by create(Key, ICUService). Subclasses can
* implement this instead of create.
*/
protected Object handleCreate(ULocale loc, int kind, ICUService service) {
return null;
}
///CLOVER:ON
/**
* Return true if this id is one the factory supports (visible or
* otherwise).
*/
protected boolean isSupportedID(String id) {
return getSupportedIDs().contains(id);
}
/**
* Return the set of ids that this factory supports (visible or
* otherwise). This can be called often and might need to be
* cached if it is expensive to create.
*/
protected Set getSupportedIDs() {
return Collections.EMPTY_SET;
}
/**
* For debugging.
*/
public String toString() {
StringBuffer buf = new StringBuffer(super.toString());
if (name != null) {
buf.append(", name: ");
buf.append(name);
}
buf.append(", visible: ");
buf.append(visible);
return buf.toString();
}
}
/**
* A LocaleKeyFactory that just returns a single object for a kind/locale.
*/
public static class SimpleLocaleKeyFactory extends LocaleKeyFactory {
private final Object obj;
private final String id;
private final int kind;
// TODO: remove when we no longer need this
public SimpleLocaleKeyFactory(Object obj, ULocale locale, int kind, boolean visible) {
this(obj, locale, kind, visible, null);
}
public SimpleLocaleKeyFactory(Object obj, ULocale locale, int kind, boolean visible, String name) {
super(visible, name);
this.obj = obj;
this.id = locale.getBaseName();
this.kind = kind;
}
/**
* Returns the service object if kind/locale match. Service is not used.
*/
public Object create(Key key, ICUService service) {
LocaleKey lkey = (LocaleKey)key;
if (kind == LocaleKey.KIND_ANY || kind == lkey.kind()) {
String keyID = lkey.currentID();
if (id.equals(keyID)) {
return obj;
}
}
return null;
}
protected boolean isSupportedID(String idToCheck) {
return this.id.equals(idToCheck);
}
public void updateVisibleIDs(Map result) {
if (visible) {
result.put(id, this);
} else {
result.remove(id);
}
}
public String toString() {
StringBuffer buf = new StringBuffer(super.toString());
buf.append(", id: ");
buf.append(id);
buf.append(", kind: ");
buf.append(kind);
return buf.toString();
}
}
/**
* A LocaleKeyFactory that creates a service based on the ICU locale data.
* This is a base class for most ICU factories. Subclasses instantiate it
* with a constructor that takes a bundle name, which determines the supported
* IDs. Subclasses then override handleCreate to create the actual service
* object. The default implementation returns a resource bundle.
*/
public static class ICUResourceBundleFactory extends LocaleKeyFactory {
protected final String bundleName;
/**
* Convenience constructor that uses the main ICU bundle name.
*/
public ICUResourceBundleFactory() {
this(ICUResourceBundle.ICU_BASE_NAME);
}
/**
* A service factory based on ICU resource data in resources
* with the given name.
*/
public ICUResourceBundleFactory(String bundleName) {
super(true);
this.bundleName = bundleName;
}
/**
* Return the supported IDs. This is the set of all locale names for the bundleName.
*/
protected Set getSupportedIDs() {
// note: "root" is one of the ids, but "" is not. Must convert ULocale.ROOT.
return ICUResourceBundle.getFullLocaleNameSet(bundleName);
}
/**
* Override of superclass method.
*/
public void updateVisibleIDs(Map result) {
Set visibleIDs = ICUResourceBundle.getAvailableLocaleNameSet(bundleName); // only visible ids
Iterator iter = visibleIDs.iterator();
while (iter.hasNext()) {
String id = (String)iter.next();
result.put(id, this);
}
}
/**
* Create the service. The default implementation returns the resource bundle
* for the locale, ignoring kind, and service.
*/
protected Object handleCreate(ULocale loc, int kind, ICUService service) {
return ICUResourceBundle.getBundleInstance(bundleName, loc);
}
public String toString() {
return super.toString() + ", bundle: " + bundleName;
}
}
/**
* Return the name of the current fallback locale. If it has changed since this was
* last accessed, the service cache is cleared.
*/
public String validateFallbackLocale() {
ULocale loc = ULocale.getDefault();
if (loc != fallbackLocale) {
synchronized (this) {
if (loc != fallbackLocale) {
fallbackLocale = loc;
fallbackLocaleName = loc.getBaseName();
clearServiceCache();
}
}
}
return fallbackLocaleName;
}
public Key createKey(String id) {
return LocaleKey.createWithCanonicalFallback(id, validateFallbackLocale());
}
public Key createKey(String id, int kind) {
return LocaleKey.createWithCanonicalFallback(id, validateFallbackLocale(), kind);
}
public Key createKey(ULocale l, int kind) {
return LocaleKey.createWithCanonical(l, validateFallbackLocale(), kind);
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/BOCU.java 0000644 0001750 0001750 00000035334 11015072544 020070 0 ustar twerner twerner /**
*******************************************************************************
* Copyright (C) 1996-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
import com.ibm.icu.text.UCharacterIterator;
/**
* Binary Ordered Compression for Unicode Users are strongly encouraged to read the ICU paper on
*
* BOCU before attempting to use this class. BOCU is used to compress unicode text into a stream of unsigned
* bytes. For many kinds of text the compression compares favorably
* to UTF-8, and for some kinds of text (such as CJK) it does better.
* The resulting bytes will compare in the same order as the original
* code points. The byte stream does not contain the values 0, 1, or
* 2. One example of a use of BOCU is in {@link
* com.ibm.icu.text.Collator#getCollationKey(String)} for a RuleBasedCollator object with
* collation strength IDENTICAL. The result CollationKey will consist of the
* collation order of the source string followed by the BOCU result of the
* source string.
* Unlike a UTF encoding, BOCU-compressed text is not suitable for
* random access. Method: Slope Detection We encode differences with few bytes if their absolute values
* are small. For correct ordering, we must treat the entire value
* range -10ffff..+10ffff in ascending order, which forbids encoding
* the sign and the absolute value separately. Instead, we split the
* lead byte range in the middle and encode non-negative values going
* up and negative values going down. For very small absolute values, the difference is added to a
* middle byte value for single-byte encoded differences. For
* somewhat larger absolute values, the difference is divided by the
* number of byte values available, the modulo is used for one trail
* byte, and the remainder is added to a lead byte avoiding the
* single-byte range. For large absolute values, the difference is
* similarly encoded in three bytes. (Syn Wee, I need examples
* here.) BOCU does not use byte values 0, 1, or 2, but uses all other
* byte values for lead and single bytes, so that the middle range of
* single bytes is as large as possible. Note that the lead byte ranges overlap some, but that the
* sequences as a whole are well ordered. I.e., even if the lead byte
* is the same for sequences of different lengths, the trail bytes
* establish correct order. It would be possible to encode slightly
* larger ranges for each length (>1) by subtracting the lower bound
* of the range. However, that would also slow down the calculation.
* (Syn Wee, need an example). For the actual string encoding, an optimization moves the
* previous code point value to the middle of its Unicode script block
* to minimize the differences in same-script text runs. (Syn Wee,
* need an example.) Encode the code points of a string as a sequence of bytes,
* preserving lexical order. The minimum size of buffer required for the compression can be
* preflighted by getCompressionLength(String). Internal reader class for ICU data file uname.dat containing
* Unicode codepoint name data. This class simply reads unames.icu, authenticates that it is a valid
* ICU data file and split its contents up into blocks of data for use in
* com.ibm.icu.impl.UCharacterName.
* unames.icu which is in big-endian format is jared together with this
* package. Protected constructor. Checking the file for the correct format. The given index must be in the range 0..n-1, where n is the
* value returned by Class enabling iteration of the values in a Trie. Result of each iteration contains the interval of codepoints that have
* the same value type and the value type itself. The comparison of each codepoint value is done via extract(), which the
* default implementation is to return the value as it is. Method extract() can be overwritten to perform manipulations on
* codepoint values in order to perform specialized comparison. TrieIterator is designed to be a generic iterator for the CharTrie
* and the IntTrie, hence to accommodate both types of data, the return
* result will be in terms of int (32 bit) values. See com.ibm.icu.text.UCharacterTypeIterator for examples of use. Notes for porting utrie_enum from icu4c to icu4j: There are basically 3 usage scenarios for porting: 1) UTrieEnumValue is the only implemented callback then just implement a
* subclass of TrieIterator and override the extract(int) method. The
* extract(int) method is analogus to UTrieEnumValue callback.
* 2) UTrieEnumValue and UTrieEnumRange both are implemented then implement
* a subclass of TrieIterator, override the extract method and iterate, e.g
* utrie_enum(&normTrie, _enumPropertyStartsValue, _enumPropertyStartsRange,
* set); 3) UTrieEnumRange is the only implemented callback then just implement
* the while loop, when utrie_enum is called
* Returns true if we are not at the end of the iteration, false
* otherwise. The next set of codepoints with the same value type will be
* calculated during this call and returned in the arguement element. Protected constructor.
* The measurement of time is a very important part of astronomy. Because
* astronomical bodies are constantly in motion, observations are only valid
* at a given moment in time. Accordingly, each
* Almost all of the calculations performed by this class, or by any
* astronomer, are approximations to various degrees of accuracy. The
* calculations in this class are mostly modelled after those described
* in the book
*
* Practical Astronomy With Your Calculator, by Peter J.
* Duffett-Smith, Cambridge University Press, 1990. This is an excellent
* book, and if you want a greater understanding of how these calculations
* are performed it a very good, readable starting point.
*
* WARNING: This class is very early in its development, and
* it is highly likely that its API will change to some degree in the future.
* At the moment, it basically does just enough to support {@link com.ibm.icu.util.IslamicCalendar}
* and {@link com.ibm.icu.util.ChineseCalendar}.
*
* @author Laura Werner
* @author Alan Liu
* @internal
*/
public class CalendarAstronomer {
//-------------------------------------------------------------------------
// Astronomical constants
//-------------------------------------------------------------------------
/**
* The number of standard hours in one sidereal day.
* Approximately 24.93.
* @internal
*/
public static final double SIDEREAL_DAY = 23.93446960027;
/**
* The number of sidereal hours in one mean solar day.
* Approximately 24.07.
* @internal
*/
public static final double SOLAR_DAY = 24.065709816;
/**
* The average number of solar days from one new moon to the next. This is the time
* it takes for the moon to return the same ecliptic longitude as the sun.
* It is longer than the sidereal month because the sun's longitude increases
* during the year due to the revolution of the earth around the sun.
* Approximately 29.53.
*
* @see #SIDEREAL_MONTH
* @internal
*/
public static final double SYNODIC_MONTH = 29.530588853;
/**
* The average number of days it takes
* for the moon to return to the same ecliptic longitude relative to the
* stellar background. This is referred to as the sidereal month.
* It is shorter than the synodic month due to
* the revolution of the earth around the sun.
* Approximately 27.32.
*
* @see #SYNODIC_MONTH
* @internal
*/
public static final double SIDEREAL_MONTH = 27.32166;
/**
* The average number number of days between successive vernal equinoxes.
* Due to the precession of the earth's
* axis, this is not precisely the same as the sidereal year.
* Approximately 365.24
*
* @see #SIDEREAL_YEAR
* @internal
*/
public static final double TROPICAL_YEAR = 365.242191;
/**
* The average number of days it takes
* for the sun to return to the same position against the fixed stellar
* background. This is the duration of one orbit of the earth about the sun
* as it would appear to an outside observer.
* Due to the precession of the earth's
* axis, this is not precisely the same as the tropical year.
* Approximately 365.25.
*
* @see #TROPICAL_YEAR
* @internal
*/
public static final double SIDEREAL_YEAR = 365.25636;
//-------------------------------------------------------------------------
// Time-related constants
//-------------------------------------------------------------------------
/**
* The number of milliseconds in one second.
* @internal
*/
public static final int SECOND_MS = 1000;
/**
* The number of milliseconds in one minute.
* @internal
*/
public static final int MINUTE_MS = 60*SECOND_MS;
/**
* The number of milliseconds in one hour.
* @internal
*/
public static final int HOUR_MS = 60*MINUTE_MS;
/**
* The number of milliseconds in one day.
* @internal
*/
public static final long DAY_MS = 24*HOUR_MS;
/**
* The start of the julian day numbering scheme used by astronomers, which
* is 1/1/4713 BC (Julian), 12:00 GMT. This is given as the number of milliseconds
* since 1/1/1970 AD (Gregorian), a negative number.
* Note that julian day numbers and
* the Julian calendar are not the same thing. Also note that
* julian days start at noon, not midnight.
* @internal
*/
public static final long JULIAN_EPOCH_MS = -210866760000000L;
// static {
// Calendar cal = new GregorianCalendar(TimeZone.getTimeZone("GMT"));
// cal.clear();
// cal.set(cal.ERA, 0);
// cal.set(cal.YEAR, 4713);
// cal.set(cal.MONTH, cal.JANUARY);
// cal.set(cal.DATE, 1);
// cal.set(cal.HOUR_OF_DAY, 12);
// System.out.println("1.5 Jan 4713 BC = " + cal.getTime().getTime());
// cal.clear();
// cal.set(cal.YEAR, 2000);
// cal.set(cal.MONTH, cal.JANUARY);
// cal.set(cal.DATE, 1);
// cal.add(cal.DATE, -1);
// System.out.println("0.0 Jan 2000 = " + cal.getTime().getTime());
// }
/**
* Milliseconds value for 0.0 January 2000 AD.
*/
static final long EPOCH_2000_MS = 946598400000L;
//-------------------------------------------------------------------------
// Assorted private data used for conversions
//-------------------------------------------------------------------------
// My own copies of these so compilers are more likely to optimize them away
static private final double PI = 3.14159265358979323846;
static private final double PI2 = PI * 2.0;
static private final double RAD_HOUR = 12 / PI; // radians -> hours
static private final double DEG_RAD = PI / 180; // degrees -> radians
static private final double RAD_DEG = 180 / PI; // radians -> degrees
//-------------------------------------------------------------------------
// Constructors
//-------------------------------------------------------------------------
/**
* Construct a new
* @param longitude The desired longitude, in degrees east of
* the Greenwich meridian.
*
* @param latitude The desired latitude, in degrees. Positive
* values signify North, negative South.
*
* @see java.util.Date#getTime()
* @internal
*/
public CalendarAstronomer(double longitude, double latitude) {
this();
fLongitude = normPI(longitude * DEG_RAD);
fLatitude = normPI(latitude * DEG_RAD);
fGmtOffset = (long)(fLongitude * 24 * HOUR_MS / PI2);
}
//-------------------------------------------------------------------------
// Time and date getters and setters
//-------------------------------------------------------------------------
/**
* Set the current date and time of this
* Currently, this method uses an approximation of the two-body Kepler's
* equation for the earth and the sun. It does not take into account the
* perturbations caused by the other planets, the moon, etc.
* @internal
*/
public double getSunLongitude()
{
// See page 86 of "Practial Astronomy with your Calculator",
// by Peter Duffet-Smith, for details on the algorithm.
if (sunLongitude == INVALID) {
double[] result = getSunLongitude(getJulianDay());
sunLongitude = result[0];
meanAnomalySun = result[1];
}
return sunLongitude;
}
/**
* TODO Make this public when the entire class is package-private.
*/
/*public*/ double[] getSunLongitude(double julian)
{
// See page 86 of "Practial Astronomy with your Calculator",
// by Peter Duffet-Smith, for details on the algorithm.
double day = julian - JD_EPOCH; // Days since epoch
// Find the angular distance the sun in a fictitious
// circular orbit has travelled since the epoch.
double epochAngle = norm2PI(PI2/TROPICAL_YEAR*day);
// The epoch wasn't at the sun's perigee; find the angular distance
// since perigee, which is called the "mean anomaly"
double meanAnomaly = norm2PI(epochAngle + SUN_ETA_G - SUN_OMEGA_G);
// Now find the "true anomaly", e.g. the real solar longitude
// by solving Kepler's equation for an elliptical orbit
// NOTE: The 3rd ed. of the book lists omega_g and eta_g in different
// equations; omega_g is to be correct.
return new double[] {
norm2PI(trueAnomaly(meanAnomaly, SUN_E) + SUN_OMEGA_G),
meanAnomaly
};
}
/**
* The position of the sun at this object's current date and time,
* in equatorial coordinates.
* @internal
*/
public Equatorial getSunPosition() {
return eclipticToEquatorial(getSunLongitude(), 0);
}
private static class SolarLongitude {
double value;
SolarLongitude(double val) { value = val; }
}
/**
* Constant representing the vernal equinox.
* For use with {@link #getSunTime(SolarLongitude, boolean) getSunTime}.
* Note: In this case, "vernal" refers to the northern hemisphere's seasons.
* @internal
*/
public static final SolarLongitude VERNAL_EQUINOX = new SolarLongitude(0);
/**
* Constant representing the summer solstice.
* For use with {@link #getSunTime(SolarLongitude, boolean) getSunTime}.
* Note: In this case, "summer" refers to the northern hemisphere's seasons.
* @internal
*/
public static final SolarLongitude SUMMER_SOLSTICE = new SolarLongitude(PI/2);
/**
* Constant representing the autumnal equinox.
* For use with {@link #getSunTime(SolarLongitude, boolean) getSunTime}.
* Note: In this case, "autumn" refers to the northern hemisphere's seasons.
* @internal
*/
public static final SolarLongitude AUTUMN_EQUINOX = new SolarLongitude(PI);
/**
* Constant representing the winter solstice.
* For use with {@link #getSunTime(SolarLongitude, boolean) getSunTime}.
* Note: In this case, "winter" refers to the northern hemisphere's seasons.
* @internal
*/
public static final SolarLongitude WINTER_SOLSTICE = new SolarLongitude((PI*3)/2);
/**
* Find the next time at which the sun's ecliptic longitude will have
* the desired value.
* @internal
*/
public long getSunTime(double desired, boolean next)
{
return timeOfAngle( new AngleFunc() { public double eval() { return getSunLongitude(); } },
desired,
TROPICAL_YEAR,
MINUTE_MS,
next);
}
/**
* Find the next time at which the sun's ecliptic longitude will have
* the desired value.
* @internal
*/
public long getSunTime(SolarLongitude desired, boolean next) {
return getSunTime(desired.value, next);
}
/**
* Returns the time (GMT) of sunrise or sunset on the local date to which
* this calendar is currently set.
*
* NOTE: This method only works well if this object is set to a
* time near local noon. Because of variations between the local
* official time zone and the geographic longitude, the
* computation can flop over into an adjacent day if this object
* is set to a time near local midnight.
*
* @internal
*/
public long getSunRiseSet(boolean rise)
{
long t0 = time;
// Make a rough guess: 6am or 6pm local time on the current day
long noon = ((time + fGmtOffset)/DAY_MS)*DAY_MS - fGmtOffset + 12*HOUR_MS;
setTime(noon + (long)((rise ? -6 : 6) * HOUR_MS));
long t = riseOrSet(new CoordFunc() {
public Equatorial eval() { return getSunPosition(); }
},
rise,
.533 * DEG_RAD, // Angular Diameter
34 /60.0 * DEG_RAD, // Refraction correction
MINUTE_MS / 12); // Desired accuracy
setTime(t0);
return t;
}
// Commented out - currently unused. ICU 2.6, Alan
// //-------------------------------------------------------------------------
// // Alternate Sun Rise/Set
// // See Duffett-Smith p.93
// //-------------------------------------------------------------------------
//
// // This yields worse results (as compared to USNO data) than getSunRiseSet().
// /**
// * TODO Make this public when the entire class is package-private.
// */
// /*public*/ long getSunRiseSet2(boolean rise) {
// // 1. Calculate coordinates of the sun's center for midnight
// double jd = Math.floor(getJulianDay() - 0.5) + 0.5;
// double[] sl = getSunLongitude(jd);
// double lambda1 = sl[0];
// Equatorial pos1 = eclipticToEquatorial(lambda1, 0);
//
// // 2. Add ... to lambda to get position 24 hours later
// double lambda2 = lambda1 + 0.985647*DEG_RAD;
// Equatorial pos2 = eclipticToEquatorial(lambda2, 0);
//
// // 3. Calculate LSTs of rising and setting for these two positions
// double tanL = Math.tan(fLatitude);
// double H = Math.acos(-tanL * Math.tan(pos1.declination));
// double lst1r = (PI2 + pos1.ascension - H) * 24 / PI2;
// double lst1s = (pos1.ascension + H) * 24 / PI2;
// H = Math.acos(-tanL * Math.tan(pos2.declination));
// double lst2r = (PI2-H + pos2.ascension ) * 24 / PI2;
// double lst2s = (H + pos2.ascension ) * 24 / PI2;
// if (lst1r > 24) lst1r -= 24;
// if (lst1s > 24) lst1s -= 24;
// if (lst2r > 24) lst2r -= 24;
// if (lst2s > 24) lst2s -= 24;
//
// // 4. Convert LSTs to GSTs. If GST1 > GST2, add 24 to GST2.
// double gst1r = lstToGst(lst1r);
// double gst1s = lstToGst(lst1s);
// double gst2r = lstToGst(lst2r);
// double gst2s = lstToGst(lst2s);
// if (gst1r > gst2r) gst2r += 24;
// if (gst1s > gst2s) gst2s += 24;
//
// // 5. Calculate GST at 0h UT of this date
// double t00 = utToGst(0);
//
// // 6. Calculate GST at 0h on the observer's longitude
// double offset = Math.round(fLongitude*12/PI); // p.95 step 6; he _rounds_ to nearest 15 deg.
// double t00p = t00 - offset*1.002737909;
// if (t00p < 0) t00p += 24; // do NOT normalize
//
// // 7. Adjust
// if (gst1r < t00p) {
// gst1r += 24;
// gst2r += 24;
// }
// if (gst1s < t00p) {
// gst1s += 24;
// gst2s += 24;
// }
//
// // 8.
// double gstr = (24.07*gst1r-t00*(gst2r-gst1r))/(24.07+gst1r-gst2r);
// double gsts = (24.07*gst1s-t00*(gst2s-gst1s))/(24.07+gst1s-gst2s);
//
// // 9. Correct for parallax, refraction, and sun's diameter
// double dec = (pos1.declination + pos2.declination) / 2;
// double psi = Math.acos(Math.sin(fLatitude) / Math.cos(dec));
// double x = 0.830725 * DEG_RAD; // parallax+refraction+diameter
// double y = Math.asin(Math.sin(x) / Math.sin(psi)) * RAD_DEG;
// double delta_t = 240 * y / Math.cos(dec) / 3600; // hours
//
// // 10. Add correction to GSTs, subtract from GSTr
// gstr -= delta_t;
// gsts += delta_t;
//
// // 11. Convert GST to UT and then to local civil time
// double ut = gstToUt(rise ? gstr : gsts);
// //System.out.println((rise?"rise=":"set=") + ut + ", delta_t=" + delta_t);
// long midnight = DAY_MS * (time / DAY_MS); // Find UT midnight on this day
// return midnight + (long) (ut * 3600000);
// }
// Commented out - currently unused. ICU 2.6, Alan
// /**
// * Convert local sidereal time to Greenwich sidereal time.
// * Section 15. Duffett-Smith p.21
// * @param lst in hours (0..24)
// * @return GST in hours (0..24)
// */
// double lstToGst(double lst) {
// double delta = fLongitude * 24 / PI2;
// return normalize(lst - delta, 24);
// }
// Commented out - currently unused. ICU 2.6, Alan
// /**
// * Convert UT to GST on this date.
// * Section 12. Duffett-Smith p.17
// * @param ut in hours
// * @return GST in hours
// */
// double utToGst(double ut) {
// return normalize(getT0() + ut*1.002737909, 24);
// }
// Commented out - currently unused. ICU 2.6, Alan
// /**
// * Convert GST to UT on this date.
// * Section 13. Duffett-Smith p.18
// * @param gst in hours
// * @return UT in hours
// */
// double gstToUt(double gst) {
// return normalize(gst - getT0(), 24) * 0.9972695663;
// }
// Commented out - currently unused. ICU 2.6, Alan
// double getT0() {
// // Common computation for UT <=> GST
//
// // Find JD for 0h UT
// double jd = Math.floor(getJulianDay() - 0.5) + 0.5;
//
// double s = jd - 2451545.0;
// double t = s / 36525.0;
// double t0 = 6.697374558 + (2400.051336 + 0.000025862*t)*t;
// return t0;
// }
// Commented out - currently unused. ICU 2.6, Alan
// //-------------------------------------------------------------------------
// // Alternate Sun Rise/Set
// // See sci.astro FAQ
// // http://www.faqs.org/faqs/astronomy/faq/part3/section-5.html
// //-------------------------------------------------------------------------
//
// // Note: This method appears to produce inferior accuracy as
// // compared to getSunRiseSet().
//
// /**
// * TODO Make this public when the entire class is package-private.
// */
// /*public*/ long getSunRiseSet3(boolean rise) {
//
// // Compute day number for 0.0 Jan 2000 epoch
// double d = (double)(time - EPOCH_2000_MS) / DAY_MS;
//
// // Now compute the Local Sidereal Time, LST:
// //
// double LST = 98.9818 + 0.985647352 * d + /*UT*15 + long*/
// fLongitude*RAD_DEG;
// //
// // (east long. positive). Note that LST is here expressed in degrees,
// // where 15 degrees corresponds to one hour. Since LST really is an angle,
// // it's convenient to use one unit---degrees---throughout.
//
// // COMPUTING THE SUN'S POSITION
// // ----------------------------
// //
// // To be able to compute the Sun's rise/set times, you need to be able to
// // compute the Sun's position at any time. First compute the "day
// // number" d as outlined above, for the desired moment. Next compute:
// //
// double oblecl = 23.4393 - 3.563E-7 * d;
// //
// double w = 282.9404 + 4.70935E-5 * d;
// double M = 356.0470 + 0.9856002585 * d;
// double e = 0.016709 - 1.151E-9 * d;
// //
// // This is the obliquity of the ecliptic, plus some of the elements of
// // the Sun's apparent orbit (i.e., really the Earth's orbit): w =
// // argument of perihelion, M = mean anomaly, e = eccentricity.
// // Semi-major axis is here assumed to be exactly 1.0 (while not strictly
// // true, this is still an accurate approximation). Next compute E, the
// // eccentric anomaly:
// //
// double E = M + e*(180/PI) * Math.sin(M*DEG_RAD) * ( 1.0 + e*Math.cos(M*DEG_RAD) );
// //
// // where E and M are in degrees. This is it---no further iterations are
// // needed because we know e has a sufficiently small value. Next compute
// // the true anomaly, v, and the distance, r:
// //
// /* r * cos(v) = */ double A = Math.cos(E*DEG_RAD) - e;
// /* r * sin(v) = */ double B = Math.sqrt(1 - e*e) * Math.sin(E*DEG_RAD);
// //
// // and
// //
// // r = sqrt( A*A + B*B )
// double v = Math.atan2( B, A )*RAD_DEG;
// //
// // The Sun's true longitude, slon, can now be computed:
// //
// double slon = v + w;
// //
// // Since the Sun is always at the ecliptic (or at least very very close to
// // it), we can use simplified formulae to convert slon (the Sun's ecliptic
// // longitude) to sRA and sDec (the Sun's RA and Dec):
// //
// // sin(slon) * cos(oblecl)
// // tan(sRA) = -------------------------
// // cos(slon)
// //
// // sin(sDec) = sin(oblecl) * sin(slon)
// //
// // As was the case when computing az, the Azimuth, if possible use an
// // atan2() function to compute sRA.
//
// double sRA = Math.atan2(Math.sin(slon*DEG_RAD) * Math.cos(oblecl*DEG_RAD), Math.cos(slon*DEG_RAD))*RAD_DEG;
//
// double sin_sDec = Math.sin(oblecl*DEG_RAD) * Math.sin(slon*DEG_RAD);
// double sDec = Math.asin(sin_sDec)*RAD_DEG;
//
// // COMPUTING RISE AND SET TIMES
// // ----------------------------
// //
// // To compute when an object rises or sets, you must compute when it
// // passes the meridian and the HA of rise/set. Then the rise time is
// // the meridian time minus HA for rise/set, and the set time is the
// // meridian time plus the HA for rise/set.
// //
// // To find the meridian time, compute the Local Sidereal Time at 0h local
// // time (or 0h UT if you prefer to work in UT) as outlined above---name
// // that quantity LST0. The Meridian Time, MT, will now be:
// //
// // MT = RA - LST0
// double MT = normalize(sRA - LST, 360);
// //
// // where "RA" is the object's Right Ascension (in degrees!). If negative,
// // add 360 deg to MT. If the object is the Sun, leave the time as it is,
// // but if it's stellar, multiply MT by 365.2422/366.2422, to convert from
// // sidereal to solar time. Now, compute HA for rise/set, name that
// // quantity HA0:
// //
// // sin(h0) - sin(lat) * sin(Dec)
// // cos(HA0) = ---------------------------------
// // cos(lat) * cos(Dec)
// //
// // where h0 is the altitude selected to represent rise/set. For a purely
// // mathematical horizon, set h0 = 0 and simplify to:
// //
// // cos(HA0) = - tan(lat) * tan(Dec)
// //
// // If you want to account for refraction on the atmosphere, set h0 = -35/60
// // degrees (-35 arc minutes), and if you want to compute the rise/set times
// // for the Sun's upper limb, set h0 = -50/60 (-50 arc minutes).
// //
// double h0 = -50/60 * DEG_RAD;
//
// double HA0 = Math.acos(
// (Math.sin(h0) - Math.sin(fLatitude) * sin_sDec) /
// (Math.cos(fLatitude) * Math.cos(sDec*DEG_RAD)))*RAD_DEG;
//
// // When HA0 has been computed, leave it as it is for the Sun but multiply
// // by 365.2422/366.2422 for stellar objects, to convert from sidereal to
// // solar time. Finally compute:
// //
// // Rise time = MT - HA0
// // Set time = MT + HA0
// //
// // convert the times from degrees to hours by dividing by 15.
// //
// // If you'd like to check that your calculations are accurate or just
// // need a quick result, check the USNO's Sun or Moon Rise/Set Table,
// //
* @param desired The desired longitude.
* @param next true if the next occurrance of the phase
* is desired, false for the previous occurrance.
* @internal
*/
public long getMoonTime(double desired, boolean next)
{
return timeOfAngle( new AngleFunc() {
public double eval() { return getMoonAge(); } },
desired,
SYNODIC_MONTH,
MINUTE_MS,
next);
}
/**
* Find the next or previous time at which the moon will be in the
* desired phase.
*
* @param desired The desired phase of the moon.
* @param next true if the next occurrance of the phase
* is desired, false for the previous occurrance.
* @internal
*/
public long getMoonTime(MoonAge desired, boolean next) {
return getMoonTime(desired.value, next);
}
/**
* Returns the time (GMT) of sunrise or sunset on the local date to which
* this calendar is currently set.
* @internal
*/
public long getMoonRiseSet(boolean rise)
{
return riseOrSet(new CoordFunc() {
public Equatorial eval() { return getMoonPosition(); }
},
rise,
.533 * DEG_RAD, // Angular Diameter
34 /60.0 * DEG_RAD, // Refraction correction
MINUTE_MS); // Desired accuracy
}
//-------------------------------------------------------------------------
// Interpolation methods for finding the time at which a given event occurs
//-------------------------------------------------------------------------
private interface AngleFunc {
public double eval();
}
private long timeOfAngle(AngleFunc func, double desired,
double periodDays, long epsilon, boolean next)
{
// Find the value of the function at the current time
double lastAngle = func.eval();
// Find out how far we are from the desired angle
double deltaAngle = norm2PI(desired - lastAngle) ;
// Using the average period, estimate the next (or previous) time at
// which the desired angle occurs.
double deltaT = (deltaAngle + (next ? 0 : -PI2)) * (periodDays*DAY_MS) / PI2;
double lastDeltaT = deltaT; // Liu
long startTime = time; // Liu
setTime(time + (long)deltaT);
// Now iterate until we get the error below epsilon. Throughout
// this loop we use normPI to get values in the range -Pi to Pi,
// since we're using them as correction factors rather than absolute angles.
do {
// Evaluate the function at the time we've estimated
double angle = func.eval();
// Find the # of milliseconds per radian at this point on the curve
double factor = Math.abs(deltaT / normPI(angle-lastAngle));
// Correct the time estimate based on how far off the angle is
deltaT = normPI(desired - angle) * factor;
// HACK:
//
// If abs(deltaT) begins to diverge we need to quit this loop.
// This only appears to happen when attempting to locate, for
// example, a new moon on the day of the new moon. E.g.:
//
// This result is correct:
// newMoon(7508(Mon Jul 23 00:00:00 CST 1990,false))=
// Sun Jul 22 10:57:41 CST 1990
//
// But attempting to make the same call a day earlier causes deltaT
// to diverge:
// CalendarAstronomer.timeOfAngle() diverging: 1.348508727575625E9 ->
// 1.3649828540224032E9
// newMoon(7507(Sun Jul 22 00:00:00 CST 1990,false))=
// Sun Jul 08 13:56:15 CST 1990
//
// As a temporary solution, we catch this specific condition and
// adjust our start time by one eighth period days (either forward
// or backward) and try again.
// Liu 11/9/00
if (Math.abs(deltaT) > Math.abs(lastDeltaT)) {
long delta = (long) (periodDays * DAY_MS / 8);
setTime(startTime + (next ? delta : -delta));
return timeOfAngle(func, desired, periodDays, epsilon, next);
}
lastDeltaT = deltaT;
lastAngle = angle;
setTime(time + (long)deltaT);
}
while (Math.abs(deltaT) > epsilon);
return time;
}
private interface CoordFunc {
public Equatorial eval();
}
private long riseOrSet(CoordFunc func, boolean rise,
double diameter, double refraction,
long epsilon)
{
Equatorial pos = null;
double tanL = Math.tan(fLatitude);
long deltaT = Long.MAX_VALUE;
int count = 0;
//
// Calculate the object's position at the current time, then use that
// position to calculate the time of rising or setting. The position
// will be different at that time, so iterate until the error is allowable.
//
do {
// See "Practical Astronomy With Your Calculator, section 33.
pos = func.eval();
double angle = Math.acos(-tanL * Math.tan(pos.declination));
double lst = ((rise ? PI2-angle : angle) + pos.ascension ) * 24 / PI2;
// Convert from LST to Universal Time.
long newTime = lstToUT( lst );
deltaT = newTime - time;
setTime(newTime);
}
while (++ count < 5 && Math.abs(deltaT) > epsilon);
// Calculate the correction due to refraction and the object's angular diameter
double cosD = Math.cos(pos.declination);
double psi = Math.acos(Math.sin(fLatitude) / cosD);
double x = diameter / 2 + refraction;
double y = Math.asin(Math.sin(x) / Math.sin(psi));
long delta = (long)((240 * y * RAD_DEG / cosD)*SECOND_MS);
return time + (rise ? -delta : delta);
}
//-------------------------------------------------------------------------
// Other utility methods
//-------------------------------------------------------------------------
/***
* Given 'value', add or subtract 'range' until 0 <= 'value' < range.
* The modulus operator.
*/
private static final double normalize(double value, double range) {
return value - range * Math.floor(value / range);
}
/**
* Normalize an angle so that it's in the range 0 - 2pi.
* For positive angles this is just (angle % 2pi), but the Java
* mod operator doesn't work that way for negative numbers....
*/
private static final double norm2PI(double angle) {
return normalize(angle, PI2);
}
/**
* Normalize an angle into the range -PI - PI
*/
private static final double normPI(double angle) {
return normalize(angle + PI, PI2) - PI;
}
/**
* Find the "true anomaly" (longitude) of an object from
* its mean anomaly and the eccentricity of its orbit. This uses
* an iterative solution to Kepler's equation.
*
* @param meanAnomaly The object's longitude calculated as if it were in
* a regular, circular orbit, measured in radians
* from the point of perigee.
*
* @param eccentricity The eccentricity of the orbit
*
* @return The true anomaly (longitude) measured in radians
*/
private double trueAnomaly(double meanAnomaly, double eccentricity)
{
// First, solve Kepler's equation iteratively
// Duffett-Smith, p.90
double delta;
double E = meanAnomaly;
do {
delta = E - eccentricity * Math.sin(E) - meanAnomaly;
E = E - delta / (1 - eccentricity * Math.cos(E));
}
while (Math.abs(delta) > 1e-5); // epsilon = 1e-5 rad
return 2.0 * Math.atan( Math.tan(E/2) * Math.sqrt( (1+eccentricity)
/(1-eccentricity) ) );
}
/**
* Return the obliquity of the ecliptic (the angle between the ecliptic
* and the earth's equator) at the current time. This varies due to
* the precession of the earth's axis.
*
* @return the obliquity of the ecliptic relative to the equator,
* measured in radians.
*/
private double eclipticObliquity() {
if (eclipObliquity == INVALID) {
final double epoch = 2451545.0; // 2000 AD, January 1.5
double T = (getJulianDay() - epoch) / 36525;
eclipObliquity = 23.439292
- 46.815/3600 * T
- 0.0006/3600 * T*T
+ 0.00181/3600 * T*T*T;
eclipObliquity *= DEG_RAD;
}
return eclipObliquity;
}
//-------------------------------------------------------------------------
// Private data
//-------------------------------------------------------------------------
/**
* Current time in milliseconds since 1/1/1970 AD
* @see java.util.Date#getTime
*/
private long time;
/* These aren't used yet, but they'll be needed for sunset calculations
* and equatorial to horizon coordinate conversions
*/
private double fLongitude = 0.0;
private double fLatitude = 0.0;
private long fGmtOffset = 0;
//
// The following fields are used to cache calculated results for improved
// performance. These values all depend on the current time setting
// of this object, so the clearCache method is provided.
//
static final private double INVALID = Double.MIN_VALUE;
private transient double julianDay = INVALID;
private transient double julianCentury = INVALID;
private transient double sunLongitude = INVALID;
private transient double meanAnomalySun = INVALID;
private transient double moonLongitude = INVALID;
private transient double moonEclipLong = INVALID;
//private transient double meanAnomalyMoon = INVALID;
private transient double eclipObliquity = INVALID;
private transient double siderealT0 = INVALID;
private transient double siderealTime = INVALID;
private transient Equatorial moonPosition = null;
private void clearCache() {
julianDay = INVALID;
julianCentury = INVALID;
sunLongitude = INVALID;
meanAnomalySun = INVALID;
moonLongitude = INVALID;
moonEclipLong = INVALID;
//meanAnomalyMoon = INVALID;
eclipObliquity = INVALID;
siderealTime = INVALID;
siderealT0 = INVALID;
moonPosition = null;
}
//private static void out(String s) {
// System.out.println(s);
//}
//private static String deg(double rad) {
// return Double.toString(rad * RAD_DEG);
//}
//private static String hours(long ms) {
// return Double.toString((double)ms / HOUR_MS) + " hours";
//}
/**
* @internal
*/
public String local(long localMillis) {
return new Date(localMillis - TimeZone.getDefault().getRawOffset()).toString();
}
/**
* Represents the position of an object in the sky relative to the ecliptic,
* the plane of the earth's orbit around the Sun.
* This is a spherical coordinate system in which the latitude
* specifies the position north or south of the plane of the ecliptic.
* The longitude specifies the position along the ecliptic plane
* relative to the "First Point of Aries", which is the Sun's position in the sky
* at the Vernal Equinox.
*
* Note that Ecliptic objects are immutable and cannot be modified
* once they are constructed. This allows them to be passed and returned by
* value without worrying about whether other code will modify them.
*
* @see CalendarAstronomer.Equatorial
* @see CalendarAstronomer.Horizon
* @internal
*/
public static final class Ecliptic {
/**
* Constructs an Ecliptic coordinate object.
*
* @param lat The ecliptic latitude, measured in radians.
* @param lon The ecliptic longitude, measured in radians.
* @internal
*/
public Ecliptic(double lat, double lon) {
latitude = lat;
longitude = lon;
}
/**
* Return a string representation of this object
* @internal
*/
public String toString() {
return Double.toString(longitude*RAD_DEG) + "," + (latitude*RAD_DEG);
}
/**
* The ecliptic latitude, in radians. This specifies an object's
* position north or south of the plane of the ecliptic,
* with positive angles representing north.
* @internal
*/
public final double latitude;
/**
* The ecliptic longitude, in radians.
* This specifies an object's position along the ecliptic plane
* relative to the "First Point of Aries", which is the Sun's position
* in the sky at the Vernal Equinox,
* with positive angles representing east.
*
* A bit of trivia: the first point of Aries is currently in the
* constellation Pisces, due to the precession of the earth's axis.
* @internal
*/
public final double longitude;
}
/**
* Represents the position of an
* object in the sky relative to the plane of the earth's equator.
* The Right Ascension specifies the position east or west
* along the equator, relative to the sun's position at the vernal
* equinox. The Declination is the position north or south
* of the equatorial plane.
*
* Note that Equatorial objects are immutable and cannot be modified
* once they are constructed. This allows them to be passed and returned by
* value without worrying about whether other code will modify them.
*
* @see CalendarAstronomer.Ecliptic
* @see CalendarAstronomer.Horizon
* @internal
*/
public static final class Equatorial {
/**
* Constructs an Equatorial coordinate object.
*
* @param asc The right ascension, measured in radians.
* @param dec The declination, measured in radians.
* @internal
*/
public Equatorial(double asc, double dec) {
ascension = asc;
declination = dec;
}
/**
* Return a string representation of this object, with the
* angles measured in degrees.
* @internal
*/
public String toString() {
return Double.toString(ascension*RAD_DEG) + "," + (declination*RAD_DEG);
}
/**
* Return a string representation of this object with the right ascension
* measured in hours, minutes, and seconds.
* @internal
*/
public String toHmsString() {
return radToHms(ascension) + "," + radToDms(declination);
}
/**
* The right ascension, in radians.
* This is the position east or west along the equator
* relative to the sun's position at the vernal equinox,
* with positive angles representing East.
* @internal
*/
public final double ascension;
/**
* The declination, in radians.
* This is the position north or south of the equatorial plane,
* with positive angles representing north.
* @internal
*/
public final double declination;
}
/**
* Represents the position of an object in the sky relative to
* the local horizon.
* The Altitude represents the object's elevation above the horizon,
* with objects below the horizon having a negative altitude.
* The Azimuth is the geographic direction of the object from the
* observer's position, with 0 representing north. The azimuth increases
* clockwise from north.
*
* Note that Horizon objects are immutable and cannot be modified
* once they are constructed. This allows them to be passed and returned by
* value without worrying about whether other code will modify them.
*
* @see CalendarAstronomer.Ecliptic
* @see CalendarAstronomer.Equatorial
* @internal
*/
public static final class Horizon {
/**
* Constructs a Horizon coordinate object.
*
* @param alt The altitude, measured in radians above the horizon.
* @param azim The azimuth, measured in radians clockwise from north.
* @internal
*/
public Horizon(double alt, double azim) {
altitude = alt;
azimuth = azim;
}
/**
* Return a string representation of this object, with the
* angles measured in degrees.
* @internal
*/
public String toString() {
return Double.toString(altitude*RAD_DEG) + "," + (azimuth*RAD_DEG);
}
/**
* The object's altitude above the horizon, in radians.
* @internal
*/
public final double altitude;
/**
* The object's direction, in radians clockwise from north.
* @internal
*/
public final double azimuth;
}
static private String radToHms(double angle) {
int hrs = (int) (angle*RAD_HOUR);
int min = (int)((angle*RAD_HOUR - hrs) * 60);
int sec = (int)((angle*RAD_HOUR - hrs - min/60.0) * 3600);
return Integer.toString(hrs) + "h" + min + "m" + sec + "s";
}
static private String radToDms(double angle) {
int deg = (int) (angle*RAD_DEG);
int min = (int)((angle*RAD_DEG - deg) * 60);
int sec = (int)((angle*RAD_DEG - deg - min/60.0) * 3600);
return Integer.toString(deg) + "\u00b0" + min + "'" + sec + "\"";
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/IntTrieBuilder.java 0000644 0001750 0001750 00000071773 10421032307 022225 0 ustar twerner twerner /*
******************************************************************************
* Copyright (C) 1996-2006, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
package com.ibm.icu.impl;
import com.ibm.icu.lang.UCharacter;
import com.ibm.icu.text.UTF16;
import java.util.Arrays;
import java.io.OutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
/**
* Builder class to manipulate and generate a trie.
* This is useful for ICU data in primitive types.
* Provides a compact way to store information that is indexed by Unicode
* values, such as character properties, types, keyboard values, etc. This is
* very useful when you have a block of Unicode data that contains significant
* values while the rest of the Unicode data is unused in the application or
* when you have a lot of redundance, such as where all 21,000 Han ideographs
* have the same value. However, lookup is much faster than a hash table.
* A trie of any primitive data type serves two purposes:
* Internal class used for Unicode character property database. This classes store binary data read from uprops.icu.
* It does not have the capability to parse the data into more high-level
* information. It only returns bytes of information when required. Due to the form most commonly used for retrieval, array of char is used
* to store the binary data. UCharacterPropertyDB also contains information on accessing indexes to
* significant points in the binary data. Responsibility for molding the binary data into more meaning form lies on
* UCharacter. The "age" is the Unicode version when the code point was first
* designated (as a non-character or for Private Use) or assigned a
* character. This can be useful to avoid emitting code points to receiving
* processes that do not accept newer characters. The data is from the UCD file DerivedAge.txt. This API does not check the validity of the codepoint. Check a binary Unicode property for a code point. Unicode, especially in version 3.2, defines many more properties
* than the original set in UnicodeData.txt. This API is intended to reflect Unicode properties as defined in
* the Unicode Character Database (UCD) and Unicode Technical Reports
* (UTR). For details about the properties see
* http://www.unicode.org/. For names of Unicode properties see the UCD file
* PropertyAliases.txt. This API does not check the validity of the codepoint. Important: If ICU is built with UCD files from Unicode versions
* below 3.2, then properties marked with "new" are not or
* not fully available.
* Unicode property names and property value names are compared
* "loosely". Property[Value]Aliases.txt say:
*
* This function does just that, for ASCII (char *) name strings.
* It is almost identical to ucnv_compareNames() but also ignores
* ASCII White_Space characters (U+0009..U+000d).
* Access to the lock should be enclosed in a try/finally block
* in order to ensure that the lock is always released in case of
* exceptions:name parameter passed to this object's constructor is used
* as a key to look up the holiday's localized name in a ResourceBundle object
* named HolidayBundle.
*
* @param locale A locale specifying the language in which the name is desired.
*
* @see ResourceBundle
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public String getDisplayName(Locale locale)
{
return getDisplayName(ULocale.forLocale(locale));
}
/**
* Return the name of this holiday in the language of the specified locale
* The name parameter passed to this object's constructor is used
* as a key to look up the holiday's localized name in a ResourceBundle object
* named HolidayBundle.
*
* @param locale A locale specifying the language in which the name is desired.
*
* @see ResourceBundle
* @draft ICU 3.2
* @provisional This API might change or be removed in a future release.
*/
public String getDisplayName(ULocale locale)
{
String dispName = name;
try {
ResourceBundle bundle = UResourceBundle.getBundleInstance("com.ibm.icu.impl.data.HolidayBundle", locale);
dispName = bundle.getString(name);
}
catch (MissingResourceException e) {
}
return dispName;
}
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public DateRule getRule() {
return rule;
}
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public void setRule(DateRule rule) {
this.rule = rule;
}
private String name;
private DateRule rule;
private static Holiday[] noHolidays = {};
}
icu4j-4.2.1.1/src/com/ibm/icu/util/CaseInsensitiveString.java 0000644 0001750 0001750 00000004605 10666355147 023652 0 ustar twerner twerner /**
*******************************************************************************
* Copyright (C) 2001-2007, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import com.ibm.icu.lang.UCharacter;
/**
* A string used as a key in java.util.Hashtable and other
* collections. It retains case information, but its equals() and
* hashCode() methods ignore case.
* @stable ICU 2.0
*/
public class CaseInsensitiveString {
private String string;
private int hash = 0;
private String folded = null;
private static String foldCase(String foldee)
{
return UCharacter.foldCase(foldee, true);
}
private void getFolded()
{
if (folded == null) {
folded = foldCase(string);
}
}
/**
* Constructs an CaseInsentiveString object from the given string
* @param s The string to construct this object from
* @stable ICU 2.0
*/
public CaseInsensitiveString(String s) {
string = s;
}
/**
* returns the underlying string
* @return String
* @stable ICU 2.0
*/
public String getString() {
return string;
}
/**
* Compare the object with this
* @param o Object to compare this object with
* @stable ICU 2.0
*/
public boolean equals(Object o) {
getFolded();
try {
CaseInsensitiveString cis = (CaseInsensitiveString) o;
cis.getFolded();
return folded.equals(cis.folded);
} catch (ClassCastException e) {
try {
String s = (String) o;
return folded.equals(foldCase(s));
} catch (ClassCastException e2) {
return false;
}
}
}
/**
* Returns the hashCode of this object
* @return int hashcode
* @stable ICU 2.0
*/
public int hashCode() {
getFolded();
if (hash == 0) {
hash = folded.hashCode();
}
return hash;
}
/**
* Overrides superclass method
* @stable ICU 3.6
*/
public String toString() {
return string;
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/TimeUnitAmount.java 0000644 0001750 0001750 00000002063 11157074147 022277 0 ustar twerner twerner /*
**************************************************************************
* Copyright (C) 2008-2009, Google, International Business Machines
* Corporation and others. All Rights Reserved.
**************************************************************************
*/
package com.ibm.icu.util;
/**
* Express a duration as a time unit and number. Patterned after Currency.
*
* root.res
* |
* --------
* | |
* fr.res en.res
* |
* --------
* | |
* fr_CA.res fr_FR.res
*
* JAVA/JDK:
*
* LocaleElements.res
* |
* -------------------
* | |
* LocaleElements_fr.res LocaleElements_en.res
* |
* ---------------------------
* | |
* LocaleElements_fr_CA.res LocaleElements_fr_FR.res
*
* Depending on the organization of your resources, the syntax to getBundleInstance will change.
* To open ICU style organization use:
*
* UResourceBundle bundle = UResourceBundle.getBundleInstance("com/mycompany/resources", "en_US", myClassLoader);
*
* To open Java/JDK style organization use:
*
* UResourceBundle bundle = UResourceBundle.getBundleInstance("com.mycompany.resources.LocaleElements", "en_US", myClassLoader);
*
*
* Note: Please use this API for loading non-ICU resources. Java security does not
* allow loading of resources across jar files. You must provide your class loader
* to load the resources
* @param baseName string containing the name of the data package.
* If null the default ICU package name is used.
* @param locale specifies the locale for which we want to open the resource.
* If null the bundle for default locale is opened.
* @param loader the loader to use
* @return a resource bundle for the given base name and locale
* @stable ICU 3.8
*/
public static UResourceBundle getBundleInstance(String baseName, ULocale locale, ClassLoader loader) {
if (baseName == null) {
baseName = ICUResourceBundle.ICU_BASE_NAME;
}
if (locale == null) {
locale = ULocale.getDefault();
}
return getBundleInstance(baseName, locale.toString(), loader, false);
}
/**
* Returns the RFC 3066 conformant locale id of this resource bundle.
* This method can be used after a call to getBundleInstance() to
* determine whether the resource bundle returned really
* corresponds to the requested locale or is a fallback.
*
* @return the locale of this resource bundle
* @stable ICU 3.0
*/
public abstract ULocale getULocale();
/**
* Gets the localeID
* @return The string representation of the localeID
* @stable ICU 3.0
*/
protected abstract String getLocaleID();
/**
* Gets the base name of the resource bundle
* @return The string representation of the base name
* @stable ICU 3.0
*/
protected abstract String getBaseName();
/**
* Gets the parent bundle
* @return The parent bundle
* @stable ICU 3.0
*/
protected abstract UResourceBundle getParent();
/**
* Get the locale of this bundle
* @return the locale of this resource bundle
* @stable ICU 3.0
*/
public Locale getLocale(){
return getULocale().toLocale();
}
// Cache for ResourceBundle instantiation
private static ICUCache BUNDLE_CACHE = new SimpleCache();
/**
* @internal
*/
public static void resetBundleCache()
{
/*
* A HACK!!!!!
* Currently if a resourcebundle with fallback turned ON is added to the cache
* and then a getBundleInstance() is called for a bundle with fallback turned OFF
* it will actually search the cache for any bundle of the same locale
* regaurdless of fallback status. This method has been created so that if
* The calling method KNOWS that instances of the other fallback state may be in the
* cache, the calling method may call this method to clear out the cache.
*
*/
//TODO figure a way around this method(see method comment)
BUNDLE_CACHE = new SimpleCache();
}
private static void addToCache(ResourceCacheKey key, UResourceBundle b) {
BUNDLE_CACHE.put(key, b);
}
/**
* Method used by subclasses to add the a particular resource bundle object to the managed cache
* @internal revisit for ICU 3.6
* @deprecated This API is ICU internal only.
*/
protected static void addToCache(ClassLoader cl, String fullName, ULocale defaultLocale, UResourceBundle b){
synchronized(cacheKey){
cacheKey.setKeyValues(cl, fullName, defaultLocale);
addToCache((ResourceCacheKey)cacheKey.clone(), b);
}
}
/**
* Method used by sub classes to load a resource bundle object from the managed cache
* @internal revisit for ICU 3.6
* @deprecated This API is ICU internal only.
*/
protected static UResourceBundle loadFromCache(ClassLoader cl, String fullName, ULocale defaultLocale){
synchronized(cacheKey){
cacheKey.setKeyValues(cl, fullName, defaultLocale);
return loadFromCache(cacheKey);
}
}
private static UResourceBundle loadFromCache(ResourceCacheKey key) {
return (UResourceBundle)BUNDLE_CACHE.get(key);
}
/**
* Key used for cached resource bundles. The key checks
* the resource name, the class root, and the default
* locale to determine if the resource is a match to the
* requested one. The root may be null, but the
* searchName and the default locale must have a non-null value.
* Note that the default locale may change over time, and
* lookup should always be based on the current default
* locale (if at all).
*/
private static final class ResourceCacheKey implements Cloneable {
private SoftReference loaderRef;
private String searchName;
private ULocale defaultLocale;
private int hashCodeCache;
///CLOVER:OFF
public boolean equals(Object other) {
if (this == other) {
return true;
}
try {
final ResourceCacheKey otherEntry = (ResourceCacheKey) other;
//quick check to see if they are not equal
if (hashCodeCache != otherEntry.hashCodeCache) {
return false;
}
//are the names the same?
if (!searchName.equals(otherEntry.searchName)) {
return false;
}
// are the default locales the same?
if (defaultLocale == null) {
if (otherEntry.defaultLocale != null) {
return false;
}
} else {
if (!defaultLocale.equals(otherEntry.defaultLocale)) {
return false;
}
}
//are refs (both non-null) or (both null)?
if (loaderRef == null) {
return otherEntry.loaderRef == null;
} else {
return (otherEntry.loaderRef != null)
&& (loaderRef.get() == otherEntry.loaderRef.get());
}
} catch (NullPointerException e) {
return false;
} catch (ClassCastException e) {
return false;
}
}
public int hashCode() {
return hashCodeCache;
}
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
//this should never happen
throw new IllegalStateException();
}
}
///CLOVER:ON
private synchronized void setKeyValues(ClassLoader root, String searchName, ULocale defaultLocale) {
this.searchName = searchName;
hashCodeCache = searchName.hashCode();
this.defaultLocale = defaultLocale;
if (defaultLocale != null) {
hashCodeCache ^= defaultLocale.hashCode();
}
if (root == null) {
this.loaderRef = null;
} else {
loaderRef = new SoftReference(root);
hashCodeCache ^= root.hashCode();
}
}
/*private void clear() {
setKeyValues(null, "", null);
}*/
}
private static final ResourceCacheKey cacheKey = new ResourceCacheKey();
private static final int ROOT_MISSING = 0;
private static final int ROOT_ICU = 1;
private static final int ROOT_JAVA = 2;
private static SoftReference ROOT_CACHE;
private static int getRootType(String baseName, ClassLoader root)
{
Map m = null;
Integer rootType;
if (ROOT_CACHE != null) {
m = (Map) ROOT_CACHE.get();
}
if (m == null) {
m = new HashMap();
ROOT_CACHE = new SoftReference(m);
}
rootType = (Integer) m.get(baseName);
if (rootType == null) {
String rootLocale = (baseName.indexOf('.')==-1) ? "root" : "";
int rt = ROOT_MISSING; // value set on success
try{
ICUResourceBundle.getBundleInstance(baseName, rootLocale, root, true);
rt = ROOT_ICU;
}catch(MissingResourceException ex){
try{
ResourceBundleWrapper.getBundleInstance(baseName, rootLocale, root, true);
rt = ROOT_JAVA;
}catch(MissingResourceException e){
//throw away the exception
}
}
rootType = new Integer(rt);
m.put(baseName, rootType);
}
return rootType.intValue();
}
private static void setRootType(String baseName, int rootType)
{
Integer rt = new Integer(rootType);
Map m = null;
if (ROOT_CACHE != null) {
m = (Map) ROOT_CACHE.get();
} else {
m = new HashMap();
ROOT_CACHE = new SoftReference(m);
}
m.put(baseName, rt);
}
/**
* Loads a new resource bundle for the give base name, locale and class loader.
* Optionally will disable loading of fallback bundles.
* @param baseName the base name of the resource bundle, a fully qualified class name
* @param localeName the locale for which a resource bundle is desired
* @param root the class object from which to load the resource bundle
* @param disableFallback disables loading of fallback lookup chain
* @exception MissingResourceException
* if no resource bundle for the specified base name can be found
* @return a resource bundle for the given base name and locale
* @stable ICU 3.0
*/
protected static UResourceBundle instantiateBundle(String baseName, String localeName,
ClassLoader root, boolean disableFallback){
UResourceBundle b = null;
int rootType = getRootType(baseName, root);
ULocale defaultLocale = ULocale.getDefault();
switch (rootType)
{
case ROOT_ICU:
if(disableFallback) {
String fullName = ICUResourceBundleReader.getFullName(baseName, localeName);
synchronized(cacheKey){
cacheKey.setKeyValues(root, fullName, defaultLocale);
b = loadFromCache(cacheKey);
}
if (b == null) {
b = ICUResourceBundle.getBundleInstance(baseName, localeName, root, disableFallback);
//cacheKey.setKeyValues(root, fullName, defaultLocale);
addToCache(cacheKey, b);
}
} else {
b = ICUResourceBundle.getBundleInstance(baseName, localeName, root, disableFallback);
}
return b;
case ROOT_JAVA:
return ResourceBundleWrapper.getBundleInstance(baseName, localeName, root, disableFallback);
default:
try{
b = ICUResourceBundle.getBundleInstance(baseName, localeName, root, disableFallback);
setRootType(baseName, ROOT_ICU);
}catch(MissingResourceException ex){
b = ResourceBundleWrapper.getBundleInstance(baseName, localeName, root, disableFallback);
setRootType(baseName, ROOT_JAVA);
}
return b;
}
}
/**
* Returns a binary data from a binary resource.
*
* @return a pointer to a chuck of unsigned bytes which live in a memory mapped/DLL file.
* @see #getIntVector
* @see #getInt
* @throws MissingResourceException
* @throws UResourceTypeMismatchException
* @stable ICU 3.8
*/
public ByteBuffer getBinary() {
throw new UResourceTypeMismatchException("");
}
/**
* Returns a string from a string resource type
*
* @return a string
* @see #getBinary()
* @see #getIntVector
* @see #getInt
* @throws MissingResourceException
* @throws UResourceTypeMismatchException
* @stable ICU 3.8
*/
public String getString() {
throw new UResourceTypeMismatchException("");
}
/**
* Returns a string array from a array resource type
*
* @return a string
* @see #getString()
* @see #getIntVector
* @throws MissingResourceException
* @throws UResourceTypeMismatchException
* @stable ICU 3.8
*/
public String[] getStringArray() {
throw new UResourceTypeMismatchException("");
}
/**
* Returns a binary data from a binary resource.
*
* @param ba The byte array to write the bytes to. A null variable is OK.
* @return an array bytes containing the binary data from the resource.
* @see #getIntVector
* @see #getInt
* @throws MissingResourceException
* @throws UResourceTypeMismatchException
* @stable ICU 3.8
*/
public byte[] getBinary(byte[] ba) {
throw new UResourceTypeMismatchException("");
}
/**
* Returns a 32 bit integer array from a resource.
*
* @return a pointer to a chunk of unsigned bytes which live in a memory mapped/DLL file.
* @see #getBinary()
* @see #getInt
* @throws MissingResourceException
* @throws UResourceTypeMismatchException
* @stable ICU 3.8
*/
public int[] getIntVector() {
throw new UResourceTypeMismatchException("");
}
/**
* Returns a signed integer from a resource.
*
* @return an integer value
* @see #getIntVector
* @see #getBinary()
* @throws MissingResourceException
* @throws UResourceTypeMismatchException
* @stable ICU 3.8
*/
public int getInt() {
throw new UResourceTypeMismatchException("");
}
/**
* Returns a unsigned integer from a resource.
* This integer is originally 28 bit and the sign gets propagated.
*
* @return an integer value
* @see #getIntVector
* @see #getBinary()
* @throws MissingResourceException
* @throws UResourceTypeMismatchException
* @stable ICU 3.8
*/
public int getUInt() {
throw new UResourceTypeMismatchException("");
}
/**
* Returns a resource in a given resource that has a given key.
*
* @param aKey a key associated with the wanted resource
* @return a resource bundle object representing the resource
* @throws MissingResourceException
* @stable ICU 3.8
*/
public UResourceBundle get(String aKey) {
UResourceBundle obj = handleGet(aKey, null, this);
if (obj == null) {
UResourceBundle res = this;
while ((res = res.getParent()) != null && obj == null) {
//call the get method to recursively fetch the resource
obj = res.handleGet(aKey, null, this);
}
if (obj == null) {
String fullName = ICUResourceBundleReader.getFullName(
getBaseName(), getLocaleID());
throw new MissingResourceException(
"Can't find resource for bundle " + fullName + ", key "
+ aKey, this.getClass().getName(), aKey);
}
}
((ICUResourceBundle)obj).setLoadingStatus(getLocaleID());
return obj;
}
/**
* Returns the string in a given resource at the specified index.
*
* @param index an index to the wanted string.
* @return a string which lives in the resource.
* @throws IndexOutOfBoundsException
* @throws UResourceTypeMismatchException
* @stable ICU 3.8
*/
public String getString(int index) {
ICUResourceBundle temp = (ICUResourceBundle)get(index);
if (temp.getType() == STRING) {
return temp.getString();
}
throw new UResourceTypeMismatchException("");
}
/**
* Returns the resource in a given resource at the specified index.
*
* @param index an index to the wanted resource.
* @return the sub resource UResourceBundle object
* @throws IndexOutOfBoundsException
* @throws MissingResourceException
* @stable ICU 3.8
*/
public UResourceBundle get(int index) {
UResourceBundle obj = handleGet(index, null, this);
if (obj == null) {
obj = (ICUResourceBundle) getParent();
if (obj != null) {
obj = obj.get(index);
}
if (obj == null)
throw new MissingResourceException(
"Can't find resource for bundle "
+ this.getClass().getName() + ", key "
+ getKey(), this.getClass().getName(), getKey());
}
((ICUResourceBundle)obj).setLoadingStatus(getLocaleID());
return obj;
}
/**
* Returns the keys in this bundle as an enumeration
* @return an enumeration containing key strings
* @stable ICU 3.8
*/
public Enumeration getKeys() {
initKeysVector();
return keys.elements();
}
private Vector keys = null;
private synchronized void initKeysVector(){
if(keys!=null){
return;
}
//ICUResourceBundle current = this;
keys = new Vector();
Enumeration e = this.handleGetKeys();
while(e.hasMoreElements()){
String elem = (String)e.nextElement();
if(!keys.contains(elem)){
keys.add(elem);
}
}
}
/**
* Returns the size of a resource. Size for scalar types is always 1,
* and for vector/table types is the number of child resources.
*
Warning: Integer array is treated as a scalar type. There are no
* APIs to access individual members of an integer array. It
* is always returned as a whole.
* @return number of resources in a given resource.
* @stable ICU 3.8
*/
public int getSize() {
return size;
}
/**
* Returns the type of a resource.
* Available types are {@link #INT INT}, {@link #ARRAY ARRAY},
* {@link #BINARY BINARY}, {@link #INT_VECTOR INT_VECTOR},
* {@link #STRING STRING}, {@link #TABLE TABLE}.
*
* @return type of the given resource.
* @stable ICU 3.8
*/
public int getType() {
int type = ICUResourceBundle.RES_GET_TYPE(resource);
if(type==TABLE32){
return TABLE; //Mask the table32's real type
}
return type;
}
/**
* Return the version number associated with this UResourceBundle as an
* VersionInfo object.
* @return VersionInfo object containing the version of the bundle
* @stable ICU 3.8
*/
public VersionInfo getVersion() {
return null;
}
/**
* Returns the iterator which iterates over this
* resource bundle
* @return UResourceBundleIterator that iterates over the resources in the bundle
* @stable ICU 3.8
*/
public UResourceBundleIterator getIterator() {
return new UResourceBundleIterator(this);
}
/**
* Returns the key associated with a given resource. Not all the resources have a key - only
* those that are members of a table.
* @return a key associated to this resource, or null if it doesn't have a key
* @stable ICU 3.8
*/
public String getKey() {
return key;
}
/**
* Resource type constant for "no resource".
* @stable ICU 3.8
*/
public static final int NONE = -1;
/**
* Resource type constant for strings.
* @stable ICU 3.8
*/
public static final int STRING = 0;
/**
* Resource type constant for binary data.
* @stable ICU 3.8
*/
public static final int BINARY = 1;
/**
* Resource type constant for tables of key-value pairs.
* @stable ICU 3.8
*/
public static final int TABLE = 2;
/**
* Resource type constant for aliases;
* internally stores a string which identifies the actual resource
* storing the data (can be in a different resource bundle).
* Resolved internally before delivering the actual resource through the API.
* @internal ICU 3.8
* @deprecated This API is ICU internal only.
*/
protected static final int ALIAS = 3;
/**
* Internal use only.
* Alternative resource type constant for tables of key-value pairs.
* Never returned by getType().
* @internal ICU 3.8
* @deprecated This API is ICU internal only.
*/
protected static final int TABLE32 = 4;
/**
* Resource type constant for a single 28-bit integer, interpreted as
* signed or unsigned by the getInt() function.
* @see #getInt
* @stable ICU 3.8
*/
public static final int INT = 7;
/**
* Resource type constant for arrays of resources.
* @stable ICU 3.8
*/
public static final int ARRAY = 8;
/**
* Resource type constant for vectors of 32-bit integers.
* @see #getIntVector
* @stable ICU 3.8
*/
public static final int INT_VECTOR = 14;
//====== protected members ==============
/**
* Data member where the subclasses store the key
* @internal
* @deprecated This API is ICU internal only.
*/
protected String key;
/**
* Data member where the subclasses store the size of resources
* @internal
* @deprecated This API is ICU internal only.
*/
protected int size = 1;
/**
* Data member where the subclasses store the offset within resource data
* @internal
* @deprecated This API is ICU internal only.
*/
protected long resource = RES_BOGUS;
/**
* Data member where the subclasses store whether the resource is top level
* @internal
* @deprecated This API is ICU internal only.
*/
protected boolean isTopLevel = false;
private static final long RES_BOGUS = 0xffffffff;
/**
* Actual worker method for fetching a resource based on the given key.
* Sub classes must override this method if they support resources with keys.
* @param aKey the key string of the resource to be fetched
* @param table hashtable object to hold references of resources already seen
* @param requested the original resource bundle object on which the get method was invoked.
* The requested bundle and the bundle on which this method is invoked
* are the same, except in the cases where aliases are involved.
* @return UResourceBundle a resource associated with the key
* @stable ICU 3.8
*/
protected UResourceBundle handleGet(String aKey, HashMap table, UResourceBundle requested) {
return null;
}
/**
* Actual worker method for fetching a resource based on the given index.
* Sub classes must override this method if they support arrays of resources.
* @param index the index of the resource to be fetched
* @param table hashtable object to hold references of resources already seen
* @param requested the original resource bundle object on which the get method was invoked.
* The requested bundle and the bundle on which this method is invoked
* are the same, except in the cases where aliases are involved.
* @return UResourceBundle a resource associated with the index
* @stable ICU 3.8
*/
protected UResourceBundle handleGet(int index, HashMap table, UResourceBundle requested) {
return null;
}
/**
* Actual worker method for fetching the array of strings in a resource.
* Sub classes must override this method if they support arrays of strings.
* @return String[] An array of strings containing strings
* @stable ICU 3.8
*/
protected String[] handleGetStringArray() {
return null;
}
/**
* Actual worker method for fetching the keys of resources contained in the resource.
* Sub classes must override this method if they support keys and associated resources.
*
* @return Enumeration An enumeration of all the keys in this resource.
* @stable ICU 3.8
*/
protected Enumeration handleGetKeys(){
Vector resKeys = new Vector();
UResourceBundle item = null;
for (int i = 0; i < size; i++) {
item = get(i);
resKeys.add(item.getKey());
}
return resKeys.elements();
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
// this method is declared in ResourceBundle class
// so cannot change the signature
// Override this method
protected Object handleGetObject(String aKey) {
return handleGetObjectImpl(aKey, this);
}
/**
* Override the superclass method
*/
// To facilitate XPath style aliases we need a way to pass the reference
// to requested locale. The only way I could figure out is to implement
// the look up logic here. This has a disadvantage that if the client
// loads an ICUResourceBundle, calls ResourceBundle.getObject method
// with a key that does not exist in the bundle then the lookup is
// done twice before throwing a MissingResourceExpection.
private Object handleGetObjectImpl(String aKey, UResourceBundle requested) {
Object obj = resolveObject(aKey, requested);
if (obj == null) {
UResourceBundle parentBundle = getParent();
if (parentBundle != null) {
obj = parentBundle.handleGetObjectImpl(aKey, requested);
}
if (obj == null)
throw new MissingResourceException(
"Can't find resource for bundle "
+ this.getClass().getName() + ", key " + aKey,
this.getClass().getName(), aKey);
}
return obj;
}
// Routine for figuring out the type of object to be returned
// string or string array
private Object resolveObject(String aKey, UResourceBundle requested) {
if (getType() == STRING) {
return getString();
}
UResourceBundle obj = handleGet(aKey, null, requested);
if (obj != null) {
if (obj.getType() == STRING) {
return obj.getString();
}
try {
if (obj.getType() == ARRAY) {
return obj.handleGetStringArray();
}
} catch (UResourceTypeMismatchException ex) {
return obj;
}
}
return obj;
}
/**
* This method is for setting the loading status of the resource.
* The status is analogous to the warning status in ICU4C.
* @internal ICU 3.8
* @deprecated This API is ICU internal only.
*/
protected abstract void setLoadingStatus(int newStatus);
}
icu4j-4.2.1.1/src/com/ibm/icu/util/RangeDateRule.java 0000644 0001750 0001750 00000011174 10666355147 022050 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2006, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.Date;
import java.util.Vector;
/**
* Implementation of DateRule that takes a range.
* @draft ICU 2.8 (retainAll)
* @provisional This API might change or be removed in a future release.
*/
public class RangeDateRule implements DateRule {
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public RangeDateRule() {
}
/**
* @internal
*/
// Range is a package-private class so this should be package-private too, probably
// public RangeDateRule(Range[] ranges)
// {
// for (int i = 0; i < ranges.length; i++) {
// this.ranges.addElement(ranges[i]);
// }
// }
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public void add(DateRule rule) {
add(new Date(Long.MIN_VALUE), rule);
}
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public void add(Date start, DateRule rule) {
// TODO: Insert in the right place
// System.out.println("Add: " + start.toString());
ranges.addElement(new Range(start, rule));
}
//-----------------------------------------------------------------------
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public Date firstAfter(Date start) {
// Find the range that I should look at
int index = startIndex(start);
if (index == ranges.size()) {
index = 0;
}
Date result = null;
Range r = rangeAt(index);
Range e = rangeAt(index+1);
if (r != null && r.rule != null)
{
if (e != null) {
result = r.rule.firstBetween(start, e.start);
} else {
result = r.rule.firstAfter(start);
}
}
return result;
}
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public Date firstBetween(Date start, Date end) {
if (end == null) {
return firstAfter(start);
}
// Find the range that I should look at
int index = startIndex(start);
Date result = null;
Range next = rangeAt(index);
while (result == null && next != null && !next.start.after(end))
{
Range r = next;
next = rangeAt(index+1);
if (r.rule != null) {
Date e = (next != null && !next.start.after(end)) ? next.start
: end;
result = r.rule.firstBetween(start, e);
}
}
return result;
}
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public boolean isOn(Date date) {
Range r = rangeAt(startIndex(date));
return r != null && r.rule != null && r.rule.isOn(date);
}
/**
* Check whether this event occurs at least once between the two
* dates given.
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public boolean isBetween(Date start, Date end) {
return firstBetween(start,end) == null;
}
/*
* find the index of the last range whose start date is before "start"
* returns an index >= ranges.size() if there is none
*/
private int startIndex(Date start) {
int lastIndex = ranges.size();
for (int i = 0; i < ranges.size(); i++) {
Range r = (Range) ranges.elementAt(i);
if (start.before(r.start)) {
break;
}
lastIndex = i;
}
return lastIndex;
}
private Range rangeAt(int index) {
return (index < ranges.size()) ? (Range) ranges.elementAt(index)
: null;
}
Vector ranges = new Vector(2,2);
}
//-----------------------------------------------------------------------
// Privates
//
class Range {
public Range(Date start, DateRule rule) {
this.start = start;
this.rule = rule;
}
public Date start;
public DateRule rule;
}
icu4j-4.2.1.1/src/com/ibm/icu/util/TimeZone.java 0000644 0001750 0001750 00000102766 11334633616 021121 0 ustar twerner twerner /*
* @(#)TimeZone.java 1.51 00/01/19
*
* Copyright (C) 1996-2010, International Business Machines
* Corporation and others. All Rights Reserved.
*/
package com.ibm.icu.util;
import java.io.Serializable;
import java.util.Date;
import java.util.Locale;
import java.util.MissingResourceException;
import com.ibm.icu.impl.Grego;
import com.ibm.icu.impl.ICUCache;
import com.ibm.icu.impl.ICUConfig;
import com.ibm.icu.impl.JavaTimeZone;
import com.ibm.icu.impl.SimpleCache;
import com.ibm.icu.impl.TimeZoneAdapter;
import com.ibm.icu.impl.ZoneMeta;
import com.ibm.icu.text.SimpleDateFormat;
/**
* TimeZone represents a time zone offset, and also figures out daylight
* savings.
*
* TimeZone using getDefault
* which creates a TimeZone based on the time zone where the program
* is running. For example, for a program running in Japan, getDefault
* creates a TimeZone object based on Japanese Standard Time.
*
* TimeZone using getTimeZone
* along with a time zone ID. For instance, the time zone ID for the
* U.S. Pacific Time zone is "America/Los_Angeles". So, you can get a
* U.S. Pacific Time TimeZone object with:
*
*
* You can use
* TimeZone tz = TimeZone.getTimeZone("America/Los_Angeles");
*
* getAvailableIDs method to iterate through
* all the supported time zone IDs. You can then choose a
* supported ID to get a TimeZone.
* If the time zone you want is not represented by one of the
* supported IDs, then you can create a custom time zone ID with
* the following syntax:
*
*
*
*
* For example, you might specify GMT+14:00 as a custom
* time zone ID. The
* GMT[+|-]hh[[:]mm]
*
* TimeZone that is returned
* when you specify a custom time zone ID does not include
* daylight savings time.
* TimeZone as the time zone implementation. The TimeZone factory
* method getTimeZone creates an instance of ICU's own TimeZone
* subclass by default. If you want to use the JDK implementation always, you can
* set the default time zone implementation type by the new method
* setDefaultTimeZoneType. Alternatively, you can change the initial
* default implementation type by setting a property below.
*
*
*
*
*
* #
* # The default TimeZone implementation type used by the ICU TimeZone
* # factory method. [ ICU | JDK ]
* #
* com.ibm.icu.util.TimeZone.DefaultTimeZoneType = ICU
*
* TimeZone class is loaded, the initialization code checks
* if the property com.ibm.icu.util.TimeZone.DefaultTimeZoneType=xxx
* is defined by the system properties. If not available, then it loads ICUConfig.properties
* to get the default time zone implementation type. The property setting is
* only used for the initial default value and you can change the default type
* by setDefaultTimeZoneType at runtime.
*
* @see Calendar
* @see GregorianCalendar
* @see SimpleTimeZone
* @author Mark Davis, David Goldsmith, Chen-Lieh Huang, Alan Liu
* @stable ICU 2.0
*/
abstract public class TimeZone implements Serializable, Cloneable {
// using serialver from jdk1.4.2_05
private static final long serialVersionUID = -744942128318337471L;
/**
* Default constructor. (For invocation by subclass constructors,
* typically implicit.)
* @stable ICU 2.8
*/
public TimeZone() {
}
/**
* A time zone implementation type indicating ICU's own TimeZone used by
* getTimeZone, setDefaultTimeZoneType
* and getDefaultTimeZoneType.
* @stable ICU 4.0
*/
public static final int TIMEZONE_ICU = 0;
/**
* A time zone implementation type indicating JDK TimeZone used by
* getTimeZone, setDefaultTimeZoneType
* and getDefaultTimeZoneType.
* @stable ICU 4.0
*/
public static final int TIMEZONE_JDK = 1;
/**
* A style specifier for getDisplayName() indicating
* a short name, such as "PST."
* @see #LONG
* @stable ICU 2.0
*/
public static final int SHORT = 0;
/**
* A style specifier for getDisplayName() indicating
* a long name, such as "Pacific Standard Time."
* @see #SHORT
* @stable ICU 2.0
*/
public static final int LONG = 1;
/**
* @internal
* @deprecated This API is ICU internal only.
*/
/*
private static final int SHORT_GENERIC = 2;
*/
/**
* @internal
* @deprecated This API is ICU internal only.
*/
private static final int LONG_GENERIC = 3;
/**
* Cache to hold the SimpleDateFormat objects for a Locale.
*/
private static ICUCache cachedLocaleData = new SimpleCache();
/**
* Gets the time zone offset, for current date, modified in case of
* daylight savings. This is the offset to add *to* UTC to get local time.
* @param era the era of the given date.
* @param year the year in the given date.
* @param month the month in the given date.
* Month is 0-based. e.g., 0 for January.
* @param day the day-in-month of the given date.
* @param dayOfWeek the day-of-week of the given date.
* @param milliseconds the millis in day in standard local time.
* @return the offset to add *to* GMT to get local time.
* @stable ICU 2.0
*/
abstract public int getOffset(int era, int year, int month, int day,
int dayOfWeek, int milliseconds);
/**
* Returns the offset of this time zone from UTC at the specified
* date. If Daylight Saving Time is in effect at the specified
* date, the offset value is adjusted with the amount of daylight
* saving.
*
* @param date the date represented in milliseconds since January 1, 1970 00:00:00 GMT
* @return the amount of time in milliseconds to add to UTC to get local time.
*
* @see Calendar#ZONE_OFFSET
* @see Calendar#DST_OFFSET
* @see #getOffset(long, boolean, int[])
* @stable ICU 2.8
*/
public int getOffset(long date) {
int[] result = new int[2];
getOffset(date, false, result);
return result[0]+result[1];
}
/**
* Returns the time zone raw and GMT offset for the given moment
* in time. Upon return, local-millis = GMT-millis + rawOffset +
* dstOffset. All computations are performed in the proleptic
* Gregorian calendar. The default implementation in the TimeZone
* class delegates to the 8-argument getOffset().
*
* @param date moment in time for which to return offsets, in
* units of milliseconds from January 1, 1970 0:00 GMT, either GMT
* time or local wall time, depending on `local'.
* @param local if true, `date' is local wall time; otherwise it
* is in GMT time.
* @param offsets output parameter to receive the raw offset, that
* is, the offset not including DST adjustments, in offsets[0],
* and the DST offset, that is, the offset to be added to
* `rawOffset' to obtain the total offset between local and GMT
* time, in offsets[1]. If DST is not in effect, the DST offset is
* zero; otherwise it is a positive value, typically one hour.
*
* @stable ICU 2.8
*/
public void getOffset(long date, boolean local, int[] offsets) {
offsets[0] = getRawOffset();
if (!local) {
date += offsets[0]; // now in local standard millis
}
// When local == true, date might not be in local standard
// millis. getOffset taking 6 parameters used here assume
// the given time in day is local standard time.
// At STD->DST transition, there is a range of time which
// does not exist. When 'date' is in this time range
// (and local == true), this method interprets the specified
// local time as DST. At DST->STD transition, there is a
// range of time which occurs twice. In this case, this
// method interprets the specified local time as STD.
// To support the behavior above, we need to call getOffset
// (with 6 args) twice when local == true and DST is
// detected in the initial call.
int fields[] = new int[6];
for (int pass = 0; ; pass++) {
Grego.timeToFields(date, fields);
offsets[1] = getOffset(GregorianCalendar.AD,
fields[0], fields[1], fields[2],
fields[3], fields[5]) - offsets[0];
if (pass != 0 || !local || offsets[1] == 0) {
break;
}
// adjust to local standard millis
date -= offsets[1];
}
}
/**
* Sets the base time zone offset to GMT.
* This is the offset to add *to* UTC to get local time.
* @param offsetMillis the given base time zone offset to GMT.
* @stable ICU 2.0
*/
abstract public void setRawOffset(int offsetMillis);
/**
* Gets unmodified offset, NOT modified in case of daylight savings.
* This is the offset to add *to* UTC to get local time.
* @return the unmodified offset to add *to* UTC to get local time.
* @stable ICU 2.0
*/
abstract public int getRawOffset();
/**
* Gets the ID of this time zone.
* @return the ID of this time zone.
* @stable ICU 2.0
*/
public String getID() {
return ID;
}
/**
* Sets the time zone ID. This does not change any other data in
* the time zone object.
* @param ID the new time zone ID.
* @stable ICU 2.0
*/
public void setID(String ID) {
if (ID == null) {
throw new NullPointerException();
}
this.ID = ID;
}
/**
* Returns a name of this time zone suitable for presentation to the user
* in the default locale.
* This method returns the long generic name.
* If the display name is not available for the locale,
* a fallback based on the country, city, or time zone id will be used.
* @return the human-readable name of this time zone in the default locale.
* @stable ICU 2.0
*/
public final String getDisplayName() {
return _getDisplayName(false, LONG_GENERIC, ULocale.getDefault());
}
/**
* Returns a name of this time zone suitable for presentation to the user
* in the specified locale.
* This method returns the long generic name.
* If the display name is not available for the locale,
* a fallback based on the country, city, or time zone id will be used.
* @param locale the locale in which to supply the display name.
* @return the human-readable name of this time zone in the given locale
* or in the default locale if the given locale is not recognized.
* @stable ICU 2.0
*/
public final String getDisplayName(Locale locale) {
return _getDisplayName(false, LONG_GENERIC, ULocale.forLocale(locale));
}
/**
* Returns a name of this time zone suitable for presentation to the user
* in the specified locale.
* This method returns the long name, not including daylight savings.
* If the display name is not available for the locale,
* a fallback based on the country, city, or time zone id will be used.
* @param locale the ulocale in which to supply the display name.
* @return the human-readable name of this time zone in the given locale
* or in the default ulocale if the given ulocale is not recognized.
* @stable ICU 3.2
*/
public final String getDisplayName(ULocale locale) {
return _getDisplayName(false, LONG_GENERIC, locale);
}
/**
* Returns a name of this time zone suitable for presentation to the user
* in the default locale.
* If the display name is not available for the locale,
* then this method returns a string in the format
* GMT[+-]hh:mm.
* @param daylight if true, return the daylight savings name.
* @param style either LONG or SHORT
* @return the human-readable name of this time zone in the default locale.
* @stable ICU 2.0
*/
public final String getDisplayName(boolean daylight, int style) {
return getDisplayName(daylight, style, ULocale.getDefault());
}
/**
* Returns a name of this time zone suitable for presentation to the user
* in the specified locale.
* If the display name is not available for the locale,
* then this method returns a string in the format
* GMT[+-]hh:mm.
* @param daylight if true, return the daylight savings name.
* @param style either LONG or SHORT
* @param locale the locale in which to supply the display name.
* @return the human-readable name of this time zone in the given locale
* or in the default locale if the given locale is not recognized.
* @exception IllegalArgumentException style is invalid.
* @stable ICU 2.0
*/
public String getDisplayName(boolean daylight, int style, Locale locale) {
return getDisplayName(daylight, style, ULocale.forLocale(locale));
}
/**
* Returns a name of this time zone suitable for presentation to the user
* in the specified locale.
* If the display name is not available for the locale,
* then this method returns a string in the format
* GMT[+-]hh:mm.
* @param daylight if true, return the daylight savings name.
* @param style either LONG or SHORT
* @param locale the locale in which to supply the display name.
* @return the human-readable name of this time zone in the given locale
* or in the default locale if the given locale is not recognized.
* @exception IllegalArgumentException style is invalid.
* @stable ICU 3.2
*/
public String getDisplayName(boolean daylight, int style, ULocale locale) {
if (style != SHORT && style != LONG) {
throw new IllegalArgumentException("Illegal style: " + style);
}
return _getDisplayName(daylight, style, locale);
}
/**
* The public version of this API only accepts LONG/SHORT, the
* internal version (which this calls) also accepts LONG_GENERIC/SHORT_GENERIC.
*/
private synchronized String _getDisplayName(boolean daylight, int style, ULocale locale) {
if (locale == null) {
throw new NullPointerException("locale is null");
}
/* NOTES:
* (1) We use SimpleDateFormat for simplicity; we could do this
* more efficiently but it would duplicate the SimpleDateFormat code
* here, which is undesirable.
* (2) Attempts to move the code from SimpleDateFormat to here also run
* around because this requires SimpleDateFormat to keep a Locale
* object around, which it currently doesn't; to synthesize such a
* locale upon resurrection; and to somehow handle the special case of
* construction from a DateFormatSymbols object.
*/
// We keep a cache, indexed by locale. The cache contains a
// SimpleDateFormat object, which we create on demand.
SimpleDateFormat format;
SimpleDateFormat tmpfmt = (SimpleDateFormat)cachedLocaleData.get(locale);
if (tmpfmt == null) {
format = new SimpleDateFormat(null, locale);
cachedLocaleData.put(locale, format);
} else {
format = (SimpleDateFormat)tmpfmt.clone();
}
String[] patterns = { "z", "zzzz", "v", "vvvv" };
format.applyPattern(patterns[style]);
format.setTimeZone(this);
Date d = new Date();
if (style >= 2) {
// Generic names may change time to time even for a single time zone.
// This method returns the one used for the zone now.
return format.format(d);
} else {
int[] offsets = new int[2];
getOffset(d.getTime(), false, offsets);
if ((daylight && offsets[1] != 0) || (!daylight && offsets[1] == 0)) {
return format.format(d);
}
// Create a new SimpleTimeZone as a stand-in for this zone; the stand-in
// will have no DST, or DST during July, but the same ID and offset,
// and hence the same display name. We don't cache these because
// they're small and cheap to create.
SimpleTimeZone tz;
if (daylight && useDaylightTime()) {
// The display name for daylight saving time was requested, but currently not in DST
// Set a fixed date (July 1) in this Gregorian year
GregorianCalendar cal = new GregorianCalendar(this);
cal.set(Calendar.MONTH, Calendar.JULY);
cal.set(Calendar.DATE, 1);
// Get July 1 date
d = cal.getTime();
// Check if it is in DST
if (cal.get(Calendar.DST_OFFSET) == 0) {
// We need to create a fake time zone
tz = new SimpleTimeZone(offsets[0], getID(),
Calendar.JUNE, 1, 0, 0,
Calendar.AUGUST, 1, 0, 0,
getDSTSavings());
format.setTimeZone(tz);
}
} else {
// The display name for standard time was requested, but currently in DST
// or display name for daylight saving time was requested, but this zone no longer
// observes DST.
tz = new SimpleTimeZone(offsets[0], getID());
format.setTimeZone(tz);
}
return format.format(d);
}
}
/**
* Returns the amount of time to be added to local standard time
* to get local wall clock time.
* TimeZone for the given ID.
*
* @param ID the ID for a TimeZone, such as "America/Los_Angeles",
* or a custom ID such as "GMT-8:00". Note that the support of abbreviations,
* such as "PST", is for JDK 1.1.x compatibility only and full names should be used.
*
* @return the specified TimeZone, or the GMT zone if the given ID
* cannot be understood.
* @stable ICU 2.0
*/
public static synchronized TimeZone getTimeZone(String ID) {
return getTimeZone(ID, TZ_IMPL);
}
/**
* Gets the TimeZone for the given ID and the timezone type.
* @param ID the ID for a TimeZone, such as "America/Los_Angeles",
* or a custom ID such as "GMT-8:00". Note that the support of abbreviations,
* such as "PST", is for JDK 1.1.x compatibility only and full names should be used.
* @param type Time zone type, either TIMEZONE_ICU or TIMEZONE_JDK.
* @return the specified TimeZone, or the GMT zone if the given ID
* cannot be understood.
* @stable ICU 4.0
*/
public static synchronized TimeZone getTimeZone(String ID, int type) {
TimeZone result;
if (type == TIMEZONE_JDK) {
result = new JavaTimeZone(ID);
} else {
/* We first try to lookup the zone ID in our system list. If this
* fails, we try to parse it as a custom string GMT[+-]hh:mm. If
* all else fails, we return GMT, which is probably not what the
* user wants, but at least is a functioning TimeZone object.
*
* We cannot return NULL, because that would break compatibility
* with the JDK.
*/
if(ID==null){
throw new NullPointerException();
}
result = ZoneMeta.getSystemTimeZone(ID);
if (result == null) {
result = ZoneMeta.getCustomTimeZone(ID);
}
if (result == null) {
result = ZoneMeta.getGMT();
}
}
return result;
}
/**
* Sets the default time zone type used by getTimeZone.
* @param type time zone type, either TIMEZONE_ICU or TIMEZONE_JDK.
* @stable ICU 4.0
*/
public static synchronized void setDefaultTimeZoneType(int type) {
if (type != TIMEZONE_ICU && type != TIMEZONE_JDK) {
throw new IllegalArgumentException("Invalid timezone type");
}
TZ_IMPL = type;
}
/**
* Returns the default time zone type currently used.
* @return The default time zone type, either TIMEZONE_ICU or TIMEZONE_JDK.
* @stable ICU 4.0
*/
public static int getDefaultTimeZoneType() {
return TZ_IMPL;
}
/**
* Return a new String array containing all system TimeZone IDs
* with the given raw offset from GMT. These IDs may be passed to
* get() to construct the corresponding TimeZone
* object.
* @param rawOffset the offset in milliseconds from GMT
* @return an array of IDs for system TimeZones with the given
* raw offset. If there are none, return a zero-length array.
* @stable ICU 2.0
*/
public static String[] getAvailableIDs(int rawOffset) {
return ZoneMeta.getAvailableIDs(rawOffset);
}
/**
* Return a new String array containing all system TimeZone IDs
* associated with the given country. These IDs may be passed to
* get() to construct the corresponding TimeZone
* object.
* @param country a two-letter ISO 3166 country code, or null
* to return zones not associated with any country
* @return an array of IDs for system TimeZones in the given
* country. If there are none, return a zero-length array.
* @stable ICU 2.0
*/
public static String[] getAvailableIDs(String country) {
return ZoneMeta.getAvailableIDs(country);
}
/**
* Return a new String array containing all system TimeZone IDs.
* These IDs (and only these IDs) may be passed to
* get() to construct the corresponding TimeZone
* object.
* @return an array of all system TimeZone IDs
* @stable ICU 2.0
*/
public static String[] getAvailableIDs() {
return ZoneMeta.getAvailableIDs();
}
/**
* Returns the number of IDs in the equivalency group that
* includes the given ID. An equivalency group contains zones
* that have the same GMT offset and rules.
*
* countEquivalentIDs(id). For
* some value of 'index', the returned value will be equal to the
* given id. If the given id is not a valid system time zone, or
* if 'index' is out of range, then returns an empty string.
* @param id a system time zone ID
* @param index a value from 0 to n-1, where n is the value
* returned by countEquivalentIDs(id)
* @return the ID of the index-th zone in the equivalency group
* containing 'id', or an empty string if 'id' is not a valid
* system ID or 'index' is out of range
* @see #countEquivalentIDs
* @stable ICU 2.0
*/
public static String getEquivalentID(String id, int index) {
return ZoneMeta.getEquivalentID(id, index);
}
/**
* Gets the default TimeZone for this host.
* The source of the default TimeZone
* may vary with implementation.
* @return a default TimeZone.
* @stable ICU 2.0
*/
public static synchronized TimeZone getDefault() {
if (defaultZone == null) {
if (TZ_IMPL == TIMEZONE_JDK) {
defaultZone = new JavaTimeZone();
} else {
java.util.TimeZone temp = java.util.TimeZone.getDefault();
defaultZone = getTimeZone(temp.getID());
}
}
return (TimeZone) defaultZone.clone();
}
/**
* Sets the TimeZone that is
* returned by the getDefault method. If zone
* is null, reset the default to the value it had originally when the
* VM first started.
* @param tz the new default time zone
* @stable ICU 2.0
*/
public static synchronized void setDefault(TimeZone tz) {
defaultZone = tz;
java.util.TimeZone jdkZone = null;
if (defaultZone instanceof JavaTimeZone) {
jdkZone = ((JavaTimeZone)defaultZone).unwrap();
} else {
// Keep java.util.TimeZone default in sync so java.util.Date
// can interoperate with com.ibm.icu.util classes.
if (tz != null) {
if (tz instanceof com.ibm.icu.impl.OlsonTimeZone) {
// Because of the lack of APIs supporting historic
// zone offset/dst saving in JDK TimeZone,
// wrapping ICU TimeZone with JDK TimeZone will
// cause historic offset calculation in Calendar/Date.
// JDK calendar implementation calls getRawOffset() and
// getDSTSavings() when the instance of JDK TimeZone
// is not an instance of JDK internal TimeZone subclass
// (sun.util.calendar.ZoneInfo). Ticket#6459
String icuID = tz.getID();
jdkZone = java.util.TimeZone.getTimeZone(icuID);
if (!icuID.equals(jdkZone.getID())) {
// JDK does not know the ID..
jdkZone = null;
}
}
if (jdkZone == null) {
jdkZone = TimeZoneAdapter.wrap(tz);
}
}
}
java.util.TimeZone.setDefault(jdkZone);
}
/**
* Returns true if this zone has the same rule and offset as another zone.
* That is, if this zone differs only in ID, if at all. Returns false
* if the other zone is null.
* @param other the TimeZone object to be compared with
* @return true if the other zone is not null and is the same as this one,
* with the possible exception of the ID
* @stable ICU 2.0
*/
public boolean hasSameRules(TimeZone other) {
return other != null &&
getRawOffset() == other.getRawOffset() &&
useDaylightTime() == other.useDaylightTime();
}
/**
* Overrides Cloneable
* @stable ICU 2.0
*/
public Object clone() {
try {
TimeZone other = (TimeZone) super.clone();
other.ID = ID;
return other;
} catch (CloneNotSupportedException e) {
throw new IllegalStateException();
}
}
/**
* Return true if obj is a TimeZone with the same class and ID as this.
* @return true if obj is a TimeZone with the same class and ID as this
* @param obj the object to compare against
* @stable ICU 3.6
*/
public boolean equals(Object obj){
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
return (ID.equals(((TimeZone)obj).ID));
}
/**
* Return the hash code.
* @return the hash code
* @stable ICU 3.6
*/
public int hashCode(){
return ID.hashCode();
}
/**
* Returns the time zone data version currently used by ICU.
*
* @return the version string, such as "2007f"
* @throws MissingResourceException if ICU time zone resource bundle
* is missing or the version information is not available.
*
* @stable ICU 3.8
*/
public static synchronized String getTZDataVersion() {
if (TZDATA_VERSION == null) {
UResourceBundle tzbundle = UResourceBundle.getBundleInstance(
"com/ibm/icu/impl/data/icudt" + VersionInfo.ICU_DATA_VERSION, "zoneinfo");
TZDATA_VERSION = tzbundle.getString("TZVersion");
}
return TZDATA_VERSION;
}
/**
* Returns the canonical system time zone ID or the normalized
* custom time zone ID for the given time zone ID.
* @param id The input time zone ID to be canonicalized.
* @return The canonical system time zone ID or the custom time zone ID
* in normalized format for the given time zone ID. When the given time zone ID
* is neither a known system time zone ID nor a valid custom time zone ID,
* null is returned.
* @stable ICU 4.0
*/
public static String getCanonicalID(String id) {
return getCanonicalID(id, null);
}
/**
* Returns the canonical system time zone ID or the normalized
* custom time zone ID for the given time zone ID.
* @param id The input time zone ID to be canonicalized.
* @param isSystemID When non-null boolean array is specified and
* the given ID is a known system time zone ID, true is set to isSystemID[0]
* @return The canonical system time zone ID or the custom time zone ID
* in normalized format for the given time zone ID. When the given time zone ID
* is neither a known system time zone ID nor a valid custom time zone ID,
* null is returned.
* @stable ICU 4.0
*/
public static String getCanonicalID(String id, boolean[] isSystemID) {
String canonicalID = null;
boolean systemTzid = false;
if (id != null && id.length() != 0) {
canonicalID = ZoneMeta.getCanonicalSystemID(id);
if (canonicalID != null) {
systemTzid = true;
} else {
canonicalID = ZoneMeta.getCustomID(id);
}
}
if (isSystemID != null) {
isSystemID[0] = systemTzid;
}
return canonicalID;
}
// =======================privates===============================
/**
* The string identifier of this TimeZone. This is a
* programmatic identifier used internally to look up TimeZone
* objects from the system table and also to map them to their localized
* display names. ID values are unique in the system
* table but may not be for dynamically created zones.
* @serial
*/
private String ID;
/**
* The default time zone, or null if not set.
*/
private static TimeZone defaultZone = null;
/**
* The tzdata version
*/
private static String TZDATA_VERSION = null;
/**
* TimeZone implementation type
*/
private static int TZ_IMPL = TIMEZONE_ICU;
/**
* TimeZone implementation type initialization
*/
private static final String TZIMPL_CONFIG_KEY = "com.ibm.icu.util.TimeZone.DefaultTimeZoneType";
private static final String TZIMPL_CONFIG_ICU = "ICU";
private static final String TZIMPL_CONFIG_JDK = "JDK";
static {
String type = ICUConfig.get(TZIMPL_CONFIG_KEY, TZIMPL_CONFIG_ICU);
if (type.equalsIgnoreCase(TZIMPL_CONFIG_JDK)) {
TZ_IMPL = TIMEZONE_JDK;
}
}
}
//eof
icu4j-4.2.1.1/src/com/ibm/icu/util/UResourceBundleIterator.java 0000644 0001750 0001750 00000005467 11015072544 024140 0 ustar twerner twerner /*
******************************************************************************
* Copyright (C) 2004-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
package com.ibm.icu.util;
import java.util.NoSuchElementException;
/**
*
*
* ICUResourceBundleIterator iterator = resB.getIterator();
* ICUResourceBundle temp;
* while (iterator.hasNext()) {
* temp = iterartor.next();
* int type = temp.getType();
* switch(type){
* case UResourceBundle.STRING:
* str = temp.getString();
* break;
* case UResourceBundle.INT:
* integer = temp.getInt();
* break;
* .....
* }
* // do something interesting with data collected
* }
*
* @author ram
* @stable ICU 3.8
*/
public class UResourceBundleIterator{
private UResourceBundle bundle;
private int index = 0;
private int size = 0;
/**
* Construct a resource bundle iterator for the
* given resource bundle
*
* @param bndl The resource bundle to iterate over
* @stable ICU 3.8
*/
public UResourceBundleIterator(UResourceBundle bndl){
bundle = bndl;
size = bundle.getSize();
}
/**
* Returns the next element of this iterator if this iterator object has at least one more element to provide
* @return the UResourceBundle object
* @throws NoSuchElementException
* @stable ICU 3.8
*/
public UResourceBundle next()throws NoSuchElementException{
if(index
* public class A {
* protected Collection b;
*
* protected Collection c;
*
* public Collection get_b() {
* return b;
* }
*
* public Collection get_c() {
* return c;
* }
*
* public A(Collection new_b, Collection new_c) {
* b = new_b;
* c = new_c;
* }
* }
*
*
*
* public test1(SupposedlyImmutableClass x, SafeStorage y) {
* <font color="#0000FF"> <b>// unsafe getter</b>
* </font> A a = x.getA();
* Collection col = a.get_b();
* col.add(something);<font color="#0000FF"> // a has now been changed, and x too
* </font>
* <font color="#0000FF"><b>// unsafe constructor</b></font>
* a = new A(col, col);
* y.store(a);
* col.add(something);<font color="#0000FF"> // a has now been changed, and y too
*
* </font>}
*
*
*
*
*
*
*
*
* Freezable Model
* Freezable model supplements these choices by giving you
* the ability to build up an object by calling various methods, then when it is
* in a final state, you can make it immutable. Once immutable, an
* object cannot ever be modified, and is completely thread-safe: that
* is, multiple threads can have references to it without any synchronization.
* If someone needs a mutable version of an object, they can use
* cloneAsThawed(), and modify the copy. This provides a simple,
* effective mechanism for safe classes in circumstances where the alternatives
* are insufficient or clumsy. (If an object is shared before it is immutable,
* then it is the responsibility of each thread to mutex its usage (as with
* other objects).)
* Immutable Objects
*
* public class A implements Freezable {
* ...
* public final boolean isFrozen() {return true;}
* public final Object freeze() {return this;}
* public final Object cloneAsThawed() { return this; }
* }
*
*
* freeze is returning
* this for chaining.)
* Mutable Objects
*
* protected boolean immutable;
*
*
*
* public final boolean isFrozen() {
* return frozen;
* };
*
* public Object freeze() {
* frozen = true;
* return this;
* }
*
*
* cloneAsThawed() method following the normal pattern for
* clone(), except that frozen=false in the new
* clone.
*
* if (isFrozen()) {
* throw new UnsupportedOperationException("Attempt to modify frozen object");
* }
*
*
* Subclassing
* Freezable will just use its superclass's
* flagging field. It must override freeze() and
* cloneAsThawed() to call the superclass, but normally does not
* override isFrozen(). It must then just pay attention to its
* own getters, setters and fields.
* Internal Caches
* Unsafe Internal Access
* frozen or immutable (such as String or primitives). If you've
* never allowed internal access to these, then you are all done. For example,
* converting UnicodeSet to be Freezable is just accomplished
* with the above steps. But remember that you have allowed
* access to unsafe internals if you have any code like the following, in a
* getter, setter, or constructor:
*
* Collection getStuff() {
* return stuff;
* } // caller could keep reference & modify
*
* void setStuff(Collection x) {
* stuff = x;
* } // caller could keep reference & modify
*
* MyClass(Collection x) {
* stuff = x;
* } // caller could keep reference & modify
*
*
*
freeze() function. Just make all of your internal
* fields frozen, and set the frozen flag. Any subsequent getter/setter will
* work properly. Here is an example:
*
* public Object freeze() {
* if (!frozen) {
* foo.freeze();
* frozen = true;
* }
* return this;
* }
*
*
* Collection or Map, then to
* make it frozen you have two choices. If you have never allowed access to the
* collection from outside your object, then just wrap it to prevent future
* modification.
*
* zone_to_country = Collections.unmodifiableMap(zone_to_country);
*
*
* clone()
* before wrapping it.
*
* zone_to_country = Collections.unmodifiableMap(zone_to_country.clone());
*
*
*
*
* @stable ICU 3.8
*/
public interface Freezable extends Cloneable {
/**
* Determines whether the object has been locked or not.
* @stable ICU 3.8
*/
public boolean isFrozen();
/**
* Locks the object.
* @return the object itself.
* @stable ICU 3.8
*/
public Object freeze();
/**
* Provides for the clone operation. Any clone is initially unlocked.
* @stable ICU 3.8
*/
public Object cloneAsThawed();
}
icu4j-4.2.1.1/src/com/ibm/icu/util/Calendar.java 0000644 0001750 0001750 00000656351 11335021766 021102 0 ustar twerner twerner /*
* Copyright (C) 1996-2010, International Business Machines
* Corporation and others. All Rights Reserved.
*/
package com.ibm.icu.util;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.text.StringCharacterIterator;
import java.util.Date;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.Set;
import com.ibm.icu.impl.CalendarData;
import com.ibm.icu.impl.CalendarUtil;
import com.ibm.icu.impl.ICUCache;
import com.ibm.icu.impl.ICUResourceBundle;
import com.ibm.icu.impl.SimpleCache;
import com.ibm.icu.text.DateFormat;
import com.ibm.icu.text.DateFormatSymbols;
import com.ibm.icu.text.MessageFormat;
import com.ibm.icu.text.SimpleDateFormat;
/**
* Map or Set, don't have a clone()
* operation. When you don't know the type of the collection, the simplest
* course is to just create a new collection:
*
* zone_to_country = Collections.unmodifiableMap(new HashMap(zone_to_country));
*
*
* Calendar is an abstract base class for converting between
* a Date object and a set of integer fields such as
* YEAR, MONTH, DAY, HOUR,
* and so on. (A Date object represents a specific instant in
* time with millisecond precision. See
* {@link Date}
* for information about the Date class.)
*
* java.util.Calendar. Changes are detailed below.
*
* Calendar interpret a Date
* according to the rules of a specific calendar system. ICU4J contains
* several subclasses implementing different international calendar systems.
*
* Calendar provides a
* class method, getInstance, for getting a generally useful
* object of this type. Calendar's getInstance method
* returns a calendar of a type appropriate to the locale, whose
* time fields have been initialized with the current date and time:
*
*
*
* Calendar rightNow = Calendar.getInstance()
* ULocale is used by getInstance, its
* 'calendar' tag and value are retrieved if present. If a recognized
* value is supplied, a calendar is provided and configured as appropriate.
* Currently recognized tags are "buddhist", "chinese", "coptic", "ethiopic",
* "gregorian", "hebrew", "islamic", "islamic-civil", "japanese", and "roc". For
* example:
*
will return an instance of JapaneseCalendar (using en_US conventions for
* minimum days in first week, start day of week, et cetera).
*
* Calendar cal = Calendar.getInstance(new ULocale("en_US@calendar=japanese"));
* Calendar object can produce all the time field values
* needed to implement the date-time formatting for a particular language and
* calendar style (for example, Japanese-Gregorian, Japanese-Traditional).
* Calendar defines the range of values returned by certain fields,
* as well as their meaning. For example, the first month of the year has value
* MONTH == JANUARY for all calendars. Other values
* are defined by the concrete subclass, such as ERA and
* YEAR. See individual field documentation and subclass
* documentation for details.
*
* Calendar is lenient, it accepts a wider range
* of field values than it produces. For example, a lenient
* GregorianCalendar interprets MONTH ==
* JANUARY, DAY_OF_MONTH == 32 as February 1. A
* non-lenient GregorianCalendar throws an exception when given
* out-of-range field settings. When calendars recompute field values for
* return by get(), they normalize them. For example, a
* GregorianCalendar always produces DAY_OF_MONTH
* values between 1 and the length of the month.
*
* Calendar defines a locale-specific seven day week using two
* parameters: the first day of the week and the minimal days in first week
* (from 1 to 7). These numbers are taken from the locale resource data when a
* Calendar is constructed. They may also be specified explicitly
* through the API.
*
* WEEK_OF_MONTH or
* WEEK_OF_YEAR fields, Calendar must determine the
* first week of the month or year as a reference point. The first week of a
* month or year is defined as the earliest seven day period beginning on
* getFirstDayOfWeek() and containing at least
* getMinimalDaysInFirstWeek() days of that month or year. Weeks
* numbered ..., -1, 0 precede the first week; weeks numbered 2, 3,... follow
* it. Note that the normalized numbering returned by get() may be
* different. For example, a specific Calendar subclass may
* designate the week before week 1 of a year as week n of the previous
* year.
*
* Date from time fields, two special
* circumstances may arise: there may be insufficient information to compute the
* Date (such as only year and month but no day in the month), or
* there may be inconsistent information (such as "Tuesday, July 15, 1996" --
* July 15, 1996 is actually a Monday).
*
*
*
*
* For the time of day:
*
*
* MONTH + DAY_OF_MONTH
* MONTH + WEEK_OF_MONTH + DAY_OF_WEEK
* MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK
* DAY_OF_YEAR
* DAY_OF_WEEK + WEEK_OF_YEAR
*
*
*
*
* HOUR_OF_DAY
* AM_PM + HOUR
*
*
*
* Calendar fields can be changed using three methods:
* set(), add(), and roll().set(f, value) changes field
* f to value. In addition, it sets an
* internal member variable to indicate that field f has
* been changed. Although field f is changed immediately,
* the calendar's milliseconds is not recomputed until the next call to
* get(), getTime(), or
* getTimeInMillis() is made. Thus, multiple calls to
* set() do not trigger multiple, unnecessary
* computations. As a result of changing a field using
* set(), other fields may also change, depending on the
* field, the field value, and the calendar system. In addition,
* get(f) will not necessarily return value
* after the fields have been recomputed. The specifics are determined by
* the concrete calendar class.GregorianCalendar
* originally set to August 31, 1999. Calling set(Calendar.MONTH,
* Calendar.SEPTEMBER) sets the calendar to September 31,
* 1999. This is a temporary internal representation that resolves to
* October 1, 1999 if getTime()is then called. However, a
* call to set(Calendar.DAY_OF_MONTH, 30) before the call to
* getTime() sets the calendar to September 30, 1999, since
* no recomputation occurs after set() itself.add(f, delta) adds delta
* to field f. This is equivalent to calling set(f,
* get(f) + delta) with two adjustments:
*
*
* f
* after the call minus the value of field f before the
* call is delta, modulo any overflow that has occurred in
* field f. Overflow occurs when a field value exceeds its
* range and, as a result, the next larger field is incremented or
* decremented and the field value is adjusted back into its range.f is changed, then its value is adjusted to be as close
* as possible to its expected value. A smaller field represents a
* smaller unit of time. HOUR is a smaller field than
* DAY_OF_MONTH. No adjustment is made to smaller fields
* that are not expected to be invariant. The calendar system
* determines what fields are expected to be invariant.set(), add() forces
* an immediate recomputation of the calendar's milliseconds and all
* fields.GregorianCalendar
* originally set to August 31, 1999. Calling add(Calendar.MONTH,
* 13) sets the calendar to September 30, 2000. Add rule
* 1 sets the MONTH field to September, since
* adding 13 months to August gives September of the next year. Since
* DAY_OF_MONTH cannot be 31 in September in a
* GregorianCalendar, add rule 2 sets the
* DAY_OF_MONTH to 30, the closest possible value. Although
* it is a smaller field, DAY_OF_WEEK is not adjusted by
* rule 2, since it is expected to change when the month changes in a
* GregorianCalendar.roll(f, delta) adds
* delta to field f without changing larger
* fields. This is equivalent to calling add(f, delta) with
* the following adjustment:
*
*
* DAY_OF_MONTH is a larger field than
* HOUR.GregorianCalendar
* originally set to August 31, 1999. Calling roll(Calendar.MONTH,
* 8) sets the calendar to April 30, 1999. Add
* rule 1 sets the MONTH field to April. Using a
* GregorianCalendar, the DAY_OF_MONTH cannot
* be 31 in the month April. Add rule 2 sets it to the closest possible
* value, 30. Finally, the roll rule maintains the
* YEAR field value of 1999.GregorianCalendar
* originally set to Sunday June 6, 1999. Calling
* roll(Calendar.WEEK_OF_MONTH, -1) sets the calendar to
* Tuesday June 1, 1999, whereas calling
* add(Calendar.WEEK_OF_MONTH, -1) sets the calendar to
* Sunday May 30, 1999. This is because the roll rule imposes an
* additional constraint: The MONTH must not change when the
* WEEK_OF_MONTH is rolled. Taken together with add rule 1,
* the resultant date must be between Tuesday June 1 and Saturday June
* 5. According to add rule 2, the DAY_OF_WEEK, an invariant
* when changing the WEEK_OF_MONTH, is set to Tuesday, the
* closest possible value to Sunday (where Sunday is the first day of the
* week).add() and roll(), consider a user interface
* component with increment and decrement buttons for the month, day, and
* year, and an underlying GregorianCalendar. If the
* interface reads January 31, 1999 and the user presses the month
* increment button, what should it read? If the underlying
* implementation uses set(), it might read March 3, 1999. A
* better result would be February 28, 1999. Furthermore, if the user
* presses the month increment button again, it should read March 31,
* 1999, not March 28, 1999. By saving the original date and using either
* add() or roll(), depending on whether larger
* fields should be affected, the user interface can behave as most users
* will intuitively expect.Calendar has changed
* significantly in order to better support subclassing. The original
* Calendar class was designed to support subclassing, but
* it had only one implemented subclass, GregorianCalendar.
* With the implementation of several new calendar subclasses, including
* the BuddhistCalendar, ChineseCalendar,
* HebrewCalendar, IslamicCalendar, and
* JapaneseCalendar, the subclassing API has been reworked
* thoroughly. This section details the new subclassing API and other
* ways in which com.ibm.icu.util.Calendar differs from
* java.util.Calendar.
* Calendar
* architecture and the new architecture.
*
*
*
*
*
* fields[] array is private now
* instead of protected. Subclasses must access it
* using the methods {@link #internalSet} and
* {@link #internalGet}. Motivation: Subclasses should
* not directly access data members.time long word is private now
* instead of protected. Subclasses may access it using
* the method {@link #internalGetTimeInMillis}, which does not
* provoke an update. Motivation: Subclasses should not
* directly access data members.Calendar base class. As a result, it is much easier
* to subclass Calendar. Motivation: Subclasses
* should not have to reimplement common code. Certain behaviors are
* common across calendar systems: The definition and behavior of
* week-related fields and time fields, the arithmetic
* ({@link #add(int, int) add} and {@link #roll(int, int) roll}) behavior of many
* fields, and the field validation system.Calendar base class contains some Gregorian
* calendar algorithmic support that subclasses can use (specifically
* in {@link #handleComputeFields}). Subclasses can use the
* methods getGregorianXxx() to obtain precomputed
* values. Motivation: This is required by all
* Calendar subclasses in order to implement consistent
* time zone behavior, and Gregorian-derived systems can use the
* already computed data.FIELD_COUNT constant has been removed. Use
* {@link #getFieldCount}. In addition, framework API has been
* added to allow subclasses to define additional fields.
* Motivation: The number of fields is not constant across
* calendar systems.Date(Long.MIN_VALUE) or
* Date(Long.MAX_VALUE). Instead, the
* Calendar constants {@link #MIN_DATE},
* {@link #MAX_DATE}, {@link #MIN_MILLIS},
* {@link #MAX_MILLIS}, {@link #MIN_JULIAN}, and
* {@link #MAX_JULIAN} should be used. Motivation: With
* the addition of the {@link #JULIAN_DAY} field, Julian day
* numbers must be restricted to a 32-bit int. This
* restricts the overall supported range. Furthermore, restricting
* the supported range simplifies the computations by removing
* special case code that was used to accomodate arithmetic overflow
* at millis near Long.MIN_VALUE and
* Long.MAX_VALUE.Calendar.DateFormat.Calendar API was based on the experience
* of implementing a only a single subclass,
* GregorianCalendar. As a result, all of the subclassing
* kinks had not been worked out. The new subclassing API has been
* refined based on several implemented subclasses. This includes methods
* that must be overridden and methods for subclasses to call. Subclasses
* no longer have direct access to fields and
* stamp. Instead, they have new API to access
* these. Subclasses are able to allocate the fields array
* through a protected framework method; this allows subclasses to
* specify additional fields. Calendar. Subclasses no longer compute the week related
* fields and the time related fields. These are commonly handled for all
* calendars by the base class. Calendar.
*
*
*
*
*
* Calendar,
* they must also be computed. These are the only fields that the
* subclass should compute. All other fields are computed by the base
* class, so time and week fields behave in a consistent way across
* all calendars. The default version of this method in
* Calendar implements a proleptic Gregorian
* calendar. Within this method, subclasses may call
* getGregorianXxx() to obtain the Gregorian calendar
* month, day of month, and extended year for the given date.Calendar. Calendar determines which fields
* are set, which are not, which are set more recently, and so on. In
* addition, Calendar handles the computation of the time
* from the time fields and handles the week-related fields. The only
* thing the subclass must do is determine the extended year, based on
* the year fields, and then, given an extended year and a month, it must
* return a Julian day number.
*
*
*
*
*
*
*
*
*
* limitType. This method only needs to handle the
* fields {@link #ERA}, {@link #YEAR}, {@link #MONTH},
* {@link #WEEK_OF_YEAR}, {@link #WEEK_OF_MONTH},
* {@link #DAY_OF_MONTH}, {@link #DAY_OF_YEAR},
* {@link #DAY_OF_WEEK_IN_MONTH}, {@link #YEAR_WOY}, and
* {@link #EXTENDED_YEAR}. Other fields are invariant (with
* respect to calendar system) and are handled by the base
* class.IllegalArgumentException. The method may call
* super.validateField(field) to handle fields in a
* generic way, that is, to compare them to the range
* getMinimum(field)..getMaximum(field).int[]
* array large enough to hold the calendar's fields. This is only
* necessary if the calendar defines additional fields beyond those
* defined by Calendar. The length of the result must be
* at least {@link #BASE_FIELD_COUNT} and no more than
* {@link #MAX_FIELD_COUNT}.DateFormat appropriate to this calendar. This is only
* required if a calendar subclass redefines the use of a field (for
* example, changes the {@link #ERA} field from a symbolic field
* to a numeric one) or defines an additional field.Calendar.
*
*
*
*
*
* Calendar and to maintain basic correpsondences
* between calendar systems. Affected fields: {@link #AM_PM},
* {@link #HOUR}, {@link #HOUR_OF_DAY}, {@link #MINUTE},
* {@link #SECOND}, {@link #MILLISECOND},
* {@link #ZONE_OFFSET}, and {@link #DST_OFFSET}.GregorianCalendar fields: the
* {@link #YEAR}, {@link #MONTH}, and
* {@link #DAY_OF_MONTH}. As a result, Calendar
* always computes these fields, even for non-Gregorian calendar
* systems. These fields are available to subclasses.WEEK_OF_YEAR,
* WEEK_OF_MONTH, {@link #DAY_OF_WEEK_IN_MONTH},
* {@link #DOW_LOCAL}, {@link #YEAR_WOY} are all computed in
* a consistent way in the base class, based on the
* {@link #EXTENDED_YEAR}, {@link #DAY_OF_YEAR},
* {@link #MONTH}, and {@link #DAY_OF_MONTH}, which are
* computed by the subclass.Calendar has been
* narrowed. GregorianCalendar used to attempt to support
* the range of dates with millisecond values from
* Long.MIN_VALUE to Long.MAX_VALUE. This
* introduced awkward constructions (hacks) which slowed down
* performance. It also introduced non-uniform behavior at the
* boundaries. The new Calendar protocol specifies the
* maximum range of supportable dates as those having Julian day numbers
* of -0x7F000000 to +0x7F000000. This
* corresponds to years from ~5,000,000 BCE to ~5,000,000 CE. Programmers
* should use the constants {@link #MIN_DATE} (or
* {@link #MIN_MILLIS} or {@link #MIN_JULIAN}) and
* {@link #MAX_DATE} (or {@link #MAX_MILLIS} or
* {@link #MAX_JULIAN}) in Calendar to specify an
* extremely early or extremely late date.
*
*
*
* @see Date
* @see GregorianCalendar
* @see TimeZone
* @see DateFormat
* @author Mark Davis, David Goldsmith, Chen-Lieh Huang, Alan Liu, Laura Werner
* @stable ICU 2.0
*/
public abstract class Calendar implements Serializable, Cloneable, Comparable {
// Data flow in Calendar
// ---------------------
// The current time is represented in two ways by Calendar: as UTC
// milliseconds from the epoch start (1 January 1970 0:00 UTC), and as local
// fields such as MONTH, HOUR, AM_PM, etc. It is possible to compute the
// millis from the fields, and vice versa. The data needed to do this
// conversion is encapsulated by a TimeZone object owned by the Calendar.
// The data provided by the TimeZone object may also be overridden if the
// user sets the ZONE_OFFSET and/or DST_OFFSET fields directly. The class
// keeps track of what information was most recently set by the caller, and
// uses that to compute any other information as needed.
// If the user sets the fields using set(), the data flow is as follows.
// This is implemented by the Calendar subclass's computeTime() method.
// During this process, certain fields may be ignored. The disambiguation
// algorithm for resolving which fields to pay attention to is described
// above.
// local fields (YEAR, MONTH, DATE, HOUR, MINUTE, etc.)
// |
// | Using Calendar-specific algorithm
// V
// local standard millis
// |
// | Using TimeZone or user-set ZONE_OFFSET / DST_OFFSET
// V
// UTC millis (in time data member)
// If the user sets the UTC millis using setTime(), the data flow is as
// follows. This is implemented by the Calendar subclass's computeFields()
// method.
// UTC millis (in time data member)
// |
// | Using TimeZone getOffset()
// V
// local standard millis
// |
// | Using Calendar-specific algorithm
// V
// local fields (YEAR, MONTH, DATE, HOUR, MINUTE, etc.)
// In general, a round trip from fields, through local and UTC millis, and
// back out to fields is made when necessary. This is implemented by the
// complete() method. Resolving a partial set of fields into a UTC millis
// value allows all remaining fields to be generated from that value. If
// the Calendar is lenient, the fields are also renormalized to standard
// ranges when they are regenerated.
/**
* Field number for GregorianCalendar class supports
* dates before the historical onset of the calendar by extending the
* calendar system backward in time. Similarly, the
* HebrewCalendar extends backward before the start of
* its epoch into zero and negative years. Subclasses do not throw
* exceptions because a date precedes the historical start of a
* calendar system. Instead, they implement
* {@link #handleGetLimit} to return appropriate limits on
* {@link #YEAR}, {@link #ERA}, etc. fields. Then, if the
* calendar is set to not be lenient, out-of-range field values will
* trigger an exception.ERA==AD ? YEAR : 1-YEAR. Another example is the Mayan
* long count, which has years (KUN) and nested cycles
* of years (KATUN and BAKTUN). The Mayan
* {@link #EXTENDED_YEAR} is computed as TUN + 20 * (KATUN
* + 20 * BAKTUN). The Calendar base class uses
* the {@link #EXTENDED_YEAR} field to compute the week-related
* fields.get and set indicating the
* era, e.g., AD or BC in the Julian calendar. This is a calendar-specific
* value; see subclass documentation.
* @see GregorianCalendar#AD
* @see GregorianCalendar#BC
* @stable ICU 2.0
*/
public final static int ERA = 0;
/**
* Field number for get and set indicating the
* year. This is a calendar-specific value; see subclass documentation.
* @stable ICU 2.0
*/
public final static int YEAR = 1;
/**
* Field number for get and set indicating the
* month. This is a calendar-specific value. The first month of the year is
* JANUARY; the last depends on the number of months in a year.
* @see #JANUARY
* @see #FEBRUARY
* @see #MARCH
* @see #APRIL
* @see #MAY
* @see #JUNE
* @see #JULY
* @see #AUGUST
* @see #SEPTEMBER
* @see #OCTOBER
* @see #NOVEMBER
* @see #DECEMBER
* @see #UNDECIMBER
* @stable ICU 2.0
*/
public final static int MONTH = 2;
/**
* Field number for get and set indicating the
* week number within the current year. The first week of the year, as
* defined by getFirstDayOfWeek() and
* getMinimalDaysInFirstWeek(), has value 1. Subclasses define
* the value of WEEK_OF_YEAR for days before the first week of
* the year.
* @see #getFirstDayOfWeek
* @see #getMinimalDaysInFirstWeek
* @stable ICU 2.0
*/
public final static int WEEK_OF_YEAR = 3;
/**
* Field number for get and set indicating the
* week number within the current month. The first week of the month, as
* defined by getFirstDayOfWeek() and
* getMinimalDaysInFirstWeek(), has value 1. Subclasses define
* the value of WEEK_OF_MONTH for days before the first week of
* the month.
* @see #getFirstDayOfWeek
* @see #getMinimalDaysInFirstWeek
* @stable ICU 2.0
*/
public final static int WEEK_OF_MONTH = 4;
/**
* Field number for get and set indicating the
* day of the month. This is a synonym for DAY_OF_MONTH.
* The first day of the month has value 1.
* @see #DAY_OF_MONTH
* @stable ICU 2.0
*/
public final static int DATE = 5;
/**
* Field number for get and set indicating the
* day of the month. This is a synonym for DATE.
* The first day of the month has value 1.
* @see #DATE
* @stable ICU 2.0
*/
public final static int DAY_OF_MONTH = 5;
/**
* Field number for get and set indicating the day
* number within the current year. The first day of the year has value 1.
* @stable ICU 2.0
*/
public final static int DAY_OF_YEAR = 6;
/**
* Field number for get and set indicating the day
* of the week. This field takes values SUNDAY,
* MONDAY, TUESDAY, WEDNESDAY,
* THURSDAY, FRIDAY, and SATURDAY.
* @see #SUNDAY
* @see #MONDAY
* @see #TUESDAY
* @see #WEDNESDAY
* @see #THURSDAY
* @see #FRIDAY
* @see #SATURDAY
* @stable ICU 2.0
*/
public final static int DAY_OF_WEEK = 7;
/**
* Field number for get and set indicating the
* ordinal number of the day of the week within the current month. Together
* with the DAY_OF_WEEK field, this uniquely specifies a day
* within a month. Unlike WEEK_OF_MONTH and
* WEEK_OF_YEAR, this field's value does not depend on
* getFirstDayOfWeek() or
* getMinimalDaysInFirstWeek(). DAY_OF_MONTH 1
* through 7 always correspond to DAY_OF_WEEK_IN_MONTH
* 1; 8 through 15 correspond to
* DAY_OF_WEEK_IN_MONTH 2, and so on.
* DAY_OF_WEEK_IN_MONTH 0 indicates the week before
* DAY_OF_WEEK_IN_MONTH 1. Negative values count back from the
* end of the month, so the last Sunday of a month is specified as
* DAY_OF_WEEK = SUNDAY, DAY_OF_WEEK_IN_MONTH = -1. Because
* negative values count backward they will usually be aligned differently
* within the month than positive values. For example, if a month has 31
* days, DAY_OF_WEEK_IN_MONTH -1 will overlap
* DAY_OF_WEEK_IN_MONTH 5 and the end of 4.
* @see #DAY_OF_WEEK
* @see #WEEK_OF_MONTH
* @stable ICU 2.0
*/
public final static int DAY_OF_WEEK_IN_MONTH = 8;
/**
* Field number for get and set indicating
* whether the HOUR is before or after noon.
* E.g., at 10:04:15.250 PM the AM_PM is PM.
* @see #AM
* @see #PM
* @see #HOUR
* @stable ICU 2.0
*/
public final static int AM_PM = 9;
/**
* Field number for get and set indicating the
* hour of the morning or afternoon. HOUR is used for the 12-hour
* clock.
* E.g., at 10:04:15.250 PM the HOUR is 10.
* @see #AM_PM
* @see #HOUR_OF_DAY
* @stable ICU 2.0
*/
public final static int HOUR = 10;
/**
* Field number for get and set indicating the
* hour of the day. HOUR_OF_DAY is used for the 24-hour clock.
* E.g., at 10:04:15.250 PM the HOUR_OF_DAY is 22.
* @see #HOUR
* @stable ICU 2.0
*/
public final static int HOUR_OF_DAY = 11;
/**
* Field number for get and set indicating the
* minute within the hour.
* E.g., at 10:04:15.250 PM the MINUTE is 4.
* @stable ICU 2.0
*/
public final static int MINUTE = 12;
/**
* Field number for get and set indicating the
* second within the minute.
* E.g., at 10:04:15.250 PM the SECOND is 15.
* @stable ICU 2.0
*/
public final static int SECOND = 13;
/**
* Field number for get and set indicating the
* millisecond within the second.
* E.g., at 10:04:15.250 PM the MILLISECOND is 250.
* @stable ICU 2.0
*/
public final static int MILLISECOND = 14;
/**
* Field number for get and set indicating the
* raw offset from GMT in milliseconds.
* @stable ICU 2.0
*/
public final static int ZONE_OFFSET = 15;
/**
* Field number for get and set indicating the
* daylight savings offset in milliseconds.
* @stable ICU 2.0
*/
public final static int DST_OFFSET = 16;
/**
* Field number for get() and set()
* indicating the extended year corresponding to the
* WEEK_OF_YEAR field. This may be one greater or less
* than the value of EXTENDED_YEAR.
* @stable ICU 2.0
*/
public static final int YEAR_WOY = 17;
/**
* Field number for get() and set()
* indicating the localized day of week. This will be a value from 1
* to 7 inclusive, with 1 being the localized first day of the week.
* @stable ICU 2.0
*/
public static final int DOW_LOCAL = 18;
/**
* Field number for get() and set()
* indicating the extended year. This is a single number designating
* the year of this calendar system, encompassing all supra-year
* fields. For example, for the Julian calendar system, year numbers
* are positive, with an era of BCE or CE. An extended year value for
* the Julian calendar system assigns positive values to CE years and
* negative values to BCE years, with 1 BCE being year 0.
* @stable ICU 2.0
*/
public static final int EXTENDED_YEAR = 19;
/**
* Field number for get() and set()
* indicating the modified Julian day number. This is different from
* the conventional Julian day number in two regards. First, it
* demarcates days at local zone midnight, rather than noon GMT.
* Second, it is a local number; that is, it depends on the local time
* zone. It can be thought of as a single number that encompasses all
* the date-related fields.
* @stable ICU 2.0
*/
public static final int JULIAN_DAY = 20;
/**
* Field number for get() and set()
* indicating the milliseconds in the day. This ranges from 0 to
* 23:59:59.999 (regardless of DST). This field behaves
* exactly like a composite of all time-related fields, not
* including the zone fields. As such, it also reflects
* discontinuities of those fields on DST transition days. On a day of
* DST onset, it will jump forward. On a day of DST cessation, it will
* jump backward. This reflects the fact that is must be combined with
* the DST_OFFSET field to obtain a unique local time value.
* @stable ICU 2.0
*/
public static final int MILLISECONDS_IN_DAY = 21;
/**
* The number of fields defined by this class. Subclasses may define
* addition fields starting with this number.
* @stable ICU 2.0
*/
protected static final int BASE_FIELD_COUNT = 22;
/**
* The maximum number of fields possible. Subclasses must not define
* more total fields than this number.
* @stable ICU 2.0
*/
protected static final int MAX_FIELD_COUNT = 32;
/**
* Value of the DAY_OF_WEEK field indicating
* Sunday.
* @stable ICU 2.0
*/
public final static int SUNDAY = 1;
/**
* Value of the DAY_OF_WEEK field indicating
* Monday.
* @stable ICU 2.0
*/
public final static int MONDAY = 2;
/**
* Value of the DAY_OF_WEEK field indicating
* Tuesday.
* @stable ICU 2.0
*/
public final static int TUESDAY = 3;
/**
* Value of the DAY_OF_WEEK field indicating
* Wednesday.
* @stable ICU 2.0
*/
public final static int WEDNESDAY = 4;
/**
* Value of the DAY_OF_WEEK field indicating
* Thursday.
* @stable ICU 2.0
*/
public final static int THURSDAY = 5;
/**
* Value of the DAY_OF_WEEK field indicating
* Friday.
* @stable ICU 2.0
*/
public final static int FRIDAY = 6;
/**
* Value of the DAY_OF_WEEK field indicating
* Saturday.
* @stable ICU 2.0
*/
public final static int SATURDAY = 7;
/**
* Value of the MONTH field indicating the
* first month of the year.
* @stable ICU 2.0
*/
public final static int JANUARY = 0;
/**
* Value of the MONTH field indicating the
* second month of the year.
* @stable ICU 2.0
*/
public final static int FEBRUARY = 1;
/**
* Value of the MONTH field indicating the
* third month of the year.
* @stable ICU 2.0
*/
public final static int MARCH = 2;
/**
* Value of the MONTH field indicating the
* fourth month of the year.
* @stable ICU 2.0
*/
public final static int APRIL = 3;
/**
* Value of the MONTH field indicating the
* fifth month of the year.
* @stable ICU 2.0
*/
public final static int MAY = 4;
/**
* Value of the MONTH field indicating the
* sixth month of the year.
* @stable ICU 2.0
*/
public final static int JUNE = 5;
/**
* Value of the MONTH field indicating the
* seventh month of the year.
* @stable ICU 2.0
*/
public final static int JULY = 6;
/**
* Value of the MONTH field indicating the
* eighth month of the year.
* @stable ICU 2.0
*/
public final static int AUGUST = 7;
/**
* Value of the MONTH field indicating the
* ninth month of the year.
* @stable ICU 2.0
*/
public final static int SEPTEMBER = 8;
/**
* Value of the MONTH field indicating the
* tenth month of the year.
* @stable ICU 2.0
*/
public final static int OCTOBER = 9;
/**
* Value of the MONTH field indicating the
* eleventh month of the year.
* @stable ICU 2.0
*/
public final static int NOVEMBER = 10;
/**
* Value of the MONTH field indicating the
* twelfth month of the year.
* @stable ICU 2.0
*/
public final static int DECEMBER = 11;
/**
* Value of the MONTH field indicating the
* thirteenth month of the year. Although GregorianCalendar
* does not use this value, lunar calendars do.
* @stable ICU 2.0
*/
public final static int UNDECIMBER = 12;
/**
* Value of the AM_PM field indicating the
* period of the day from midnight to just before noon.
* @stable ICU 2.0
*/
public final static int AM = 0;
/**
* Value of the AM_PM field indicating the
* period of the day from noon to just before midnight.
* @stable ICU 2.0
*/
public final static int PM = 1;
/**
* Value returned by getDayOfWeekType(int dayOfWeek) to indicate a
* weekday.
* @see #WEEKEND
* @see #WEEKEND_ONSET
* @see #WEEKEND_CEASE
* @see #getDayOfWeekType
* @stable ICU 2.0
*/
public static final int WEEKDAY = 0;
/**
* Value returned by getDayOfWeekType(int dayOfWeek) to indicate a
* weekend day.
* @see #WEEKDAY
* @see #WEEKEND_ONSET
* @see #WEEKEND_CEASE
* @see #getDayOfWeekType
* @stable ICU 2.0
*/
public static final int WEEKEND = 1;
/**
* Value returned by getDayOfWeekType(int dayOfWeek) to indicate a
* day that starts as a weekday and transitions to the weekend.
* Call getWeekendTransition() to get the point of transition.
* @see #WEEKDAY
* @see #WEEKEND
* @see #WEEKEND_CEASE
* @see #getDayOfWeekType
* @stable ICU 2.0
*/
public static final int WEEKEND_ONSET = 2;
/**
* Value returned by getDayOfWeekType(int dayOfWeek) to indicate a
* day that starts as the weekend and transitions to a weekday.
* Call getWeekendTransition() to get the point of transition.
* @see #WEEKDAY
* @see #WEEKEND
* @see #WEEKEND_ONSET
* @see #getDayOfWeekType
* @stable ICU 2.0
*/
public static final int WEEKEND_CEASE = 3;
/**
* The number of milliseconds in one second.
* @stable ICU 2.0
*/
protected static final int ONE_SECOND = 1000;
/**
* The number of milliseconds in one minute.
* @stable ICU 2.0
*/
protected static final int ONE_MINUTE = 60*ONE_SECOND;
/**
* The number of milliseconds in one hour.
* @stable ICU 2.0
*/
protected static final int ONE_HOUR = 60*ONE_MINUTE;
/**
* The number of milliseconds in one day. Although ONE_DAY and
* ONE_WEEK can fit into ints, they must be longs in order to prevent
* arithmetic overflow when performing (bug 4173516).
* @stable ICU 2.0
*/
protected static final long ONE_DAY = 24*ONE_HOUR;
/**
* The number of milliseconds in one week. Although ONE_DAY and
* ONE_WEEK can fit into ints, they must be longs in order to prevent
* arithmetic overflow when performing (bug 4173516).
* @stable ICU 2.0
*/
protected static final long ONE_WEEK = 7*ONE_DAY;
/**
* The Julian day of the Gregorian epoch, that is, January 1, 1 on the
* Gregorian calendar.
* @stable ICU 2.0
*/
protected static final int JAN_1_1_JULIAN_DAY = 1721426;
/**
* The Julian day of the epoch, that is, January 1, 1970 on the
* Gregorian calendar.
* @stable ICU 2.0
*/
protected static final int EPOCH_JULIAN_DAY = 2440588;
/**
* The minimum supported Julian day. This value is equivalent to
* MIN_MILLIS and MIN_DATE.
* @see #JULIAN_DAY
* @stable ICU 2.0
*/
protected static final int MIN_JULIAN = -0x7F000000;
/**
* The minimum supported epoch milliseconds. This value is equivalent
* to MIN_JULIAN and MIN_DATE.
* @stable ICU 2.0
*/
protected static final long MIN_MILLIS = -184303902528000000L;
// Get around bug in jikes 1.12 for now. Later, use:
//protected static final long MIN_MILLIS = (MIN_JULIAN - EPOCH_JULIAN_DAY) * ONE_DAY;
/**
* The minimum supported Date. This value is equivalent
* to MIN_JULIAN and MIN_MILLIS.
* @stable ICU 2.0
*/
protected static final Date MIN_DATE = new Date(MIN_MILLIS);
/**
* The maximum supported Julian day. This value is equivalent to
* MAX_MILLIS and MAX_DATE.
* @see #JULIAN_DAY
* @stable ICU 2.0
*/
protected static final int MAX_JULIAN = +0x7F000000;
/**
* The maximum supported epoch milliseconds. This value is equivalent
* to MAX_JULIAN and MAX_DATE.
* @stable ICU 2.0
*/
protected static final long MAX_MILLIS = (MAX_JULIAN - EPOCH_JULIAN_DAY) * ONE_DAY;
/**
* The maximum supported Date. This value is equivalent
* to MAX_JULIAN and MAX_MILLIS.
* @stable ICU 2.0
*/
protected static final Date MAX_DATE = new Date(MAX_MILLIS);
// Internal notes:
// Calendar contains two kinds of time representations: current "time" in
// milliseconds, and a set of time "fields" representing the current time.
// The two representations are usually in sync, but can get out of sync
// as follows.
// 1. Initially, no fields are set, and the time is invalid.
// 2. If the time is set, all fields are computed and in sync.
// 3. If a single field is set, the time is invalid.
// Recomputation of the time and fields happens when the object needs
// to return a result to the user, or use a result for a computation.
/**
* The field values for the currently set time for this calendar.
* This is an array of at least BASE_FIELD_COUNT integers.
* @see #handleCreateFields
* @serial
*/
private transient int fields[];
/**
* Pseudo-time-stamps which specify when each field was set. There
* are two special values, UNSET and INTERNALLY_SET. Values from
* MINIMUM_USER_SET to Integer.MAX_VALUE are legal user set values.
*/
private transient int stamp[];
/**
* The currently set time for this calendar, expressed in milliseconds after
* January 1, 1970, 0:00:00 GMT.
* @see isTimeSet
* @serial
*/
private long time;
/**
* True if then the value of time is valid.
* The time is made invalid by a change to an item of field[].
* @see #time
* @serial
*/
private transient boolean isTimeSet;
/**
* True if fields[] are in sync with the currently set time.
* If false, then the next attempt to get the value of a field will
* force a recomputation of all fields from the current value of
* time.
* @serial
*/
private transient boolean areFieldsSet;
/**
* True if all fields have been set. This is only false in a few
* situations: In a newly created, partially constructed object. After
* a call to clear(). In an object just read from a stream using
* readObject(). Once computeFields() has been called this is set to
* true and stays true until one of the above situations recurs.
* @serial
*/
private transient boolean areAllFieldsSet;
/**
* True if all fields have been virtually set, but have not yet been
* computed. This occurs only in setTimeInMillis(), or after readObject().
* A calendar set to this state will compute all fields from the time if it
* becomes necessary, but otherwise will delay such computation.
*/
private transient boolean areFieldsVirtuallySet;
/**
* True if this calendar allows out-of-range field values during computation
* of time from fields[].
* @see #setLenient
* @serial
*/
private boolean lenient = true;
/**
* The TimeZone used by this calendar. Calendar
* uses the time zone data to translate between locale and GMT time.
* @serial
*/
private TimeZone zone;
/**
* The first day of the week, with possible values SUNDAY,
* MONDAY, etc. This is a locale-dependent value.
* @serial
*/
private int firstDayOfWeek;
/**
* The number of days required for the first week in a month or year,
* with possible values from 1 to 7. This is a locale-dependent value.
* @serial
*/
private int minimalDaysInFirstWeek;
/**
* First day of the weekend in this calendar's locale. Must be in
* the range SUNDAY...SATURDAY (1..7). The weekend starts at
* weekendOnsetMillis milliseconds after midnight on that day of
* the week. This value is taken from locale resource data.
*/
private int weekendOnset;
/**
* Milliseconds after midnight at which the weekend starts on the
* day of the week weekendOnset. Times that are greater than or
* equal to weekendOnsetMillis are considered part of the weekend.
* Must be in the range 0..24*60*60*1000-1. This value is taken
* from locale resource data.
*/
private int weekendOnsetMillis;
/**
* Day of the week when the weekend stops in this calendar's
* locale. Must be in the range SUNDAY...SATURDAY (1..7). The
* weekend stops at weekendCeaseMillis milliseconds after midnight
* on that day of the week. This value is taken from locale
* resource data.
*/
private int weekendCease;
/**
* Milliseconds after midnight at which the weekend stops on the
* day of the week weekendCease. Times that are greater than or
* equal to weekendCeaseMillis are considered not to be the
* weekend. Must be in the range 0..24*60*60*1000-1. This value
* is taken from locale resource data.
*/
private int weekendCeaseMillis;
/**
* Cache to hold the firstDayOfWeek and minimalDaysInFirstWeek
* of a Locale.
*/
private static Hashtable cachedLocaleData = new Hashtable(3);
/**
* Value of the time stamp stamp[] indicating that
* a field has not been set since the last call to clear().
* @see #INTERNALLY_SET
* @see #MINIMUM_USER_STAMP
* @stable ICU 2.0
*/
protected static final int UNSET = 0;
/**
* Value of the time stamp stamp[] indicating that a field
* has been set via computations from the time or from other fields.
* @see #UNSET
* @see #MINIMUM_USER_STAMP
* @stable ICU 2.0
*/
protected static final int INTERNALLY_SET = 1;
/**
* If the time stamp stamp[] has a value greater than or
* equal to MINIMUM_USER_SET then it has been set by the
* user via a call to set().
* @see #UNSET
* @see #INTERNALLY_SET
* @stable ICU 2.0
*/
protected static final int MINIMUM_USER_STAMP = 2;
/**
* The next available value for stamp[], an internal array.
* @serial
*/
private transient int nextStamp = MINIMUM_USER_STAMP;
// the internal serial version which says which version was written
// - 0 (default) for version up to JDK 1.1.5
// - 1 for version from JDK 1.1.6, which writes a correct 'time' value
// as well as compatible values for other fields. This is a
// transitional format.
// - 2 (not implemented yet) a future version, in which fields[],
// areFieldsSet, and isTimeSet become transient, and isSet[] is
// removed. In JDK 1.1.6 we write a format compatible with version 2.
// static final int currentSerialVersion = 1;
/**
* The version of the serialized data on the stream. Possible values:
*
*
* When streaming out this class, the most recent format
* and the highest allowable serialVersionOnStream
* is written.
* @serial
* @since JDK1.1.6
*/
// private int serialVersionOnStream = currentSerialVersion;
// Proclaim serialization compatibility with JDK 1.1
// static final long serialVersionUID = -1807547505821590642L;
// haven't been compatible for awhile, no longer try
// jdk1.4.2 serialver
private static final long serialVersionUID = 6222646104888790989L;
/**
* Bitmask for internalSet() defining which fields may legally be set
* by subclasses. Any attempt to set a field not in this bitmask
* results in an exception, because such fields must be set by the base
* class.
*/
private transient int internalSetMask;
/**
* The Gregorian year, as computed by computeGregorianFields() and
* returned by getGregorianYear().
*/
private transient int gregorianYear;
/**
* The Gregorian month, as computed by computeGregorianFields() and
* returned by getGregorianMonth().
*/
private transient int gregorianMonth;
/**
* The Gregorian day of the year, as computed by
* computeGregorianFields() and returned by getGregorianDayOfYear().
*/
private transient int gregorianDayOfYear;
/**
* The Gregorian day of the month, as computed by
* computeGregorianFields() and returned by getGregorianDayOfMonth().
*/
private transient int gregorianDayOfMonth;
/**
* Constructs a Calendar with the default time zone
* and locale.
* @see TimeZone#getDefault
* @stable ICU 2.0
*/
protected Calendar()
{
this(TimeZone.getDefault(), ULocale.getDefault());
}
/**
* Constructs a calendar with the specified time zone and locale.
* @param zone the time zone to use
* @param aLocale the locale for the week data
* @stable ICU 2.0
*/
protected Calendar(TimeZone zone, Locale aLocale)
{
this(zone, ULocale.forLocale(aLocale));
}
/**
* Constructs a calendar with the specified time zone and locale.
* @param zone the time zone to use
* @param locale the ulocale for the week data
* @stable ICU 3.2
*/
protected Calendar(TimeZone zone, ULocale locale)
{
this.zone = zone;
setWeekData(locale);
initInternal();
}
private void initInternal()
{
// Allocate fields through the framework method. Subclasses
// may override this to define additional fields.
fields = handleCreateFields();
///CLOVER:OFF
// todo: fix, difficult to test without subclassing
if (fields == null || fields.length < BASE_FIELD_COUNT ||
fields.length > MAX_FIELD_COUNT) {
throw new IllegalStateException("Invalid fields[]");
}
///CLOVER:ON
stamp = new int[fields.length];
int mask = (1 << ERA) |
(1 << YEAR) |
(1 << MONTH) |
(1 << DAY_OF_MONTH) |
(1 << DAY_OF_YEAR) |
(1 << EXTENDED_YEAR);
for (int i=BASE_FIELD_COUNT; isetTime() with
* Date(Long.MAX_VALUE) or Date(Long.MIN_VALUE)
* may yield incorrect field values from get().
* @param date the given Date.
* @stable ICU 2.0
*/
public final void setTime(Date date) {
setTimeInMillis( date.getTime() );
}
/**
* Gets this Calendar's current time as a long.
* @return the current time as UTC milliseconds from the epoch.
* @stable ICU 2.0
*/
public long getTimeInMillis() {
if (!isTimeSet) updateTime();
return time;
}
/**
* Sets this Calendar's current time from the given long value.
* @param millis the new time in UTC milliseconds from the epoch.
* @stable ICU 2.0
*/
public void setTimeInMillis( long millis ) {
if (millis > MAX_MILLIS) {
millis = MAX_MILLIS;
} else if (millis < MIN_MILLIS) {
millis = MIN_MILLIS;
}
time = millis;
areFieldsSet = areAllFieldsSet = false;
isTimeSet = areFieldsVirtuallySet = true;
}
/**
* Gets the value for a given time field.
* @param field the given time field.
* @return the value for the given time field.
* @stable ICU 2.0
*/
public final int get(int field)
{
complete();
return fields[field];
}
/**
* Gets the value for a given time field. This is an internal method
* for subclasses that does not trigger any calculations.
* @param field the given time field.
* @return the value for the given time field.
* @stable ICU 2.0
*/
protected final int internalGet(int field)
{
return fields[field];
}
/**
* Get the value for a given time field, or return the given default
* value if the field is not set. This is an internal method for
* subclasses that does not trigger any calculations.
* @param field the given time field.
* @param defaultValue value to return if field is not set
* @return the value for the given time field of defaultValue if the
* field is unset
* @stable ICU 2.0
*/
protected final int internalGet(int field, int defaultValue) {
return (stamp[field] > UNSET) ? fields[field] : defaultValue;
}
/**
* Sets the time field with the given value.
* @param field the given time field.
* @param value the value to be set for the given time field.
* @stable ICU 2.0
*/
public final void set(int field, int value)
{
if (areFieldsVirtuallySet) {
computeFields();
}
fields[field] = value;
stamp[field] = nextStamp++;
isTimeSet = areFieldsSet = areFieldsVirtuallySet = false;
}
/**
* Sets the values for the fields year, month, and date.
* Previous values of other fields are retained. If this is not desired,
* call clear first.
* @param year the value used to set the YEAR time field.
* @param month the value used to set the MONTH time field.
* Month value is 0-based. e.g., 0 for January.
* @param date the value used to set the DATE time field.
* @stable ICU 2.0
*/
public final void set(int year, int month, int date)
{
set(YEAR, year);
set(MONTH, month);
set(DATE, date);
}
/**
* Sets the values for the fields year, month, date, hour, and minute.
* Previous values of other fields are retained. If this is not desired,
* call clear first.
* @param year the value used to set the YEAR time field.
* @param month the value used to set the MONTH time field.
* Month value is 0-based. e.g., 0 for January.
* @param date the value used to set the DATE time field.
* @param hour the value used to set the HOUR_OF_DAY time field.
* @param minute the value used to set the MINUTE time field.
* @stable ICU 2.0
*/
public final void set(int year, int month, int date, int hour, int minute)
{
set(YEAR, year);
set(MONTH, month);
set(DATE, date);
set(HOUR_OF_DAY, hour);
set(MINUTE, minute);
}
/**
* Sets the values for the fields year, month, date, hour, minute, and second.
* Previous values of other fields are retained. If this is not desired,
* call clear first.
* @param year the value used to set the YEAR time field.
* @param month the value used to set the MONTH time field.
* Month value is 0-based. e.g., 0 for January.
* @param date the value used to set the DATE time field.
* @param hour the value used to set the HOUR_OF_DAY time field.
* @param minute the value used to set the MINUTE time field.
* @param second the value used to set the SECOND time field.
* @stable ICU 2.0
*/
public final void set(int year, int month, int date, int hour, int minute,
int second)
{
set(YEAR, year);
set(MONTH, month);
set(DATE, date);
set(HOUR_OF_DAY, hour);
set(MINUTE, minute);
set(SECOND, second);
}
/**
* Clears the values of all the time fields.
* @stable ICU 2.0
*/
public final void clear()
{
for (int i=0; inull and is a Calendar object that
* represents the same calendar as this object.
* @param obj the object to compare with.
* @return true if the objects are the same;
* false otherwise.
* @stable ICU 2.0
*/
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (this.getClass() != obj.getClass()) {
return false;
}
Calendar that = (Calendar) obj;
return isEquivalentTo(that) &&
getTimeInMillis() == that.getTime().getTime();
}
/**
* Returns true if the given Calendar object is equivalent to this
* one. An equivalent Calendar will behave exactly as this one
* does, but it may be set to a different time. By contrast, for
* the equals() method to return true, the other Calendar must
* be set to the same time.
*
* @param other the Calendar to be compared with this Calendar
* @stable ICU 2.4
*/
public boolean isEquivalentTo(Calendar other) {
return this.getClass() == other.getClass() &&
isLenient() == other.isLenient() &&
getFirstDayOfWeek() == other.getFirstDayOfWeek() &&
getMinimalDaysInFirstWeek() == other.getMinimalDaysInFirstWeek() &&
getTimeZone().equals(other.getTimeZone());
}
/**
* Returns a hash code for this calendar.
* @return a hash code value for this object.
* @stable ICU 2.0
*/
public int hashCode() {
/* Don't include the time because (a) we don't want the hash value to
* move around just because a calendar is set to different times, and
* (b) we don't want to trigger a time computation just to get a hash.
* Note that it is not necessary for unequal objects to always have
* unequal hashes, but equal objects must have equal hashes. */
return (lenient ? 1 : 0)
| (firstDayOfWeek << 1)
| (minimalDaysInFirstWeek << 4)
| (zone.hashCode() << 7);
}
/**
* Return the difference in milliseconds between the moment this
* calendar is set to and the moment the given calendar or Date object
* is set to.
*/
private long compare(Object that) {
long thatMs;
if (that instanceof Calendar) {
thatMs = ((Calendar)that).getTimeInMillis();
} else if (that instanceof Date) {
thatMs = ((Date)that).getTime();
} else {
throw new IllegalArgumentException(that + "is not a Calendar or Date");
}
return getTimeInMillis() - thatMs;
}
/**
* Compares the time field records.
* Equivalent to comparing result of conversion to UTC.
* @param when the Calendar to be compared with this Calendar.
* @return true if the current time of this Calendar is before
* the time of Calendar when; false otherwise.
* @stable ICU 2.0
*/
public boolean before(Object when) {
return compare(when) < 0;
}
/**
* Compares the time field records.
* Equivalent to comparing result of conversion to UTC.
* @param when the Calendar to be compared with this Calendar.
* @return true if the current time of this Calendar is after
* the time of Calendar when; false otherwise.
* @stable ICU 2.0
*/
public boolean after(Object when) {
return compare(when) > 0;
}
/**
* Return the maximum value that this field could have, given the
* current date. For example, with the Gregorian date February 3, 1997
* and the {@link #DAY_OF_MONTH DAY_OF_MONTH} field, the actual maximum
* is 28; for February 3, 1996 it is 29.
*
* getActualMinimum(WEEK_OF_MONTH) will return 1. However,
* if the first of the month is a Thursday, Friday, or Saturday, there are
* not four days in that week, so it is week number 0, and
* getActualMinimum(WEEK_OF_MONTH) will return 0.
* roll({@link #DATE}, true)
* MONTH field
* for the Gregorian date 1/31/96 upward, the DAY_OF_MONTH field
* must be adjusted so that the result is 2/29/96 rather than the invalid
* 2/31/96.
* true if rolling up,
* false otherwise.
*
* @exception IllegalArgumentException if the field is invalid or refers
* to a field that cannot be handled by this method.
* @see #roll(int, int)
* @see #add
* @stable ICU 2.0
*/
public final void roll(int field, boolean up)
{
roll(field, up ? +1 : -1);
}
/**
* Rolls (up/down) a specified amount time on the given field. For
* example, to roll the current date up by three days, you can call
* roll(Calendar.DATE, 3). If the
* field is rolled past its maximum allowable value, it will "wrap" back
* to its minimum and continue rolling.
* For example, calling roll(Calendar.DATE, 10)
* on a Gregorian calendar set to 4/25/96 will result in the date 4/5/96.
* com.ibm.icu.util.Calendar implementation of this method is able to roll
* all fields except for {@link #ERA ERA}, {@link #DST_OFFSET DST_OFFSET},
* and {@link #ZONE_OFFSET ZONE_OFFSET}. Subclasses may, of course, add support for
* additional fields in their overrides of roll.
*
* This implementation of roll assumes that the behavior of the
* field is continuous between its minimum and maximum, which are found by
* calling {@link #getActualMinimum getActualMinimum} and {@link #getActualMaximum getActualMaximum}.
* For most such fields, simple addition, subtraction, and modulus operations
* are sufficient to perform the roll. For week-related fields,
* the results of {@link #getFirstDayOfWeek getFirstDayOfWeek} and
* {@link #getMinimalDaysInFirstWeek getMinimalDaysInFirstWeek} are also necessary.
* Subclasses can override these two methods if their values differ from the defaults.
* roll to handle those fields specially.
* For example, in the Hebrew calendar the month "Adar I"
* only occurs in leap years; in other years the calendar jumps from
* Shevat (month #4) to Adar (month #6). The
* {@link HebrewCalendar#roll HebrewCalendar.roll} method takes this into account,
* so that rolling the month of Shevat by one gives the proper result (Adar) in a
* non-leap year.
* add(Calendar.DATE, 3).
* com.ibm.icu.util.Calendar implementation of this method is able to add to
* all fields except for {@link #ERA ERA}, {@link #DST_OFFSET DST_OFFSET},
* and {@link #ZONE_OFFSET ZONE_OFFSET}. Subclasses may, of course, add support for
* additional fields in their overrides of add.
*
* This implementation of add assumes that the behavior of the
* field is continuous between its minimum and maximum, which are found by
* calling {@link #getActualMinimum getActualMinimum} and
* {@link #getActualMaximum getActualMaximum}.
* For such fields, simple arithmetic operations are sufficient to
* perform the add.
* add to handle those fields specially.
* For example, in the Hebrew calendar the month "Adar I"
* only occurs in leap years; in other years the calendar jumps from
* Shevat (month #4) to Adar (month #6). The
* {@link HebrewCalendar#add HebrewCalendar.add} method takes this into account,
* so that adding one month
* to a date in Shevat gives the proper result (Adar) in a non-leap year.
* Calendar objects.
*
* @param that the Calendar to compare to this.
* @return 0 if the time represented by
* this Calendar is equal to the time represented
* by that Calendar, a value less than
* 0 if the time represented by this is before
* the time represented by that, and a value greater than
* 0 if the time represented by this
* is after the time represented by that.
* @throws NullPointerException if that
* Calendar is null.
* @throws IllegalArgumentException if the time of that
* Calendar can't be obtained because of invalid
* calendar values.
* @stable ICU 3.4
*/
public int compareTo(Calendar that) {
long v = getTimeInMillis() - that.getTimeInMillis();
return v < 0 ? -1 : (v > 0 ? 1 : 0);
}
/**
* Implement comparable API as a convenience override of
* {@link #compareTo(Calendar)}.
* @stable ICU 3.4
*/
public int compareTo(Object that) {
return compareTo((Calendar)that);
}
//-------------------------------------------------------------------------
// Interface for creating custon DateFormats for different types of Calendars
//-------------------------------------------------------------------------
/**
* Return a DateFormat appropriate to this calendar.
* Subclasses wishing to specialize this behavior should override
* handleGetDateFormat()
* @see #handleGetDateFormat
* @stable ICU 2.0
*/
public DateFormat getDateTimeFormat(int dateStyle, int timeStyle, Locale loc) {
return formatHelper(this, ULocale.forLocale(loc), dateStyle, timeStyle);
}
/**
* Return a DateFormat appropriate to this calendar.
* Subclasses wishing to specialize this behavior should override
* handleGetDateFormat()
* @see #handleGetDateFormat
* @stable ICU 3.2
*/
public DateFormat getDateTimeFormat(int dateStyle, int timeStyle, ULocale loc) {
return formatHelper(this, loc, dateStyle, timeStyle);
}
/**
* Create a DateFormat appropriate to this calendar.
* This is a framework method for subclasses to override. This method
* is responsible for creating the calendar-specific DateFormat and
* DateFormatSymbols objects as needed.
* @param pattern the pattern, specific to the DateFormat
* subclass
* @param locale the locale for which the symbols should be drawn
* @return a DateFormat appropriate to this calendar
* @stable ICU 2.0
*/
protected DateFormat handleGetDateFormat(String pattern, Locale locale) {
return handleGetDateFormat(pattern, null, ULocale.forLocale(locale));
}
/**
* Create a DateFormat appropriate to this calendar.
* This is a framework method for subclasses to override. This method
* is responsible for creating the calendar-specific DateFormat and
* DateFormatSymbols objects as needed.
* @param pattern the pattern, specific to the DateFormat
* subclass
* @param locale the locale for which the symbols should be drawn
* @return a DateFormat appropriate to this calendar
* @stable ICU 2.0
*/
protected DateFormat handleGetDateFormat(String pattern, String override, Locale locale) {
return handleGetDateFormat(pattern, override, ULocale.forLocale(locale));
}
/**
* Create a DateFormat appropriate to this calendar.
* This is a framework method for subclasses to override. This method
* is responsible for creating the calendar-specific DateFormat and
* DateFormatSymbols objects as needed.
* @param pattern the pattern, specific to the DateFormat
* subclass
* @param locale the locale for which the symbols should be drawn
* @return a DateFormat appropriate to this calendar
* @stable ICU 2.0
*/
protected DateFormat handleGetDateFormat(String pattern, ULocale locale) {
return handleGetDateFormat(pattern, null, locale);
}
/**
* Create a DateFormat appropriate to this calendar.
* This is a framework method for subclasses to override. This method
* is responsible for creating the calendar-specific DateFormat and
* DateFormatSymbols objects as needed.
* @param pattern the pattern, specific to the DateFormat
* subclass
* @param locale the locale for which the symbols should be drawn
* @return a DateFormat appropriate to this calendar
* @draft ICU 3.2 (retain)
* @provisional This API might change or be removed in a future release.
*/
protected DateFormat handleGetDateFormat(String pattern, String override, ULocale locale) {
FormatConfiguration fmtConfig = new FormatConfiguration();
fmtConfig.pattern = pattern;
fmtConfig.override = override;
fmtConfig.formatData = new DateFormatSymbols(this, locale);
fmtConfig.loc = locale;
fmtConfig.cal = this;
return SimpleDateFormat.getInstance(fmtConfig);
}
// date format pattern cache
private static final ICUCache PATTERN_CACHE = new SimpleCache();
// final fallback patterns
private static final String[] DEFAULT_PATTERNS = {
"HH:mm:ss z",
"HH:mm:ss z",
"HH:mm:ss",
"HH:mm",
"EEEE, yyyy MMMM dd",
"yyyy MMMM d",
"yyyy MMM d",
"yy/MM/dd",
"{1} {0}",
"{1} {0}",
"{1} {0}",
"{1} {0}",
"{1} {0}"
};
static private DateFormat formatHelper(Calendar cal, ULocale loc, int dateStyle, int timeStyle) {
PatternData patternData = PatternData.make(cal, loc);
String override = null;
// Resolve a pattern for the date/time style
String pattern = null;
if ((timeStyle >= 0) && (dateStyle >= 0)) {
pattern = MessageFormat.format(patternData.getDateTimePattern(dateStyle),
new Object[] {patternData.patterns[timeStyle], patternData.patterns[dateStyle + 4]});
// Might need to merge the overrides from the date and time into a single override string
// TODO: Right now we are forcing the date's override into the time style.
if ( patternData.overrides != null ) {
String dateOverride = patternData.overrides[dateStyle + 4];
String timeOverride = patternData.overrides[timeStyle];
override = mergeOverrideStrings(patternData.patterns[dateStyle+4],patternData.patterns[timeStyle],dateOverride,timeOverride);
}
} else if (timeStyle >= 0) {
pattern = patternData.patterns[timeStyle];
if ( patternData.overrides != null ) {
override = patternData.overrides[timeStyle];
}
} else if (dateStyle >= 0) {
pattern = patternData.patterns[dateStyle + 4];
if ( patternData.overrides != null ) {
override = patternData.overrides[dateStyle + 4];
}
} else {
throw new IllegalArgumentException("No date or time style specified");
}
DateFormat result = cal.handleGetDateFormat(pattern, override, loc);
result.setCalendar(cal);
return result;
}
static class PatternData {
// TODO make this even more object oriented
private String[] patterns;
private String[] overrides;
public PatternData(String[] patterns, String[] overrides) {
this.patterns = patterns;
this.overrides = overrides;
}
private String getDateTimePattern(int dateStyle) {
int glueIndex = 8;
if (patterns.length >= 13) {
glueIndex += (dateStyle + 1);
}
final String dateTimePattern = patterns[glueIndex];
return dateTimePattern;
}
private static PatternData make(Calendar cal, ULocale loc) {
// First, try to get a pattern from PATTERN_CACHE
String key = loc.toString() + cal.getType();
PatternData patternData = (PatternData) PATTERN_CACHE.get(key);
if (patternData == null) {
// Cache missed. Get one from bundle
try {
CalendarData calData = new CalendarData(loc, cal.getType());
patternData = new PatternData(calData.getDateTimePatterns(), calData.getOverrides());
} catch (MissingResourceException e) {
patternData = new PatternData(DEFAULT_PATTERNS, null);
}
PATTERN_CACHE.put(key, patternData);
}
return patternData;
}
}
/**
* @internal
* @deprecated This API is ICU internal only.
*/
public static String getDateTimePattern(Calendar cal, ULocale uLocale, int dateStyle) {
PatternData patternData = PatternData.make(cal, uLocale);
return patternData.getDateTimePattern(dateStyle);
}
private static String mergeOverrideStrings( String datePattern, String timePattern, String dateOverride, String timeOverride ) {
if ( dateOverride == null && timeOverride == null ) {
return null;
}
if ( dateOverride == null ) {
return expandOverride(timePattern,timeOverride);
}
if ( timeOverride == null ) {
return expandOverride(datePattern,dateOverride);
}
if ( dateOverride.equals(timeOverride) ) {
return dateOverride;
}
return (expandOverride(datePattern,dateOverride)+";"+expandOverride(timePattern,timeOverride));
}
private static final char QUOTE = '\'';
private static String expandOverride(String pattern, String override) {
if (override.indexOf('=') >= 0) {
return override;
}
boolean inQuotes = false;
char prevChar = ' ';
StringBuffer result = new StringBuffer();
StringCharacterIterator it = new StringCharacterIterator(pattern);
for (char c = it.first(); c!= StringCharacterIterator.DONE; c = it.next()) {
if ( c == QUOTE ) {
inQuotes = !inQuotes;
prevChar = c;
continue;
}
if ( !inQuotes && c != prevChar ) {
if (result.length() > 0) {
result.append(";");
}
result.append(c);
result.append("=");
result.append(override);
}
prevChar = c;
}
return result.toString();
}
/**
* An instance of FormatConfiguration represents calendar specific
* date format configuration and used for calling the ICU private
* SimpleDateFormat factory method.
*
* @internal
* @deprecated This API is ICU internal only.
*/
public static class FormatConfiguration {
private String pattern;
private String override;
private DateFormatSymbols formatData;
private Calendar cal;
private ULocale loc;
// Only Calendar can instantiate
private FormatConfiguration() {
}
/**
* Gets the pattern string
* @return the format pattern string
* @internal
* @deprecated This API is ICU internal only.
*/
public String getPatternString() {
return pattern;
}
public String getOverrideString() {
return override;
}
/**
* Gets the calendar
* @return the calendar
* @internal
* @deprecated This API is ICU internal only.
*/
public Calendar getCalendar() {
return cal;
}
/**
* Gets the locale
* @return the locale
* @internal
* @deprecated This API is ICU internal only.
*/
public ULocale getLocale() {
return loc;
}
/**
* Gets the format symbols
* @return the format symbols
* @internal
* @deprecated This API is ICU internal only.
*/
public DateFormatSymbols getDateFormatSymbols() {
return formatData;
}
}
//-------------------------------------------------------------------------
// Protected utility methods for use by subclasses. These are very handy
// for implementing add, roll, and computeFields.
//-------------------------------------------------------------------------
/**
* Adjust the specified field so that it is within
* the allowable range for the date to which this calendar is set.
* For example, in a Gregorian calendar pinning the {@link #DAY_OF_MONTH DAY_OF_MONTH}
* field for a calendar set to April 31 would cause it to be set
* to April 30.
*
* This utility method is intended for use by subclasses that need to implement
* their own overrides of {@link #roll roll} and {@link #add add}.
* pinField is implemented in terms of
* {@link #getActualMinimum getActualMinimum}
* and {@link #getActualMaximum getActualMaximum}. If either of those methods uses
* a slow, iterative algorithm for a particular field, it would be
* unwise to attempt to call pinField for that field. If you
* really do need to do so, you should override this method to do
* something more efficient for that field.
*
* This method is intended for use by subclasses in implementing their
* {@link #computeTime computeTime} and/or {@link #computeFields computeFields} methods.
* It is often useful in {@link #getActualMinimum getActualMinimum} and
* {@link #getActualMaximum getActualMaximum} as well.
* dayOfWeek parameter.
* Should be 1 for first day of period.
*
* @param dayOfWeek The {@link #DAY_OF_WEEK DAY_OF_WEEK} for the day
* corresponding to the dayOfPeriod parameter.
* 1-based with 1=Sunday.
*
* @return The week number (one-based), or zero if the day falls before
* the first week because
* {@link #getMinimalDaysInFirstWeek getMinimalDaysInFirstWeek}
* is more than one.
* @stable ICU 2.0
*/
protected int weekNumber(int desiredDay, int dayOfPeriod, int dayOfWeek)
{
// Determine the day of the week of the first day of the period
// in question (either a year or a month). Zero represents the
// first day of the week on this calendar.
int periodStartDayOfWeek = (dayOfWeek - getFirstDayOfWeek() - dayOfPeriod + 1) % 7;
if (periodStartDayOfWeek < 0) periodStartDayOfWeek += 7;
// Compute the week number. Initially, ignore the first week, which
// may be fractional (or may not be). We add periodStartDayOfWeek in
// order to fill out the first week, if it is fractional.
int weekNo = (desiredDay + periodStartDayOfWeek - 1)/7;
// If the first week is long enough, then count it. If
// the minimal days in the first week is one, or if the period start
// is zero, we always increment weekNo.
if ((7 - periodStartDayOfWeek) >= getMinimalDaysInFirstWeek()) ++weekNo;
return weekNo;
}
/**
* Return the week number of a day, within a period. This may be the week number in
* a year, or the week number in a month. Usually this will be a value >= 1, but if
* some initial days of the period are excluded from week 1, because
* {@link #getMinimalDaysInFirstWeek getMinimalDaysInFirstWeek} is > 1,
* then the week number will be zero for those
* initial days. This method requires the day of week for the given date in order to
* determine the result.
*
* This method is intended for use by subclasses in implementing their
* {@link #computeTime computeTime} and/or {@link #computeFields computeFields} methods.
* It is often useful in {@link #getActualMinimum getActualMinimum} and
* {@link #getActualMaximum getActualMaximum} as well.
* dayOfPeriod parameter.
* 1-based with 1=Sunday.
*
* @return The week number (one-based), or zero if the day falls before
* the first week because
* {@link #getMinimalDaysInFirstWeek getMinimalDaysInFirstWeek}
* is more than one.
* @stable ICU 2.0
*/
protected final int weekNumber(int dayOfPeriod, int dayOfWeek)
{
return weekNumber(dayOfPeriod, dayOfPeriod, dayOfWeek);
}
//-------------------------------------------------------------------------
// Constants
//-------------------------------------------------------------------------
/**
* [NEW]
* Return the difference between the given time and the time this
* calendar object is set to. If this calendar is set
* before the given time, the returned value will be
* positive. If this calendar is set after the given
* time, the returned value will be negative. The
* field parameter specifies the units of the return
* value. For example, if fieldDifference(when,
* Calendar.MONTH) returns 3, then this calendar is set to
* 3 months before when, and possibly some additional
* time less than one month.
*
* when by the given amount. That is, calling
* this method has the side effect of calling add(field,
* n), where n is the return value.
*
*
* int y = cal.fieldDifference(when, Calendar.YEAR);
* int m = cal.fieldDifference(when, Calendar.MONTH);
* int d = cal.fieldDifference(when, Calendar.DATE);
*
* computes the difference between cal and
* when in years, months, and days.
*
* fieldDifference() is
* asymmetrical. That is, in the following code:
*
*
* cal.setTime(date1);
* int m1 = cal.fieldDifference(date2, Calendar.MONTH);
* int d1 = cal.fieldDifference(date2, Calendar.DATE);
* cal.setTime(date2);
* int m2 = cal.fieldDifference(date1, Calendar.MONTH);
* int d2 = cal.fieldDifference(date1, Calendar.DATE);
*
* one might expect that m1 == -m2 && d1 == -d2.
* However, this is not generally the case, because of
* irregularities in the underlying calendar system (e.g., the
* Gregorian calendar has a varying number of days per month).
*
* @param when the date to compare this calendar's time to
* @param field the field in which to compute the result
* @return the difference, either positive or negative, between
* this calendar's time and when, in terms of
* field.
* @stable ICU 2.0
*/
public int fieldDifference(Date when, int field) {
int min = 0;
long startMs = getTimeInMillis();
long targetMs = when.getTime();
// Always add from the start millis. This accomodates
// operations like adding years from February 29, 2000 up to
// February 29, 2004. If 1, 1, 1, 1 is added to the year
// field, the DOM gets pinned to 28 and stays there, giving an
// incorrect DOM difference of 1. We have to add 1, reset, 2,
// reset, 3, reset, 4.
if (startMs < targetMs) {
int max = 1;
// Find a value that is too large
for (;;) {
setTimeInMillis(startMs);
add(field, max);
long ms = getTimeInMillis();
if (ms == targetMs) {
return max;
} else if (ms > targetMs) {
break;
} else {
max <<= 1;
if (max < 0) {
// Field difference too large to fit into int
throw new RuntimeException();
}
}
}
// Do a binary search
while ((max - min) > 1) {
int t = (min + max) / 2;
setTimeInMillis(startMs);
add(field, t);
long ms = getTimeInMillis();
if (ms == targetMs) {
return t;
} else if (ms > targetMs) {
max = t;
} else {
min = t;
}
}
} else if (startMs > targetMs) {
if (false) {
// This works, and makes the code smaller, but costs
// an extra object creation and an extra couple cycles
// of calendar computation.
setTimeInMillis(targetMs);
min = -fieldDifference(new Date(startMs), field);
}
int max = -1;
// Find a value that is too small
for (;;) {
setTimeInMillis(startMs);
add(field, max);
long ms = getTimeInMillis();
if (ms == targetMs) {
return max;
} else if (ms < targetMs) {
break;
} else {
max <<= 1;
if (max == 0) {
// Field difference too large to fit into int
throw new RuntimeException();
}
}
}
// Do a binary search
while ((min - max) > 1) {
int t = (min + max) / 2;
setTimeInMillis(startMs);
add(field, t);
long ms = getTimeInMillis();
if (ms == targetMs) {
return t;
} else if (ms < targetMs) {
max = t;
} else {
min = t;
}
}
}
// Set calendar to end point
setTimeInMillis(startMs);
add(field, min);
return min;
}
/**
* Sets the time zone with the given time zone value.
* @param value the given time zone.
* @stable ICU 2.0
*/
public void setTimeZone(TimeZone value)
{
zone = value;
/* Recompute the fields from the time using the new zone. This also
* works if isTimeSet is false (after a call to set()). In that case
* the time will be computed from the fields using the new zone, then
* the fields will get recomputed from that. Consider the sequence of
* calls: cal.setTimeZone(EST); cal.set(HOUR, 1); cal.setTimeZone(PST).
* Is cal set to 1 o'clock EST or 1 o'clock PST? Answer: PST. More
* generally, a call to setTimeZone() affects calls to set() BEFORE AND
* AFTER it up to the next call to complete().
*/
areFieldsSet = false;
}
/**
* Gets the time zone.
* @return the time zone object associated with this calendar.
* @stable ICU 2.0
*/
public TimeZone getTimeZone()
{
return zone;
}
/**
* Specify whether or not date/time interpretation is to be lenient. With
* lenient interpretation, a date such as "February 942, 1996" will be
* treated as being equivalent to the 941st day after February 1, 1996.
* With strict interpretation, such dates will cause an exception to be
* thrown.
*
* @see DateFormat#setLenient
* @stable ICU 2.0
*/
public void setLenient(boolean lenient)
{
this.lenient = lenient;
}
/**
* Tell whether date/time interpretation is to be lenient.
* @stable ICU 2.0
*/
public boolean isLenient()
{
return lenient;
}
/**
* Sets what the first day of the week is; e.g., Sunday in US,
* Monday in France.
* @param value the given first day of the week.
* @stable ICU 2.0
*/
public void setFirstDayOfWeek(int value)
{
if (firstDayOfWeek != value) {
if (value < SUNDAY || value > SATURDAY) {
throw new IllegalArgumentException("Invalid day of week");
}
firstDayOfWeek = value;
areFieldsSet = false;
}
}
/**
* Gets what the first day of the week is; e.g., Sunday in US,
* Monday in France.
* @return the first day of the week.
* @stable ICU 2.0
*/
public int getFirstDayOfWeek()
{
return firstDayOfWeek;
}
/**
* Sets what the minimal days required in the first week of the year are.
* For example, if the first week is defined as one that contains the first
* day of the first month of a year, call the method with value 1. If it
* must be a full week, use value 7.
* @param value the given minimal days required in the first week
* of the year.
* @stable ICU 2.0
*/
public void setMinimalDaysInFirstWeek(int value)
{
// Values less than 1 have the same effect as 1; values greater
// than 7 have the same effect as 7. However, we normalize values
// so operator== and so forth work.
if (value < 1) {
value = 1;
} else if (value > 7) {
value = 7;
}
if (minimalDaysInFirstWeek != value) {
minimalDaysInFirstWeek = value;
areFieldsSet = false;
}
}
/**
* Gets what the minimal days required in the first week of the year are;
* e.g., if the first week is defined as one that contains the first day
* of the first month of a year, getMinimalDaysInFirstWeek returns 1. If
* the minimal days required must be a full week, getMinimalDaysInFirstWeek
* returns 7.
* @return the minimal days required in the first week of the year.
* @stable ICU 2.0
*/
public int getMinimalDaysInFirstWeek()
{
return minimalDaysInFirstWeek;
}
private static final int LIMITS[][] = {
// Minimum Greatest min Least max Greatest max
{/* */}, // ERA
{/* */}, // YEAR
{/* */}, // MONTH
{/* */}, // WEEK_OF_YEAR
{/* */}, // WEEK_OF_MONTH
{/* */}, // DAY_OF_MONTH
{/* */}, // DAY_OF_YEAR
{ 1, 1, 7, 7 }, // DAY_OF_WEEK
{/* */}, // DAY_OF_WEEK_IN_MONTH
{ 0, 0, 1, 1 }, // AM_PM
{ 0, 0, 11, 11 }, // HOUR
{ 0, 0, 23, 23 }, // HOUR_OF_DAY
{ 0, 0, 59, 59 }, // MINUTE
{ 0, 0, 59, 59 }, // SECOND
{ 0, 0, 999, 999 }, // MILLISECOND
{-12*ONE_HOUR, -12*ONE_HOUR, 12*ONE_HOUR, 12*ONE_HOUR }, // ZONE_OFFSET
{ 0, 0, 1*ONE_HOUR, 1*ONE_HOUR }, // DST_OFFSET
{/* */}, // YEAR_WOY
{ 1, 1, 7, 7 }, // DOW_LOCAL
{/* */}, // EXTENDED_YEAR
{ -0x7F000000, -0x7F000000, 0x7F000000, 0x7F000000 }, // JULIAN_DAY
{ 0, 0, 24*ONE_HOUR-1, 24*ONE_HOUR-1 }, // MILLISECONDS_IN_DAY
};
/**
* Subclass API for defining limits of different types.
* Subclasses must implement this method to return limits for the
* following fields:
*
* ERA
* YEAR
* MONTH
* WEEK_OF_YEAR
* WEEK_OF_MONTH
* DAY_OF_MONTH
* DAY_OF_YEAR
* DAY_OF_WEEK_IN_MONTH
* YEAR_WOY
* EXTENDED_YEAR
*
* @param field one of the above field numbers
* @param limitType one of MINIMUM, GREATEST_MINIMUM,
* LEAST_MAXIMUM, or MAXIMUM
* @stable ICU 2.0
*/
abstract protected int handleGetLimit(int field, int limitType);
/**
* Return a limit for a field.
* @param field the field, from 0..getFieldCount()-1
* @param limitType the type specifier for the limit
* @see #MINIMUM
* @see #GREATEST_MINIMUM
* @see #LEAST_MAXIMUM
* @see #MAXIMUM
* @stable ICU 2.0
*/
protected int getLimit(int field, int limitType) {
switch (field) {
case DAY_OF_WEEK:
case AM_PM:
case HOUR:
case HOUR_OF_DAY:
case MINUTE:
case SECOND:
case MILLISECOND:
case ZONE_OFFSET:
case DST_OFFSET:
case DOW_LOCAL:
case JULIAN_DAY:
case MILLISECONDS_IN_DAY:
return LIMITS[field][limitType];
case WEEK_OF_MONTH:
{
int limit;
if (limitType == MINIMUM) {
limit = getMinimalDaysInFirstWeek() == 1 ? 1 : 0;
} else if (limitType == GREATEST_MINIMUM){
limit = 1;
} else {
int minDaysInFirst = getMinimalDaysInFirstWeek();
int daysInMonth = handleGetLimit(DAY_OF_MONTH, limitType);
if (limitType == LEAST_MAXIMUM) {
limit = (daysInMonth + (7 - minDaysInFirst)) / 7;
} else { // limitType == MAXIMUM
limit = (daysInMonth + 6 + (7 - minDaysInFirst)) / 7;
}
}
return limit;
}
}
return handleGetLimit(field, limitType);
}
/**
* Limit type for getLimit() and handleGetLimit()
* indicating the minimum value that a field can take (least minimum).
* @see #getLimit
* @see #handleGetLimit
* @stable ICU 2.0
*/
protected static final int MINIMUM = 0;
/**
* Limit type for getLimit() and handleGetLimit()
* indicating the greatest minimum value that a field can take.
* @see #getLimit
* @see #handleGetLimit
* @stable ICU 2.0
*/
protected static final int GREATEST_MINIMUM = 1;
/**
* Limit type for getLimit() and handleGetLimit()
* indicating the least maximum value that a field can take.
* @see #getLimit
* @see #handleGetLimit
* @stable ICU 2.0
*/
protected static final int LEAST_MAXIMUM = 2;
/**
* Limit type for getLimit() and handleGetLimit()
* indicating the maximum value that a field can take (greatest maximum).
* @see #getLimit
* @see #handleGetLimit
* @stable ICU 2.0
*/
protected static final int MAXIMUM = 3;
/**
* Gets the minimum value for the given time field.
* e.g., for Gregorian DAY_OF_MONTH, 1.
* @param field the given time field.
* @return the minimum value for the given time field.
* @stable ICU 2.0
*/
public final int getMinimum(int field) {
return getLimit(field, MINIMUM);
}
/**
* Gets the maximum value for the given time field.
* e.g. for Gregorian DAY_OF_MONTH, 31.
* @param field the given time field.
* @return the maximum value for the given time field.
* @stable ICU 2.0
*/
public final int getMaximum(int field) {
return getLimit(field, MAXIMUM);
}
/**
* Gets the highest minimum value for the given field if varies.
* Otherwise same as getMinimum(). For Gregorian, no difference.
* @param field the given time field.
* @return the highest minimum value for the given time field.
* @stable ICU 2.0
*/
public final int getGreatestMinimum(int field) {
return getLimit(field, GREATEST_MINIMUM);
}
/**
* Gets the lowest maximum value for the given field if varies.
* Otherwise same as getMaximum(). e.g., for Gregorian DAY_OF_MONTH, 28.
* @param field the given time field.
* @return the lowest maximum value for the given time field.
* @stable ICU 2.0
*/
public final int getLeastMaximum(int field) {
return getLimit(field, LEAST_MAXIMUM);
}
//-------------------------------------------------------------------------
// Weekend support -- determining which days of the week are the weekend
// in a given locale
//-------------------------------------------------------------------------
/**
* Return whether the given day of the week is a weekday, a
* weekend day, or a day that transitions from one to the other,
* in this calendar system. If a transition occurs at midnight,
* then the days before and after the transition will have the
* type WEEKDAY or WEEKEND. If a transition occurs at a time
* other than midnight, then the day of the transition will have
* the type WEEKEND_ONSET or WEEKEND_CEASE. In this case, the
* method getWeekendTransition() will return the point of
* transition.
* @param dayOfWeek either SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
* THURSDAY, FRIDAY, or SATURDAY
* @return either WEEKDAY, WEEKEND, WEEKEND_ONSET, or
* WEEKEND_CEASE
* @exception IllegalArgumentException if dayOfWeek is not
* between SUNDAY and SATURDAY, inclusive
* @see #WEEKDAY
* @see #WEEKEND
* @see #WEEKEND_ONSET
* @see #WEEKEND_CEASE
* @see #getWeekendTransition
* @see #isWeekend(Date)
* @see #isWeekend()
* @stable ICU 2.0
*/
public int getDayOfWeekType(int dayOfWeek) {
if (dayOfWeek < SUNDAY || dayOfWeek > SATURDAY) {
throw new IllegalArgumentException("Invalid day of week");
}
if (weekendOnset < weekendCease) {
if (dayOfWeek < weekendOnset || dayOfWeek > weekendCease) {
return WEEKDAY;
}
} else {
if (dayOfWeek > weekendCease && dayOfWeek < weekendOnset) {
return WEEKDAY;
}
}
if (dayOfWeek == weekendOnset) {
return (weekendOnsetMillis == 0) ? WEEKEND : WEEKEND_ONSET;
}
if (dayOfWeek == weekendCease) {
return (weekendCeaseMillis == 0) ? WEEKDAY : WEEKEND_CEASE;
}
return WEEKEND;
}
/**
* Return the time during the day at which the weekend begins or end in
* this calendar system. If getDayOfWeekType(dayOfWeek) ==
* WEEKEND_ONSET return the time at which the weekend begins. If
* getDayOfWeekType(dayOfWeek) == WEEKEND_CEASE return the time at
* which the weekend ends. If getDayOfWeekType(dayOfWeek) has some
* other value, then throw an exception.
* @param dayOfWeek either SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
* THURSDAY, FRIDAY, or SATURDAY
* @return the milliseconds after midnight at which the
* weekend begins or ends
* @exception IllegalArgumentException if dayOfWeek is not
* WEEKEND_ONSET or WEEKEND_CEASE
* @see #getDayOfWeekType
* @see #isWeekend(Date)
* @see #isWeekend()
* @stable ICU 2.0
*/
public int getWeekendTransition(int dayOfWeek) {
if (dayOfWeek == weekendOnset) {
return weekendOnsetMillis;
} else if (dayOfWeek == weekendCease) {
return weekendCeaseMillis;
}
throw new IllegalArgumentException("Not weekend transition day");
}
/**
* Return true if the given date and time is in the weekend in
* this calendar system. Equivalent to calling setTime() followed
* by isWeekend(). Note: This method changes the time this
* calendar is set to.
* @param date the date and time
* @return true if the given date and time is part of the
* weekend
* @see #getDayOfWeekType
* @see #getWeekendTransition
* @see #isWeekend()
* @stable ICU 2.0
*/
public boolean isWeekend(Date date) {
setTime(date);
return isWeekend();
}
/**
* Return true if this Calendar's current date and time is in the
* weekend in this calendar system.
* @return true if the given date and time is part of the
* weekend
* @see #getDayOfWeekType
* @see #getWeekendTransition
* @see #isWeekend(Date)
* @stable ICU 2.0
*/
public boolean isWeekend() {
int dow = get(DAY_OF_WEEK);
int dowt = getDayOfWeekType(dow);
switch (dowt) {
case WEEKDAY:
return false;
case WEEKEND:
return true;
default: // That is, WEEKEND_ONSET or WEEKEND_CEASE
// Use internalGet() because the above call to get() populated
// all fields.
// [Note: There should be a better way to get millis in day.
// For ICU4J, submit request for a MILLIS_IN_DAY field
// and a DAY_NUMBER field (could be Julian day #). - aliu]
int millisInDay = internalGet(MILLISECOND) + 1000 * (internalGet(SECOND) +
60 * (internalGet(MINUTE) + 60 * internalGet(HOUR_OF_DAY)));
int transition = getWeekendTransition(dow);
return (dowt == WEEKEND_ONSET)
? (millisInDay >= transition)
: (millisInDay < transition);
}
// (We can never reach this point.)
}
//-------------------------------------------------------------------------
// End of weekend support
//-------------------------------------------------------------------------
/**
* Overrides Cloneable
* @stable ICU 2.0
*/
public Object clone()
{
try {
Calendar other = (Calendar) super.clone();
other.fields = new int[fields.length];
other.stamp = new int[fields.length];
System.arraycopy(this.fields, 0, other.fields, 0, fields.length);
System.arraycopy(this.stamp, 0, other.stamp, 0, fields.length);
other.zone = (TimeZone) zone.clone();
return other;
}
catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new IllegalStateException();
}
}
/**
* Return a string representation of this calendar. This method
* is intended to be used only for debugging purposes, and the
* format of the returned string may vary between implementations.
* The returned string may be empty but may not be null.
*
* @return a string representation of this calendar.
* @stable ICU 2.0
*/
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append(getClass().getName());
buffer.append("[time=");
buffer.append(isTimeSet ? String.valueOf(time) : "?");
buffer.append(",areFieldsSet=");
buffer.append(areFieldsSet);
buffer.append(",areAllFieldsSet=");
buffer.append(areAllFieldsSet);
buffer.append(",lenient=");
buffer.append(lenient);
buffer.append(",zone=");
buffer.append(zone);
buffer.append(",firstDayOfWeek=");
buffer.append(firstDayOfWeek);
buffer.append(",minimalDaysInFirstWeek=");
buffer.append(minimalDaysInFirstWeek);
for (int i=0; itime to
* field values in fields[]. This synchronizes the time
* field values with a new time that is set for the calendar. The time
* is not recomputed first; to recompute the time, then the
* fields, call the complete method.
* @see #complete
* @stable ICU 2.0
*/
protected void computeFields() {
int offsets[] = new int[2];
getTimeZone().getOffset(time, false, offsets);
long localMillis = time + offsets[0] + offsets[1];
// Mark fields as set. Do this before calling handleComputeFields().
int mask = internalSetMask;
for (int i=0; iREMAP_RESOLVE | F at
* the start of the line, where F is the desired return
* field value. This field will NOT be examined; it only determines
* the return value if the other fields in the line are the newest.
*
* Calendar.validateField().
* @see #validateField(int, int, int)
* @stable ICU 2.0
*/
protected void validateField(int field) {
int y;
switch (field) {
case DAY_OF_MONTH:
y = handleGetExtendedYear();
validateField(field, 1, handleGetMonthLength(y, internalGet(MONTH)));
break;
case DAY_OF_YEAR:
y = handleGetExtendedYear();
validateField(field, 1, handleGetYearLength(y));
break;
case DAY_OF_WEEK_IN_MONTH:
if (internalGet(field) == 0) {
throw new IllegalArgumentException("DAY_OF_WEEK_IN_MONTH cannot be zero");
}
validateField(field, getMinimum(field), getMaximum(field));
break;
default:
validateField(field, getMinimum(field), getMaximum(field));
break;
}
}
/**
* Validate a single field of this calendar given its minimum and
* maximum allowed value. If the field is out of range, throw a
* descriptive IllegalArgumentException. Subclasses may
* use this method in their implementation of {@link
* #validateField(int)}.
* @stable ICU 2.0
*/
protected final void validateField(int field, int min, int max) {
int value = fields[field];
if (value < min || value > max) {
throw new IllegalArgumentException(fieldName(field) +
'=' + value + ", valid range=" +
min + ".." + max);
}
}
/**
* Converts the current field values in fields[] to the
* millisecond time value time.
* @stable ICU 2.0
*/
protected void computeTime() {
if (!isLenient()) {
validateFields();
}
// Compute the Julian day
int julianDay = computeJulianDay();
long millis = julianDayToMillis(julianDay);
int millisInDay;
// We only use MILLISECONDS_IN_DAY if it has been set by the user.
// This makes it possible for the caller to set the calendar to a
// time and call clear(MONTH) to reset the MONTH to January. This
// is legacy behavior. Without this, clear(MONTH) has no effect,
// since the internally set JULIAN_DAY is used.
if (stamp[MILLISECONDS_IN_DAY] >= MINIMUM_USER_STAMP &&
newestStamp(AM_PM, MILLISECOND, UNSET) <= stamp[MILLISECONDS_IN_DAY]) {
millisInDay = internalGet(MILLISECONDS_IN_DAY);
} else {
millisInDay = computeMillisInDay();
}
// Compute the time zone offset and DST offset. There are two potential
// ambiguities here. We'll assume a 2:00 am (wall time) switchover time
// for discussion purposes here.
// 1. The transition into DST. Here, a designated time of 2:00 am - 2:59 am
// can be in standard or in DST depending. However, 2:00 am is an invalid
// representation (the representation jumps from 1:59:59 am Std to 3:00:00 am DST).
// We assume standard time, that is, 2:30 am is interpreted as 3:30 am DST.
// 2. The transition out of DST. Here, a designated time of 1:00 am - 1:59 am
// can be in standard or DST. Both are valid representations (the rep
// jumps from 1:59:59 DST to 1:00:00 Std).
// Again, we assume standard time, that is, 1:30 am is interpreted as 1:30 am Std.
// We use the TimeZone object, unless the user has explicitly set the ZONE_OFFSET
// or DST_OFFSET fields; then we use those fields.
if (stamp[ZONE_OFFSET] >= MINIMUM_USER_STAMP ||
stamp[DST_OFFSET] >= MINIMUM_USER_STAMP) {
millisInDay -= internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET);
} else {
millisInDay -= computeZoneOffset(millis, millisInDay);
}
time = millis + millisInDay;
}
/**
* Compute the milliseconds in the day from the fields. This is a
* value from 0 to 23:59:59.999 inclusive, unless fields are out of
* range, in which case it can be an arbitrary value. This value
* reflects local zone wall time.
* @stable ICU 2.0
*/
protected int computeMillisInDay() {
// Do the time portion of the conversion.
int millisInDay = 0;
// Find the best set of fields specifying the time of day. There
// are only two possibilities here; the HOUR_OF_DAY or the
// AM_PM and the HOUR.
int hourOfDayStamp = stamp[HOUR_OF_DAY];
int hourStamp = Math.max(stamp[HOUR], stamp[AM_PM]);
int bestStamp = (hourStamp > hourOfDayStamp) ? hourStamp : hourOfDayStamp;
// Hours
if (bestStamp != UNSET) {
if (bestStamp == hourOfDayStamp) {
// Don't normalize here; let overflow bump into the next period.
// This is consistent with how we handle other fields.
millisInDay += internalGet(HOUR_OF_DAY);
} else {
// Don't normalize here; let overflow bump into the next period.
// This is consistent with how we handle other fields.
millisInDay += internalGet(HOUR);
millisInDay += 12 * internalGet(AM_PM); // Default works for unset AM_PM
}
}
// We use the fact that unset == 0; we start with millisInDay
// == HOUR_OF_DAY.
millisInDay *= 60;
millisInDay += internalGet(MINUTE); // now have minutes
millisInDay *= 60;
millisInDay += internalGet(SECOND); // now have seconds
millisInDay *= 1000;
millisInDay += internalGet(MILLISECOND); // now have millis
return millisInDay;
}
/**
* This method can assume EXTENDED_YEAR has been set.
* @param millis milliseconds of the date fields (local midnight millis)
* @param millisInDay milliseconds of the time fields; may be out
* or range.
* @return total zone offset (raw + DST) for the given moment
* @stable ICU 2.0
*/
protected int computeZoneOffset(long millis, int millisInDay) {
int offsets[] = new int[2];
zone.getOffset(millis + millisInDay, true, offsets);
return offsets[0] + offsets[1];
// Note: Because we pass in wall millisInDay, rather than
// standard millisInDay, we interpret "1:00 am" on the day
// of cessation of DST as "1:00 am Std" (assuming the time
// of cessation is 2:00 am).
}
/**
* Compute the Julian day number as specified by this calendar's fields.
* @stable ICU 2.0
*/
protected int computeJulianDay() {
// We want to see if any of the date fields is newer than the
// JULIAN_DAY. If not, then we use JULIAN_DAY. If so, then we do
// the normal resolution. We only use JULIAN_DAY if it has been
// set by the user. This makes it possible for the caller to set
// the calendar to a time and call clear(MONTH) to reset the MONTH
// to January. This is legacy behavior. Without this,
// clear(MONTH) has no effect, since the internally set JULIAN_DAY
// is used.
if (stamp[JULIAN_DAY] >= MINIMUM_USER_STAMP) {
int bestStamp = newestStamp(ERA, DAY_OF_WEEK_IN_MONTH, UNSET);
bestStamp = newestStamp(YEAR_WOY, EXTENDED_YEAR, bestStamp);
if (bestStamp <= stamp[JULIAN_DAY]) {
return internalGet(JULIAN_DAY);
}
}
int bestField = resolveFields(getFieldResolutionTable());
if (bestField < 0) {
bestField = DAY_OF_MONTH;
}
return handleComputeJulianDay(bestField);
}
/**
* Return the field resolution array for this calendar. Calendars that
* define additional fields or change the semantics of existing fields
* should override this method to adjust the field resolution semantics
* accordingly. Other subclasses should not override this method.
* @see #resolveFields
* @stable ICU 2.0
*/
protected int[][][] getFieldResolutionTable() {
return DATE_PRECEDENCE;
}
/**
* Return the Julian day number of day before the first day of the
* given month in the given extended year. Subclasses should override
* this method to implement their calendar system.
* @param eyear the extended year
* @param month the zero-based month, or 0 if useMonth is false
* @param useMonth if false, compute the day before the first day of
* the given year, otherwise, compute the day before the first day of
* the given month
* @return the Julian day number of the day before the first
* day of the given month and year
* @stable ICU 2.0
*/
abstract protected int handleComputeMonthStart(int eyear, int month,
boolean useMonth);
/**
* Return the extended year defined by the current fields. This will
* use the EXTENDED_YEAR field or the YEAR and supra-year fields (such
* as ERA) specific to the calendar system, depending on which set of
* fields is newer.
* @return the extended year
* @stable ICU 2.0
*/
abstract protected int handleGetExtendedYear();
// (The following method is not called because all existing subclasses
// override it. 2003-06-11 ICU 2.6 Alan)
///CLOVER:OFF
/**
* Return the number of days in the given month of the given extended
* year of this calendar system. Subclasses should override this
* method if they can provide a more correct or more efficient
* implementation than the default implementation in Calendar.
* @stable ICU 2.0
*/
protected int handleGetMonthLength(int extendedYear, int month) {
return handleComputeMonthStart(extendedYear, month+1, true) -
handleComputeMonthStart(extendedYear, month, true);
}
///CLOVER:ON
/**
* Return the number of days in the given extended year of this
* calendar system. Subclasses should override this method if they can
* provide a more correct or more efficient implementation than the
* default implementation in Calendar.
* @stable ICU 2.0
*/
protected int handleGetYearLength(int eyear) {
return handleComputeMonthStart(eyear+1, 0, false) -
handleComputeMonthStart(eyear, 0, false);
}
/**
* Subclasses that use additional fields beyond those defined in
* Calendar should override this method to return an
* int[] array of the appropriate length. The length
* must be at least BASE_FIELD_COUNT and no more than
* MAX_FIELD_COUNT.
* @stable ICU 2.0
*/
protected int[] handleCreateFields() {
return new int[BASE_FIELD_COUNT];
}
/**
* Subclasses may override this.
* Called by handleComputeJulianDay. Returns the default month (0-based) for the year,
* taking year and era into account. Defaults to 0 (JANUARY) for Gregorian.
* @param extendedYear the extendedYear, as returned by handleGetExtendedYear
* @return the default month
* @draft ICU 3.6 (retain)
* @provisional This API might change or be removed in a future release.
* @see #MONTH
*/
protected int getDefaultMonthInYear(int extendedYear) {
return Calendar.JANUARY;
}
/**
* Subclasses may override this.
* Called by handleComputeJulianDay. Returns the default day (1-based) for the month,
* taking currently-set year and era into account. Defaults to 1 for Gregorian.
* @param extendedYear the extendedYear, as returned by handleGetExtendedYear
* @param month the month, as returned by getDefaultMonthInYear
* @return the default day of the month
* @draft ICU 3.6 (retain)
* @provisional This API might change or be removed in a future release.
* @see #DAY_OF_MONTH
*/
protected int getDefaultDayInMonth(int extendedYear, int month) {
return 1;
}
/**
* Subclasses may override this. This method calls
* handleGetMonthLength() to obtain the calendar-specific month
* length.
* @stable ICU 2.0
*/
protected int handleComputeJulianDay(int bestField) {
boolean useMonth = (bestField == DAY_OF_MONTH ||
bestField == WEEK_OF_MONTH ||
bestField == DAY_OF_WEEK_IN_MONTH);
int year;
if (bestField == WEEK_OF_YEAR) {
// Nota Bene! It is critical that YEAR_WOY be used as the year here, if it is set.
// Otherwise, when WOY is the best field, the year may be wrong at the extreme limits of the year.
// If YEAR_WOY is not set then it will fall back.
// TODO: Should resolveField(YEAR_PRECEDENCE) be brought to bear?
year = internalGet(YEAR_WOY, handleGetExtendedYear());
} else {
year = handleGetExtendedYear();
}
internalSet(EXTENDED_YEAR, year);
int month = useMonth ? internalGet(MONTH, getDefaultMonthInYear(year)) : 0;
// Get the Julian day of the day BEFORE the start of this year.
// If useMonth is true, get the day before the start of the month.
int julianDay = handleComputeMonthStart(year, month, useMonth);
if (bestField == DAY_OF_MONTH) {
if(isSet(DAY_OF_MONTH)) {
return julianDay + internalGet(DAY_OF_MONTH, getDefaultDayInMonth(year, month));
} else {
return julianDay + getDefaultDayInMonth(year, month);
}
}
if (bestField == DAY_OF_YEAR) {
return julianDay + internalGet(DAY_OF_YEAR);
}
int firstDOW = getFirstDayOfWeek(); // Localized fdw
// At this point julianDay is the 0-based day BEFORE the first day of
// January 1, year 1 of the given calendar. If julianDay == 0, it
// specifies (Jan. 1, 1) - 1, in whatever calendar we are using (Julian
// or Gregorian).
// At this point we need to process the WEEK_OF_MONTH or
// WEEK_OF_YEAR, which are similar, or the DAY_OF_WEEK_IN_MONTH.
// First, perform initial shared computations. These locate the
// first week of the period.
// Get the 0-based localized DOW of day one of the month or year.
// Valid range 0..6.
int first = julianDayToDayOfWeek(julianDay + 1) - firstDOW;
if (first < 0) {
first += 7;
}
// Get zero-based localized DOW, valid range 0..6. This is the DOW
// we are looking for.
int dowLocal = 0;
switch (resolveFields(DOW_PRECEDENCE)) {
case DAY_OF_WEEK:
dowLocal = internalGet(DAY_OF_WEEK) - firstDOW;
break;
case DOW_LOCAL:
dowLocal = internalGet(DOW_LOCAL) - 1;
break;
}
dowLocal = dowLocal % 7;
if (dowLocal < 0) {
dowLocal += 7;
}
// Find the first target DOW (dowLocal) in the month or year.
// Actually, it may be just before the first of the month or year.
// It will be an integer from -5..7.
int date = 1 - first + dowLocal;
if (bestField == DAY_OF_WEEK_IN_MONTH) {
// Adjust the target DOW to be in the month or year.
if (date < 1) {
date += 7;
}
// The only trickiness occurs if the day-of-week-in-month is
// negative.
int dim = internalGet(DAY_OF_WEEK_IN_MONTH, 1);
if (dim >= 0) {
date += 7*(dim - 1);
} else {
// Move date to the last of this day-of-week in this month,
// then back up as needed. If dim==-1, we don't back up at
// all. If dim==-2, we back up once, etc. Don't back up
// past the first of the given day-of-week in this month.
// Note that we handle -2, -3, etc. correctly, even though
// values < -1 are technically disallowed.
int m = internalGet(MONTH, JANUARY);
int monthLength = handleGetMonthLength(year, m);
date += ((monthLength - date) / 7 + dim + 1) * 7;
}
} else {
// assert(bestField == WEEK_OF_MONTH || bestField == WEEK_OF_YEAR)
// Adjust for minimal days in first week
if ((7 - first) < getMinimalDaysInFirstWeek()) {
date += 7;
}
// Now adjust for the week number.
date += 7 * (internalGet(bestField) - 1);
}
return julianDay + date;
}
/**
* Compute the Julian day of a month of the Gregorian calendar.
* Subclasses may call this method to perform a Gregorian calendar
* fields->millis computation. To perform a Gregorian calendar
* millis->fields computation, call computeGregorianFields().
* @param year extended Gregorian year
* @param month zero-based Gregorian month
* @return the Julian day number of the day before the first
* day of the given month in the given extended year
* @see #computeGregorianFields
* @stable ICU 2.0
*/
protected int computeGregorianMonthStart(int year, int month) {
// If the month is out of range, adjust it into range, and
// modify the extended year value accordingly.
if (month < 0 || month > 11) {
int[] rem = new int[1];
year += floorDivide(month, 12, rem);
month = rem[0];
}
boolean isLeap = (year%4 == 0) && ((year%100 != 0) || (year%400 == 0));
int y = year - 1;
// This computation is actually ... + (JAN_1_1_JULIAN_DAY - 3) + 2.
// Add 2 because Gregorian calendar starts 2 days after Julian
// calendar.
int julianDay = 365*y + floorDivide(y, 4) - floorDivide(y, 100) +
floorDivide(y, 400) + JAN_1_1_JULIAN_DAY - 1;
// At this point julianDay indicates the day BEFORE the first day
// of January 1,
*
* Subclasses can refer to the DAY_OF_WEEK and DOW_LOCAL fields, which
* will be set when this method is called. Subclasses can also call
* the getGregorianXxx() methods to obtain Gregorian calendar
* equivalents for the given Julian day.
*
* Calendar implements
* a pure proleptic Gregorian calendar.
* @stable ICU 2.0
*/
protected void handleComputeFields(int julianDay) {
internalSet(MONTH, getGregorianMonth());
internalSet(DAY_OF_MONTH, getGregorianDayOfMonth());
internalSet(DAY_OF_YEAR, getGregorianDayOfYear());
int eyear = getGregorianYear();
internalSet(EXTENDED_YEAR, eyear);
int era = GregorianCalendar.AD;
if (eyear < 1) {
era = GregorianCalendar.BC;
eyear = 1 - eyear;
}
internalSet(ERA, era);
internalSet(YEAR, eyear);
}
///CLOVER:ON
//----------------------------------------------------------------------
// Subclass API
// For subclasses to call
//----------------------------------------------------------------------
/**
* Return the extended year on the Gregorian calendar as computed by
* computeGregorianFields().
* @see #computeGregorianFields
* @stable ICU 2.0
*/
protected final int getGregorianYear() {
return gregorianYear;
}
/**
* Return the month (0-based) on the Gregorian calendar as computed by
* computeGregorianFields().
* @see #computeGregorianFields
* @stable ICU 2.0
*/
protected final int getGregorianMonth() {
return gregorianMonth;
}
/**
* Return the day of year (1-based) on the Gregorian calendar as
* computed by computeGregorianFields().
* @see #computeGregorianFields
* @stable ICU 2.0
*/
protected final int getGregorianDayOfYear() {
return gregorianDayOfYear;
}
/**
* Return the day of month (1-based) on the Gregorian calendar as
* computed by computeGregorianFields().
* @see #computeGregorianFields
* @stable ICU 2.0
*/
protected final int getGregorianDayOfMonth() {
return gregorianDayOfMonth;
}
/**
* Return the number of fields defined by this calendar. Valid field
* arguments to set() and get() are
* 0..getFieldCount()-1.
* @stable ICU 2.0
*/
public final int getFieldCount() {
return fields.length;
}
/**
* Set a field to a value. Subclasses should use this method when
* computing fields. It sets the time stamp in the
* stamp[] array to INTERNALLY_SET. If a
* field that may not be set by subclasses is passed in, an
* IllegalArgumentException is thrown. This prevents
* subclasses from modifying fields that are intended to be
* calendar-system invariant.
* @stable ICU 2.0
*/
protected final void internalSet(int field, int value) {
if (((1 << field) & internalSetMask) == 0) {
throw new IllegalStateException("Subclass cannot set " +
fieldName(field));
}
fields[field] = value;
stamp[field] = INTERNALLY_SET;
}
private static final int[][] GREGORIAN_MONTH_COUNT = {
//len len2 st st2
{ 31, 31, 0, 0 }, // Jan
{ 28, 29, 31, 31 }, // Feb
{ 31, 31, 59, 60 }, // Mar
{ 30, 30, 90, 91 }, // Apr
{ 31, 31, 120, 121 }, // May
{ 30, 30, 151, 152 }, // Jun
{ 31, 31, 181, 182 }, // Jul
{ 31, 31, 212, 213 }, // Aug
{ 30, 30, 243, 244 }, // Sep
{ 31, 31, 273, 274 }, // Oct
{ 30, 30, 304, 305 }, // Nov
{ 31, 31, 334, 335 } // Dec
// len length of month
// len2 length of month in a leap year
// st days in year before start of month
// st2 days in year before month in leap year
};
/**
* Determines if the given year is a leap year. Returns true if the
* given year is a leap year.
* @param year the given year.
* @return true if the given year is a leap year; false otherwise.
* @stable ICU 2.0
*/
protected static final boolean isGregorianLeapYear(int year) {
return (year%4 == 0) && ((year%100 != 0) || (year%400 == 0));
}
/**
* Return the length of a month of the Gregorian calendar.
* @param y the extended year
* @param m the 0-based month number
* @return the number of days in the given month
* @stable ICU 2.0
*/
protected static final int gregorianMonthLength(int y, int m) {
return GREGORIAN_MONTH_COUNT[m][isGregorianLeapYear(y)?1:0];
}
/**
* Return the length of a previous month of the Gregorian calendar.
* @param y the extended year
* @param m the 0-based month number
* @return the number of days in the month previous to the given month
* @stable ICU 2.0
*/
protected static final int gregorianPreviousMonthLength(int y, int m) {
return (m > 0) ? gregorianMonthLength(y, m-1) : 31;
}
/**
* Divide two long integers, returning the floor of the quotient.
* -1/4 => 0
* but floorDivide(-1,4) => -1.
* @param numerator the numerator
* @param denominator a divisor which must be > 0
* @return the floor of the quotient.
* @stable ICU 2.0
*/
protected static final long floorDivide(long numerator, long denominator) {
// We do this computation in order to handle
// a numerator of Long.MIN_VALUE correctly
return (numerator >= 0) ?
numerator / denominator :
((numerator + 1) / denominator) - 1;
}
/**
* Divide two integers, returning the floor of the quotient.
* -1/4 => 0
* but floorDivide(-1,4) => -1.
* @param numerator the numerator
* @param denominator a divisor which must be > 0
* @return the floor of the quotient.
* @stable ICU 2.0
*/
protected static final int floorDivide(int numerator, int denominator) {
// We do this computation in order to handle
// a numerator of Integer.MIN_VALUE correctly
return (numerator >= 0) ?
numerator / denominator :
((numerator + 1) / denominator) - 1;
}
/**
* Divide two integers, returning the floor of the quotient, and
* the modulus remainder.
* -1/4 => 0 and -1%4 => -1,
* but floorDivide(-1,4) => -1 with remainder[0] => 3.
* @param numerator the numerator
* @param denominator a divisor which must be > 0
* @param remainder an array of at least one element in which the value
* numerator mod denominator is returned. Unlike numerator
* % denominator, this will always be non-negative.
* @return the floor of the quotient.
* @stable ICU 2.0
*/
protected static final int floorDivide(int numerator, int denominator, int[] remainder) {
if (numerator >= 0) {
remainder[0] = numerator % denominator;
return numerator / denominator;
}
int quotient = ((numerator + 1) / denominator) - 1;
remainder[0] = numerator - (quotient * denominator);
return quotient;
}
/**
* Divide two integers, returning the floor of the quotient, and
* the modulus remainder.
* -1/4 => 0 and -1%4 => -1,
* but floorDivide(-1,4) => -1 with remainder[0] => 3.
* @param numerator the numerator
* @param denominator a divisor which must be > 0
* @param remainder an array of at least one element in which the value
* numerator mod denominator is returned. Unlike numerator
* % denominator, this will always be non-negative.
* @return the floor of the quotient.
* @stable ICU 2.0
*/
protected static final int floorDivide(long numerator, int denominator, int[] remainder) {
if (numerator >= 0) {
remainder[0] = (int)(numerator % denominator);
return (int)(numerator / denominator);
}
int quotient = (int)(((numerator + 1) / denominator) - 1);
remainder[0] = (int)(numerator - (quotient * denominator));
return quotient;
}
private static final String[] FIELD_NAME = {
"ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH",
"DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK",
"DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY",
"MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET",
"DST_OFFSET", "YEAR_WOY", "DOW_LOCAL", "EXTENDED_YEAR",
"JULIAN_DAY", "MILLISECONDS_IN_DAY",
};
/**
* Return a string name for a field, for debugging and exceptions.
* @stable ICU 2.0
*/
protected String fieldName(int field) {
try {
return FIELD_NAME[field];
} catch (ArrayIndexOutOfBoundsException e) {
return "Field " + field;
}
}
/**
* Converts time as milliseconds to Julian day.
* @param millis the given milliseconds.
* @return the Julian day number.
* @stable ICU 2.0
*/
protected static final int millisToJulianDay(long millis) {
return (int) (EPOCH_JULIAN_DAY + floorDivide(millis, ONE_DAY));
}
/**
* Converts Julian day to time as milliseconds.
* @param julian the given Julian day number.
* @return time as milliseconds.
* @stable ICU 2.0
*/
protected static final long julianDayToMillis(int julian) {
return (julian - EPOCH_JULIAN_DAY) * ONE_DAY;
}
/**
* Return the day of week, from SUNDAY to SATURDAY, given a Julian day.
* @stable ICU 2.0
*/
protected static final int julianDayToDayOfWeek(int julian) {
// If julian is negative, then julian%7 will be negative, so we adjust
// accordingly. Julian day 0 is Monday.
int dayOfWeek = (julian + MONDAY) % 7;
if (dayOfWeek < SUNDAY) {
dayOfWeek += 7;
}
return dayOfWeek;
}
/**
* Return the current milliseconds without recomputing.
* @stable ICU 2.0
*/
protected final long internalGetTimeInMillis() {
return time;
}
/**
* Return the current Calendar type.
* Note, in 3.0 this function will return 'gregorian' in Calendar to emulate legacy behavior
* @return type of calendar (gregorian, etc)
* @stable ICU 3.8
*/
public String getType() {
return "gregorian";
}
// -------- BEGIN ULocale boilerplate --------
/**
* Return the locale that was used to create this object, or null.
* This may may differ from the locale requested at the time of
* this object's creation. For example, if an object is created
* for locale en_US_CALIFORNIA, the actual data may be
* drawn from en (the actual locale), and
* en_US may be the most specific locale that exists (the
* valid locale).
*
* GregorianCalendar is a concrete subclass of
* {@link Calendar}
* and provides the standard calendar used by most of the world.
*
* setGregorianChange().
*
* GregorianCalendar
* implements the Julian calendar. The only difference between the Gregorian
* and the Julian calendar is the leap year rule. The Julian calendar specifies
* leap years every four years, whereas the Gregorian calendar omits century
* years which are not divisible by 400.
*
* GregorianCalendar implements proleptic Gregorian and
* Julian calendars. That is, dates are computed by extrapolating the current
* rules indefinitely far backward and forward in time. As a result,
* GregorianCalendar may be used for all years to generate
* meaningful and consistent results. However, dates obtained using
* GregorianCalendar are historically accurate only from March 1, 4
* AD onward, when modern Julian calendar rules were adopted. Before this date,
* leap year rules were applied irregularly, and before 45 BC the Julian
* calendar did not even exist.
*
* WEEK_OF_YEAR field range from 1 to
* 53. Week 1 for a year is the earliest seven day period starting on
* getFirstDayOfWeek() that contains at least
* getMinimalDaysInFirstWeek() days from that year. It thus
* depends on the values of getMinimalDaysInFirstWeek(),
* getFirstDayOfWeek(), and the day of the week of January 1.
* Weeks between week 1 of one year and week 1 of the following year are
* numbered sequentially from 2 to 52 or 53 (as needed).
* getFirstDayOfWeek() is MONDAY and
* getMinimalDaysInFirstWeek() is 4 (these are the values
* reflecting ISO 8601 and many national standards), then week 1 of 1998 starts
* on December 29, 1997, and ends on January 4, 1998. If, however,
* getFirstDayOfWeek() is SUNDAY, then week 1 of 1998
* starts on January 4, 1998, and ends on January 10, 1998; the first three days
* of 1998 then are part of week 53 of 1997.
*
* WEEK_OF_MONTH field range from 0 or
* 1 to 4 or 5. Week 1 of a month (the days with WEEK_OF_MONTH =
* 1) is the earliest set of at least
* getMinimalDaysInFirstWeek() contiguous days in that month,
* ending on the day before getFirstDayOfWeek(). Unlike
* week 1 of a year, week 1 of a month may be shorter than 7 days, need
* not start on getFirstDayOfWeek(), and will not include days of
* the previous month. Days of a month before week 1 have a
* WEEK_OF_MONTH of 0.
*
* getFirstDayOfWeek() is SUNDAY
* and getMinimalDaysInFirstWeek() is 4, then the first week of
* January 1998 is Sunday, January 4 through Saturday, January 10. These days
* have a WEEK_OF_MONTH of 1. Thursday, January 1 through
* Saturday, January 3 have a WEEK_OF_MONTH of 0. If
* getMinimalDaysInFirstWeek() is changed to 3, then January 1
* through January 3 have a WEEK_OF_MONTH of 1.
*
*
*
*
* // get the supported ids for GMT-08:00 (Pacific Standard Time)
* String[] ids = TimeZone.getAvailableIDs(-8 * 60 * 60 * 1000);
* // if no ids were returned, something is wrong. get out.
* if (ids.length == 0)
* System.exit(0);
*
* // begin output
* System.out.println("Current Time");
*
* // create a Pacific Standard Time time zone
* SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids[0]);
*
* // set up rules for daylight savings time
* pdt.setStartRule(Calendar.MARCH, 2, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
* pdt.setEndRule(Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
*
* // create a GregorianCalendar with the Pacific Daylight time zone
* // and the current date and time
* Calendar calendar = new GregorianCalendar(pdt);
* Date trialTime = new Date();
* calendar.setTime(trialTime);
*
* // print out a bunch of interesting things
* System.out.println("ERA: " + calendar.get(Calendar.ERA));
* System.out.println("YEAR: " + calendar.get(Calendar.YEAR));
* System.out.println("MONTH: " + calendar.get(Calendar.MONTH));
* System.out.println("WEEK_OF_YEAR: " + calendar.get(Calendar.WEEK_OF_YEAR));
* System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.WEEK_OF_MONTH));
* System.out.println("DATE: " + calendar.get(Calendar.DATE));
* System.out.println("DAY_OF_MONTH: " + calendar.get(Calendar.DAY_OF_MONTH));
* System.out.println("DAY_OF_YEAR: " + calendar.get(Calendar.DAY_OF_YEAR));
* System.out.println("DAY_OF_WEEK: " + calendar.get(Calendar.DAY_OF_WEEK));
* System.out.println("DAY_OF_WEEK_IN_MONTH: "
* + calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));
* System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM));
* System.out.println("HOUR: " + calendar.get(Calendar.HOUR));
* System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY));
* System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE));
* System.out.println("SECOND: " + calendar.get(Calendar.SECOND));
* System.out.println("MILLISECOND: " + calendar.get(Calendar.MILLISECOND));
* System.out.println("ZONE_OFFSET: "
* + (calendar.get(Calendar.ZONE_OFFSET)/(60*60*1000)));
* System.out.println("DST_OFFSET: "
* + (calendar.get(Calendar.DST_OFFSET)/(60*60*1000)));
* System.out.println("Current Time, with hour reset to 3");
* calendar.clear(Calendar.HOUR_OF_DAY); // so doesn't override
* calendar.set(Calendar.HOUR, 3);
* System.out.println("ERA: " + calendar.get(Calendar.ERA));
* System.out.println("YEAR: " + calendar.get(Calendar.YEAR));
* System.out.println("MONTH: " + calendar.get(Calendar.MONTH));
* System.out.println("WEEK_OF_YEAR: " + calendar.get(Calendar.WEEK_OF_YEAR));
* System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.WEEK_OF_MONTH));
* System.out.println("DATE: " + calendar.get(Calendar.DATE));
* System.out.println("DAY_OF_MONTH: " + calendar.get(Calendar.DAY_OF_MONTH));
* System.out.println("DAY_OF_YEAR: " + calendar.get(Calendar.DAY_OF_YEAR));
* System.out.println("DAY_OF_WEEK: " + calendar.get(Calendar.DAY_OF_WEEK));
* System.out.println("DAY_OF_WEEK_IN_MONTH: "
* + calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));
* System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM));
* System.out.println("HOUR: " + calendar.get(Calendar.HOUR));
* System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY));
* System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE));
* System.out.println("SECOND: " + calendar.get(Calendar.SECOND));
* System.out.println("MILLISECOND: " + calendar.get(Calendar.MILLISECOND));
* System.out.println("ZONE_OFFSET: "
* + (calendar.get(Calendar.ZONE_OFFSET)/(60*60*1000))); // in hours
* System.out.println("DST_OFFSET: "
* + (calendar.get(Calendar.DST_OFFSET)/(60*60*1000))); // in hours
* ULocale
* with the tag "@calendar=gregorian".ERA field indicating
* the period before the common era (before Christ), also known as BCE.
* The sequence of years at the transition from BC to AD is
* ..., 2 BC, 1 BC, 1 AD, 2 AD,...
* @see Calendar#ERA
* @stable ICU 2.0
*/
public static final int BC = 0;
/**
* Value of the ERA field indicating
* the common era (Anno Domini), also known as CE.
* The sequence of years at the transition from BC to AD is
* ..., 2 BC, 1 BC, 1 AD, 2 AD,...
* @see Calendar#ERA
* @stable ICU 2.0
*/
public static final int AD = 1;
private static final int EPOCH_YEAR = 1970;
private static final int[][] MONTH_COUNT = {
//len len2 st st2
{ 31, 31, 0, 0 }, // Jan
{ 28, 29, 31, 31 }, // Feb
{ 31, 31, 59, 60 }, // Mar
{ 30, 30, 90, 91 }, // Apr
{ 31, 31, 120, 121 }, // May
{ 30, 30, 151, 152 }, // Jun
{ 31, 31, 181, 182 }, // Jul
{ 31, 31, 212, 213 }, // Aug
{ 30, 30, 243, 244 }, // Sep
{ 31, 31, 273, 274 }, // Oct
{ 30, 30, 304, 305 }, // Nov
{ 31, 31, 334, 335 } // Dec
// len length of month
// len2 length of month in a leap year
// st days in year before start of month
// st2 days in year before month in leap year
};
/**
* Old year limits were least max 292269054, max 292278994.
*/
private static final int LIMITS[][] = {
// Minimum Greatest Least Maximum
// Minimum Maximum
{ 0, 0, 1, 1 }, // ERA
{ 1, 1, 5828963, 5838270 }, // YEAR
{ 0, 0, 11, 11 }, // MONTH
{ 1, 1, 52, 53 }, // WEEK_OF_YEAR
{/* */}, // WEEK_OF_MONTH
{ 1, 1, 28, 31 }, // DAY_OF_MONTH
{ 1, 1, 365, 366 }, // DAY_OF_YEAR
{/* */}, // DAY_OF_WEEK
{ -1, -1, 4, 5 }, // DAY_OF_WEEK_IN_MONTH
{/* */}, // AM_PM
{/* */}, // HOUR
{/* */}, // HOUR_OF_DAY
{/* */}, // MINUTE
{/* */}, // SECOND
{/* */}, // MILLISECOND
{/* */}, // ZONE_OFFSET
{/* */}, // DST_OFFSET
{ -5838270, -5838270, 5828964, 5838271 }, // YEAR_WOY
{/* */}, // DOW_LOCAL
{ -5838269, -5838269, 5828963, 5838270 }, // EXTENDED_YEAR
{/* */}, // JULIAN_DAY
{/* */}, // MILLISECONDS_IN_DAY
};
/**
* @stable ICU 2.0
*/
protected int handleGetLimit(int field, int limitType) {
return LIMITS[field][limitType];
}
/////////////////////
// Instance Variables
/////////////////////
/**
* The point at which the Gregorian calendar rules are used, measured in
* milliseconds from the standard epoch. Default is October 15, 1582
* (Gregorian) 00:00:00 UTC or -12219292800000L. For this value, October 4,
* 1582 (Julian) is followed by October 15, 1582 (Gregorian). This
* corresponds to Julian day number 2299161.
* @serial
*/
private long gregorianCutover = -12219292800000L;
/**
* Julian day number of the Gregorian cutover.
*/
private transient int cutoverJulianDay = 2299161;
/**
* The year of the gregorianCutover, with 0 representing
* 1 BC, -1 representing 2 BC, etc.
*/
private transient int gregorianCutoverYear = 1582;
/**
* Used by handleComputeJulianDay() and handleComputeMonthStart().
* @stable ICU 2.0
*/
transient protected boolean isGregorian;
/**
* Used by handleComputeJulianDay() and handleComputeMonthStart().
* @stable ICU 2.0
*/
transient protected boolean invertGregorian;
///////////////
// Constructors
///////////////
/**
* Constructs a default GregorianCalendar using the current time
* in the default time zone with the default locale.
* @stable ICU 2.0
*/
public GregorianCalendar() {
this(TimeZone.getDefault(), ULocale.getDefault());
}
/**
* Constructs a GregorianCalendar based on the current time
* in the given time zone with the default locale.
* @param zone the given time zone.
* @stable ICU 2.0
*/
public GregorianCalendar(TimeZone zone) {
this(zone, ULocale.getDefault());
}
/**
* Constructs a GregorianCalendar based on the current time
* in the default time zone with the given locale.
* @param aLocale the given locale.
* @stable ICU 2.0
*/
public GregorianCalendar(Locale aLocale) {
this(TimeZone.getDefault(), aLocale);
}
/**
* Constructs a GregorianCalendar based on the current time
* in the default time zone with the given locale.
* @param locale the given ulocale.
* @stable ICU 3.2
*/
public GregorianCalendar(ULocale locale) {
this(TimeZone.getDefault(), locale);
}
/**
* Constructs a GregorianCalendar based on the current time
* in the given time zone with the given locale.
* @param zone the given time zone.
* @param aLocale the given locale.
* @stable ICU 2.0
*/
public GregorianCalendar(TimeZone zone, Locale aLocale) {
super(zone, aLocale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs a GregorianCalendar based on the current time
* in the given time zone with the given locale.
* @param zone the given time zone.
* @param locale the given ulocale.
* @stable ICU 3.2
*/
public GregorianCalendar(TimeZone zone, ULocale locale) {
super(zone, locale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs a GregorianCalendar with the given date set
* in the default time zone with the default locale.
* @param year the value used to set the YEAR time field in the calendar.
* @param month the value used to set the MONTH time field in the calendar.
* Month value is 0-based. e.g., 0 for January.
* @param date the value used to set the DATE time field in the calendar.
* @stable ICU 2.0
*/
public GregorianCalendar(int year, int month, int date) {
super(TimeZone.getDefault(), ULocale.getDefault());
set(ERA, AD);
set(YEAR, year);
set(MONTH, month);
set(DATE, date);
}
/**
* Constructs a GregorianCalendar with the given date
* and time set for the default time zone with the default locale.
* @param year the value used to set the YEAR time field in the calendar.
* @param month the value used to set the MONTH time field in the calendar.
* Month value is 0-based. e.g., 0 for January.
* @param date the value used to set the DATE time field in the calendar.
* @param hour the value used to set the HOUR_OF_DAY time field
* in the calendar.
* @param minute the value used to set the MINUTE time field
* in the calendar.
* @stable ICU 2.0
*/
public GregorianCalendar(int year, int month, int date, int hour,
int minute) {
super(TimeZone.getDefault(), ULocale.getDefault());
set(ERA, AD);
set(YEAR, year);
set(MONTH, month);
set(DATE, date);
set(HOUR_OF_DAY, hour);
set(MINUTE, minute);
}
/**
* Constructs a GregorianCalendar with the given date
* and time set for the default time zone with the default locale.
* @param year the value used to set the YEAR time field in the calendar.
* @param month the value used to set the MONTH time field in the calendar.
* Month value is 0-based. e.g., 0 for January.
* @param date the value used to set the DATE time field in the calendar.
* @param hour the value used to set the HOUR_OF_DAY time field
* in the calendar.
* @param minute the value used to set the MINUTE time field
* in the calendar.
* @param second the value used to set the SECOND time field
* in the calendar.
* @stable ICU 2.0
*/
public GregorianCalendar(int year, int month, int date, int hour,
int minute, int second) {
super(TimeZone.getDefault(), ULocale.getDefault());
set(ERA, AD);
set(YEAR, year);
set(MONTH, month);
set(DATE, date);
set(HOUR_OF_DAY, hour);
set(MINUTE, minute);
set(SECOND, second);
}
/////////////////
// Public methods
/////////////////
/**
* Sets the GregorianCalendar change date. This is the point when the switch
* from Julian dates to Gregorian dates occurred. Default is October 15,
* 1582. Previous to this, dates will be in the Julian calendar.
* Date(Long.MAX_VALUE). To obtain a pure Gregorian calendar,
* set the change date to Date(Long.MIN_VALUE).
*
* @param date the given Gregorian cutover date.
* @stable ICU 2.0
*/
public void setGregorianChange(Date date) {
gregorianCutover = date.getTime();
// If the cutover has an extreme value, then create a pure
// Gregorian or pure Julian calendar by giving the cutover year and
// JD extreme values.
if (gregorianCutover <= MIN_MILLIS) {
gregorianCutoverYear = cutoverJulianDay = Integer.MIN_VALUE;
} else if (gregorianCutover >= MAX_MILLIS) {
gregorianCutoverYear = cutoverJulianDay = Integer.MAX_VALUE;
} else {
// Precompute two internal variables which we use to do the actual
// cutover computations. These are the Julian day of the cutover
// and the cutover year.
cutoverJulianDay = (int) floorDivide(gregorianCutover, ONE_DAY);
// Convert cutover millis to extended year
GregorianCalendar cal = new GregorianCalendar(getTimeZone());
cal.setTime(date);
gregorianCutoverYear = cal.get(EXTENDED_YEAR);
}
}
/**
* Gets the Gregorian Calendar change date. This is the point when the
* switch from Julian dates to Gregorian dates occurred. Default is
* October 15, 1582. Previous to this, dates will be in the Julian
* calendar.
* @return the Gregorian cutover date for this calendar.
* @stable ICU 2.0
*/
public final Date getGregorianChange() {
return new Date(gregorianCutover);
}
/**
* Determines if the given year is a leap year. Returns true if the
* given year is a leap year.
* @param year the given year.
* @return true if the given year is a leap year; false otherwise.
* @stable ICU 2.0
*/
public boolean isLeapYear(int year) {
return year >= gregorianCutoverYear ?
((year%4 == 0) && ((year%100 != 0) || (year%400 == 0))) : // Gregorian
(year%4 == 0); // Julian
}
/**
* Returns true if the given Calendar object is equivalent to this
* one. Calendar override.
*
* @param other the Calendar to be compared with this Calendar
* @stable ICU 2.4
*/
public boolean isEquivalentTo(Calendar other) {
return super.isEquivalentTo(other) &&
gregorianCutover == ((GregorianCalendar)other).gregorianCutover;
}
/**
* Override hashCode.
* Generates the hash code for the GregorianCalendar object
* @stable ICU 2.0
*/
public int hashCode() {
return super.hashCode() ^ (int)gregorianCutover;
}
/**
* Roll a field by a signed amount.
* @stable ICU 2.0
*/
public void roll(int field, int amount) {
switch (field) {
case WEEK_OF_YEAR:
{
// Unlike WEEK_OF_MONTH, WEEK_OF_YEAR never shifts the day of the
// week. Also, rolling the week of the year can have seemingly
// strange effects simply because the year of the week of year
// may be different from the calendar year. For example, the
// date Dec 28, 1997 is the first day of week 1 of 1998 (if
// weeks start on Sunday and the minimal days in first week is
// <= 3).
int woy = get(WEEK_OF_YEAR);
// Get the ISO year, which matches the week of year. This
// may be one year before or after the calendar year.
int isoYear = get(YEAR_WOY);
int isoDoy = internalGet(DAY_OF_YEAR);
if (internalGet(MONTH) == Calendar.JANUARY) {
if (woy >= 52) {
isoDoy += handleGetYearLength(isoYear);
}
} else {
if (woy == 1) {
isoDoy -= handleGetYearLength(isoYear - 1);
}
}
woy += amount;
// Do fast checks to avoid unnecessary computation:
if (woy < 1 || woy > 52) {
// Determine the last week of the ISO year.
// We do this using the standard formula we use
// everywhere in this file. If we can see that the
// days at the end of the year are going to fall into
// week 1 of the next year, we drop the last week by
// subtracting 7 from the last day of the year.
int lastDoy = handleGetYearLength(isoYear);
int lastRelDow = (lastDoy - isoDoy + internalGet(DAY_OF_WEEK) -
getFirstDayOfWeek()) % 7;
if (lastRelDow < 0) lastRelDow += 7;
if ((6 - lastRelDow) >= getMinimalDaysInFirstWeek()) lastDoy -= 7;
int lastWoy = weekNumber(lastDoy, lastRelDow + 1);
woy = ((woy + lastWoy - 1) % lastWoy) + 1;
}
set(WEEK_OF_YEAR, woy);
set(YEAR, isoYear); // Why not YEAR_WOY? - Alan 11/6/00
return;
}
default:
super.roll(field, amount);
return;
}
}
/**
* Return the minimum value that this field could have, given the current date.
* For the Gregorian calendar, this is the same as getMinimum() and getGreatestMinimum().
* @stable ICU 2.0
*/
public int getActualMinimum(int field) {
return getMinimum(field);
}
/**
* Return the maximum value that this field could have, given the current date.
* For example, with the date "Feb 3, 1997" and the DAY_OF_MONTH field, the actual
* maximum would be 28; for "Feb 3, 1996" it s 29. Similarly for a Hebrew calendar,
* for some years the actual maximum for MONTH is 12, and for others 13.
* @stable ICU 2.0
*/
public int getActualMaximum(int field) {
/* It is a known limitation that the code here (and in getActualMinimum)
* won't behave properly at the extreme limits of GregorianCalendar's
* representable range (except for the code that handles the YEAR
* field). That's because the ends of the representable range are at
* odd spots in the year. For calendars with the default Gregorian
* cutover, these limits are Sun Dec 02 16:47:04 GMT 292269055 BC to Sun
* Aug 17 07:12:55 GMT 292278994 AD, somewhat different for non-GMT
* zones. As a result, if the calendar is set to Aug 1 292278994 AD,
* the actual maximum of DAY_OF_MONTH is 17, not 30. If the date is Mar
* 31 in that year, the actual maximum month might be Jul, whereas is
* the date is Mar 15, the actual maximum might be Aug -- depending on
* the precise semantics that are desired. Similar considerations
* affect all fields. Nonetheless, this effect is sufficiently arcane
* that we permit it, rather than complicating the code to handle such
* intricacies. - liu 8/20/98
* UPDATE: No longer true, since we have pulled in the limit values on
* the year. - Liu 11/6/00 */
switch (field) {
case YEAR:
/* The year computation is no different, in principle, from the
* others, however, the range of possible maxima is large. In
* addition, the way we know we've exceeded the range is different.
* For these reasons, we use the special case code below to handle
* this field.
*
* The actual maxima for YEAR depend on the type of calendar:
*
* Gregorian = May 17, 292275056 BC - Aug 17, 292278994 AD
* Julian = Dec 2, 292269055 BC - Jan 3, 292272993 AD
* Hybrid = Dec 2, 292269055 BC - Aug 17, 292278994 AD
*
* We know we've exceeded the maximum when either the month, date,
* time, or era changes in response to setting the year. We don't
* check for month, date, and time here because the year and era are
* sufficient to detect an invalid year setting. NOTE: If code is
* added to check the month and date in the future for some reason,
* Feb 29 must be allowed to shift to Mar 1 when setting the year.
*/
{
Calendar cal = (Calendar) clone();
cal.setLenient(true);
int era = cal.get(ERA);
Date d = cal.getTime();
/* Perform a binary search, with the invariant that lowGood is a
* valid year, and highBad is an out of range year.
*/
int lowGood = LIMITS[YEAR][1];
int highBad = LIMITS[YEAR][2]+1;
while ((lowGood + 1) < highBad) {
int y = (lowGood + highBad) / 2;
cal.set(YEAR, y);
if (cal.get(YEAR) == y && cal.get(ERA) == era) {
lowGood = y;
} else {
highBad = y;
cal.setTime(d); // Restore original fields
}
}
return lowGood;
}
default:
return super.getActualMaximum(field);
}
}
//////////////////////
// Proposed public API
//////////////////////
/**
* Return true if the current time for this Calendar is in Daylignt
* Savings Time.
*/
boolean inDaylightTime() {
if (!getTimeZone().useDaylightTime()) return false;
complete(); // Force update of DST_OFFSET field
return internalGet(DST_OFFSET) != 0;
}
/////////////////////
// Calendar framework
/////////////////////
/**
* @stable ICU 2.0
*/
protected int handleGetMonthLength(int extendedYear, int month) {
// If the month is out of range, adjust it into range, and
// modify the extended year value accordingly.
if (month < 0 || month > 11) {
int[] rem = new int[1];
extendedYear += floorDivide(month, 12, rem);
month = rem[0];
}
return MONTH_COUNT[month][isLeapYear(extendedYear)?1:0];
}
/**
* @stable ICU 2.0
*/
protected int handleGetYearLength(int eyear) {
return isLeapYear(eyear) ? 366 : 365;
}
/////////////////////////////
// Time => Fields computation
/////////////////////////////
/**
* Override Calendar to compute several fields specific to the hybrid
* Gregorian-Julian calendar system. These are:
*
*
* @stable ICU 2.0
*/
protected void handleComputeFields(int julianDay) {
int eyear, month, dayOfMonth, dayOfYear;
if (julianDay >= cutoverJulianDay) {
month = getGregorianMonth();
dayOfMonth = getGregorianDayOfMonth();
dayOfYear = getGregorianDayOfYear();
eyear = getGregorianYear();
} else {
// The Julian epoch day (not the same as Julian Day)
// is zero on Saturday December 30, 0 (Gregorian).
long julianEpochDay = julianDay - (JAN_1_1_JULIAN_DAY - 2);
eyear = (int) floorDivide(4*julianEpochDay + 1464, 1461);
// Compute the Julian calendar day number for January 1, eyear
long january1 = 365*(eyear-1) + floorDivide(eyear-1, 4);
dayOfYear = (int)(julianEpochDay - january1); // 0-based
// Julian leap years occurred historically every 4 years starting
// with 8 AD. Before 8 AD the spacing is irregular; every 3 years
// from 45 BC to 9 BC, and then none until 8 AD. However, we don't
// implement this historical detail; instead, we implement the
// computatinally cleaner proleptic calendar, which assumes
// consistent 4-year cycles throughout time.
boolean isLeap = ((eyear&0x3) == 0); // equiv. to (eyear%4 == 0)
// Common Julian/Gregorian calculation
int correction = 0;
int march1 = isLeap ? 60 : 59; // zero-based DOY for March 1
if (dayOfYear >= march1) {
correction = isLeap ? 1 : 2;
}
month = (12 * (dayOfYear + correction) + 6) / 367; // zero-based month
dayOfMonth = dayOfYear - MONTH_COUNT[month][isLeap?3:2] + 1; // one-based DOM
++dayOfYear;
}
internalSet(MONTH, month);
internalSet(DAY_OF_MONTH, dayOfMonth);
internalSet(DAY_OF_YEAR, dayOfYear);
internalSet(EXTENDED_YEAR, eyear);
int era = AD;
if (eyear < 1) {
era = BC;
eyear = 1 - eyear;
}
internalSet(ERA, era);
internalSet(YEAR, eyear);
}
/////////////////////////////
// Fields => Time computation
/////////////////////////////
/**
* @stable ICU 2.0
*/
protected int handleGetExtendedYear() {
int year;
if (newerField(EXTENDED_YEAR, YEAR) == EXTENDED_YEAR) {
year = internalGet(EXTENDED_YEAR, EPOCH_YEAR);
} else {
// The year defaults to the epoch start, the era to AD
int era = internalGet(ERA, AD);
if (era == BC) {
year = 1 - internalGet(YEAR, 1); // Convert to extended year
} else {
year = internalGet(YEAR, EPOCH_YEAR);
}
}
return year;
}
/**
* @stable ICU 2.0
*/
protected int handleComputeJulianDay(int bestField) {
invertGregorian = false;
int jd = super.handleComputeJulianDay(bestField);
// The following check handles portions of the cutover year BEFORE the
// cutover itself happens.
if (isGregorian != (jd >= cutoverJulianDay)) {
invertGregorian = true;
jd = super.handleComputeJulianDay(bestField);
}
return jd;
}
/**
* Return JD of start of given month/year
* @stable ICU 2.0
*/
protected int handleComputeMonthStart(int eyear, int month, boolean useMonth) {
// If the month is out of range, adjust it into range, and
// modify the extended year value accordingly.
if (month < 0 || month > 11) {
int[] rem = new int[1];
eyear += floorDivide(month, 12, rem);
month = rem[0];
}
boolean isLeap = eyear%4 == 0;
int y = eyear - 1;
int julianDay = 365*y + floorDivide(y, 4) + (JAN_1_1_JULIAN_DAY - 3);
isGregorian = (eyear >= gregorianCutoverYear);
if (invertGregorian) {
isGregorian = !isGregorian;
}
if (isGregorian) {
isLeap = isLeap && ((eyear%100 != 0) || (eyear%400 == 0));
// Add 2 because Gregorian calendar starts 2 days after
// Julian calendar
julianDay += floorDivide(y, 400) - floorDivide(y, 100) + 2;
}
// At this point julianDay indicates the day BEFORE the first
// day of January 1, AnnualTimeZoneRule is a class used for representing a time zone
* rule which takes effect annually. Years used in this class are
* all Gregorian calendar years.
*
* @stable ICU 3.8
*/
public class AnnualTimeZoneRule extends TimeZoneRule {
private static final long serialVersionUID = -8870666707791230688L;
/**
* The constant representing the maximum year used for designating a rule is permanent.
* @stable ICU 3.8
*/
public static final int MAX_YEAR = Integer.MAX_VALUE;
private final DateTimeRule dateTimeRule;
private final int startYear;
private final int endYear;
/**
* Constructs a AnnualTimeZoneRule with the name, the GMT offset of its
* standard time, the amount of daylight saving offset adjustment,
* the annual start time rule and the start/until years.
*
* @param name The time zone name.
* @param rawOffset The GMT offset of its standard time in milliseconds.
* @param dstSavings The amount of daylight saving offset adjustment in
* milliseconds. If this ia a rule for standard time,
* the value of this argument is 0.
* @param dateTimeRule The start date/time rule repeated annually.
* @param startYear The first year when this rule takes effect.
* @param endYear The last year when this rule takes effect. If this
* rule is effective forever in future, specify MAX_YEAR.
*
* @stable ICU 3.8
*/
public AnnualTimeZoneRule(String name, int rawOffset, int dstSavings,
DateTimeRule dateTimeRule, int startYear, int endYear) {
super(name, rawOffset, dstSavings);
this.dateTimeRule = dateTimeRule;
this.startYear = startYear;
this.endYear = endYear > MAX_YEAR ? MAX_YEAR : endYear;
}
/**
* Gets the start date/time rule associated used by this rule.
*
* @return An AnnualDateTimeRule which represents the start date/time
* rule used by this time zone rule.
*
* @stable ICU 3.8
*/
public DateTimeRule getRule() {
return dateTimeRule;
}
/**
* Gets the first year when this rule takes effect.
*
* @return The start year of this rule. The year is in Gregorian calendar
* with 0 == 1 BCE, -1 == 2 BCE, etc.
*
* @stable ICU 3.8
*/
public int getStartYear() {
return startYear;
}
/**
* Gets the end year when this rule takes effect.
*
* @return The end year of this rule (inclusive). The year is in Gregorian calendar
* with 0 == 1 BCE, -1 == 2 BCE, etc.
*
* @stable ICU 3.8
*/
public int getEndYear() {
return endYear;
}
/**
* Gets the time when this rule takes effect in the given year.
*
* @param year The Gregorian year, with 0 == 1 BCE, -1 == 2 BCE, etc.
* @param prevRawOffset The standard time offset from UTC before this rule
* takes effect in milliseconds.
* @param prevDSTSavings The amount of daylight saving offset from the
* standard time.
*
* @return The time when this rule takes effect in the year, or
* null if this rule is not applicable in the year.
*
* @stable ICU 3.8
*/
public Date getStartInYear(int year, int prevRawOffset, int prevDSTSavings) {
if (year < startYear || year > endYear) {
return null;
}
long ruleDay;
int type = dateTimeRule.getDateRuleType();
if (type == DateTimeRule.DOM) {
ruleDay = Grego.fieldsToDay(year, dateTimeRule.getRuleMonth(), dateTimeRule.getRuleDayOfMonth());
} else {
boolean after = true;
if (type == DateTimeRule.DOW) {
int weeks = dateTimeRule.getRuleWeekInMonth();
if (weeks > 0) {
ruleDay = Grego.fieldsToDay(year, dateTimeRule.getRuleMonth(), 1);
ruleDay += 7 * (weeks - 1);
} else {
after = false;
ruleDay = Grego.fieldsToDay(year, dateTimeRule.getRuleMonth(),
Grego.monthLength(year, dateTimeRule.getRuleMonth()));
ruleDay += 7 * (weeks + 1);
}
} else {
int month = dateTimeRule.getRuleMonth();
int dom = dateTimeRule.getRuleDayOfMonth();
if (type == DateTimeRule.DOW_LEQ_DOM) {
after = false;
// Handle Feb <=29
if (month == Calendar.FEBRUARY && dom == 29 && !Grego.isLeapYear(year)) {
dom--;
}
}
ruleDay = Grego.fieldsToDay(year, month, dom);
}
int dow = Grego.dayOfWeek(ruleDay);
int delta = dateTimeRule.getRuleDayOfWeek() - dow;
if (after) {
delta = delta < 0 ? delta + 7 : delta;
} else {
delta = delta > 0 ? delta - 7 : delta;
}
ruleDay += delta;
}
long ruleTime = ruleDay * Grego.MILLIS_PER_DAY + dateTimeRule.getRuleMillisInDay();
if (dateTimeRule.getTimeRuleType() != DateTimeRule.UTC_TIME) {
ruleTime -= prevRawOffset;
}
if (dateTimeRule.getTimeRuleType() == DateTimeRule.WALL_TIME) {
ruleTime -= prevDSTSavings;
}
return new Date(ruleTime);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public Date getFirstStart(int prevRawOffset, int prevDSTSavings) {
return getStartInYear(startYear, prevRawOffset, prevDSTSavings);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public Date getFinalStart(int prevRawOffset, int prevDSTSavings) {
if (endYear == MAX_YEAR) {
return null;
}
return getStartInYear(endYear, prevRawOffset, prevDSTSavings);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public Date getNextStart(long base, int prevRawOffset, int prevDSTSavings, boolean inclusive) {
int[] fields = Grego.timeToFields(base, null);
int year = fields[0];
if (year < startYear) {
return getFirstStart(prevRawOffset, prevDSTSavings);
}
Date d = getStartInYear(year, prevRawOffset, prevDSTSavings);
if (d != null && (d.getTime() < base || (!inclusive && (d.getTime() == base)))) {
d = getStartInYear(year + 1, prevRawOffset, prevDSTSavings);
}
return d;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public Date getPreviousStart(long base, int prevRawOffset, int prevDSTSavings, boolean inclusive) {
int[] fields = Grego.timeToFields(base, null);
int year = fields[0];
if (year > endYear) {
return getFinalStart(prevRawOffset, prevDSTSavings);
}
Date d = getStartInYear(year, prevRawOffset, prevDSTSavings);
if (d != null && (d.getTime() > base || (!inclusive && (d.getTime() == base)))) {
d = getStartInYear(year - 1, prevRawOffset, prevDSTSavings);
}
return d;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public boolean isEquivalentTo(TimeZoneRule other) {
if (!(other instanceof AnnualTimeZoneRule)) {
return false;
}
AnnualTimeZoneRule otherRule = (AnnualTimeZoneRule)other;
if (startYear == otherRule.startYear
&& endYear == otherRule.endYear
&& dateTimeRule.equals(otherRule.dateTimeRule)) {
return super.isEquivalentTo(other);
}
return false;
}
/**
* {@inheritDoc}
* Note: This method in AnnualTimeZoneRule always returns true.
* @stable ICU 3.8
*/
public boolean isTransitionRule() {
return true;
}
/**
* Returns a String representation of this AnnualTimeZoneRule object.
* This method is used for debugging purpose only. The string representation can be changed
* in future version of ICU without any notice.
*
* @stable ICU 3.8
*/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append(super.toString());
buf.append(", rule={" + dateTimeRule + "}");
buf.append(", startYear=" + startYear);
buf.append(", endYear=");
if (endYear == MAX_YEAR) {
buf.append("max");
} else {
buf.append(endYear);
}
return buf.toString();
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/IslamicCalendar.java 0000644 0001750 0001750 00000056241 11015072544 022367 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import com.ibm.icu.util.TimeZone;
import com.ibm.icu.impl.CalendarAstronomer;
import com.ibm.icu.impl.CalendarCache;
import java.util.Date;
import java.util.Locale;
/**
* IslamicCalendar is a subclass of Calendar
* that that implements the Islamic civil and religious calendars. It
* is used as the civil calendar in most of the Arab world and the
* liturgical calendar of the Islamic faith worldwide. This calendar
* is also known as the "Hijri" calendar, since it starts at the time
* of Mohammed's emigration (or "hijra") to Medinah on Thursday,
* July 15, 622 AD (Julian).
* IslamicCalendar
* object.
* setCivil(false)
* is called, an approximation of the true lunar calendar will be used.
* ULocale
* with the tag "@calendar=islamic" or "@calendar=islamic-civil".IslamicCalendar using the current time
* in the default time zone with the default locale.
* @stable ICU 2.8
*/
public IslamicCalendar()
{
this(TimeZone.getDefault(), ULocale.getDefault());
}
/**
* Constructs an IslamicCalendar based on the current time
* in the given time zone with the default locale.
* @param zone the given time zone.
* @stable ICU 2.8
*/
public IslamicCalendar(TimeZone zone)
{
this(zone, ULocale.getDefault());
}
/**
* Constructs an IslamicCalendar based on the current time
* in the default time zone with the given locale.
*
* @param aLocale the given locale.
* @stable ICU 2.8
*/
public IslamicCalendar(Locale aLocale)
{
this(TimeZone.getDefault(), aLocale);
}
/**
* Constructs an IslamicCalendar based on the current time
* in the default time zone with the given locale.
*
* @param locale the given ulocale.
* @stable ICU 3.2
*/
public IslamicCalendar(ULocale locale)
{
this(TimeZone.getDefault(), locale);
}
/**
* Constructs an IslamicCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone the given time zone.
* @param aLocale the given locale.
* @stable ICU 2.8
*/
public IslamicCalendar(TimeZone zone, Locale aLocale)
{
super(zone, aLocale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs an IslamicCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone the given time zone.
* @param locale the given ulocale.
* @stable ICU 3.2
*/
public IslamicCalendar(TimeZone zone, ULocale locale)
{
super(zone, locale);
setTimeInMillis(System.currentTimeMillis());
}
/**
* Constructs an IslamicCalendar with the given date set
* in the default time zone with the default locale.
*
* @param date The date to which the new calendar is set.
* @stable ICU 2.8
*/
public IslamicCalendar(Date date) {
super(TimeZone.getDefault(), ULocale.getDefault());
this.setTime(date);
}
/**
* Constructs an IslamicCalendar with the given date set
* in the default time zone with the default locale.
*
* @param year the value used to set the {@link #YEAR YEAR} time field in the calendar.
* @param month the value used to set the {@link #MONTH MONTH} time field in the calendar.
* Note that the month value is 0-based. e.g., 0 for Muharram.
* @param date the value used to set the {@link #DATE DATE} time field in the calendar.
* @stable ICU 2.8
*/
public IslamicCalendar(int year, int month, int date)
{
super(TimeZone.getDefault(), ULocale.getDefault());
this.set(Calendar.YEAR, year);
this.set(Calendar.MONTH, month);
this.set(Calendar.DATE, date);
}
/**
* Constructs an IslamicCalendar with the given date
* and time set for the default time zone with the default locale.
*
* @param year the value used to set the {@link #YEAR YEAR} time field in the calendar.
* @param month the value used to set the {@link #MONTH MONTH} time field in the calendar.
* Note that the month value is 0-based. e.g., 0 for Muharram.
* @param date the value used to set the {@link #DATE DATE} time field in the calendar.
* @param hour the value used to set the {@link #HOUR_OF_DAY HOUR_OF_DAY} time field
* in the calendar.
* @param minute the value used to set the {@link #MINUTE MINUTE} time field
* in the calendar.
* @param second the value used to set the {@link #SECOND SECOND} time field
* in the calendar.
* @stable ICU 2.8
*/
public IslamicCalendar(int year, int month, int date, int hour,
int minute, int second)
{
super(TimeZone.getDefault(), ULocale.getDefault());
this.set(Calendar.YEAR, year);
this.set(Calendar.MONTH, month);
this.set(Calendar.DATE, date);
this.set(Calendar.HOUR_OF_DAY, hour);
this.set(Calendar.MINUTE, minute);
this.set(Calendar.SECOND, second);
}
/**
* Determines whether this object uses the fixed-cycle Islamic civil calendar
* or an approximation of the religious, astronomical calendar.
*
* @param beCivil true to use the civil calendar,
* false to use the astronomical calendar.
* @stable ICU 2.8
*/
public void setCivil(boolean beCivil)
{
if (civil != beCivil) {
// The fields of the calendar will become invalid, because the calendar
// rules are different
long m = getTimeInMillis();
civil = beCivil;
clear();
setTimeInMillis(m);
}
}
/**
* Returns true if this object is using the fixed-cycle civil
* calendar, or false if using the religious, astronomical
* calendar.
* @stable ICU 2.8
*/
public boolean isCivil() {
return civil;
}
//-------------------------------------------------------------------------
// Minimum / Maximum access functions
//-------------------------------------------------------------------------
// Note: Current IslamicCalendar implementation does not work
// well with negative years.
private static final int LIMITS[][] = {
// Minimum Greatest Least Maximum
// Minimum Maximum
{ 0, 0, 0, 0}, // ERA
{ 1, 1, 5000000, 5000000}, // YEAR
{ 0, 0, 11, 11}, // MONTH
{ 1, 1, 50, 51}, // WEEK_OF_YEAR
{/* */}, // WEEK_OF_MONTH
{ 1, 1, 29, 30}, // DAY_OF_MONTH
{ 1, 1, 354, 355}, // DAY_OF_YEAR
{/* */}, // DAY_OF_WEEK
{ -1, -1, 5, 5}, // DAY_OF_WEEK_IN_MONTH
{/* */}, // AM_PM
{/* */}, // HOUR
{/* */}, // HOUR_OF_DAY
{/* */}, // MINUTE
{/* */}, // SECOND
{/* */}, // MILLISECOND
{/* */}, // ZONE_OFFSET
{/* */}, // DST_OFFSET
{ 1, 1, 5000000, 5000000}, // YEAR_WOY
{/* */}, // DOW_LOCAL
{ 1, 1, 5000000, 5000000}, // EXTENDED_YEAR
{/* */}, // JULIAN_DAY
{/* */}, // MILLISECONDS_IN_DAY
};
/**
* @stable ICU 2.8
*/
protected int handleGetLimit(int field, int limitType) {
return LIMITS[field][limitType];
}
//-------------------------------------------------------------------------
// Assorted calculation utilities
//
// Unused code - Alan 2003-05
// /**
// * Find the day of the week for a given day
// *
// * @param day The # of days since the start of the Islamic calendar.
// */
// // private and uncalled, perhaps not used yet?
// private static final int absoluteDayToDayOfWeek(long day)
// {
// // Calculate the day of the week.
// // This relies on the fact that the epoch was a Thursday.
// int dayOfWeek = (int)(day + THURSDAY) % 7 + SUNDAY;
// if (dayOfWeek < 0) {
// dayOfWeek += 7;
// }
// return dayOfWeek;
// }
/**
* Determine whether a year is a leap year in the Islamic civil calendar
*/
private final static boolean civilLeapYear(int year)
{
return (14 + 11 * year) % 30 < 11;
}
/**
* Return the day # on which the given year starts. Days are counted
* from the Hijri epoch, origin 0.
*/
private long yearStart(int year) {
if (civil) {
return (year-1)*354 + (long)Math.floor((3+11*year)/30.0);
} else {
return trueMonthStart(12*(year-1));
}
}
/**
* Return the day # on which the given month starts. Days are counted
* from the Hijri epoch, origin 0.
*
* @param year The hijri year
* @param month The hijri month, 0-based
*/
private long monthStart(int year, int month) {
if (civil) {
return (long)Math.ceil(29.5*month)
+ (year-1)*354 + (long)Math.floor((3+11*year)/30.0);
} else {
return trueMonthStart(12*(year-1) + month);
}
}
/**
* Find the day number on which a particular month of the true/lunar
* Islamic calendar starts.
*
* @param month The month in question, origin 0 from the Hijri epoch
*
* @return The day number on which the given month starts.
*/
private static final long trueMonthStart(long month)
{
long start = cache.get(month);
if (start == CalendarCache.EMPTY)
{
// Make a guess at when the month started, using the average length
long origin = HIJRA_MILLIS
+ (long)Math.floor(month * CalendarAstronomer.SYNODIC_MONTH - 1) * ONE_DAY;
double age = moonAge(origin);
if (moonAge(origin) >= 0) {
// The month has already started
do {
origin -= ONE_DAY;
age = moonAge(origin);
} while (age >= 0);
}
else {
// Preceding month has not ended yet.
do {
origin += ONE_DAY;
age = moonAge(origin);
} while (age < 0);
}
start = (origin - HIJRA_MILLIS) / ONE_DAY + 1;
cache.put(month, start);
}
return start;
}
/**
* Return the "age" of the moon at the given time; this is the difference
* in ecliptic latitude between the moon and the sun. This method simply
* calls CalendarAstronomer.moonAge, converts to degrees,
* and adjusts the resultto be in the range [-180, 180].
*
* @param time The time at which the moon's age is desired,
* in millis since 1/1/1970.
*/
static final double moonAge(long time)
{
double age = 0;
synchronized(astro) {
astro.setTime(time);
age = astro.getMoonAge();
}
// Convert to degrees and normalize...
age = age * 180 / Math.PI;
if (age > 180) {
age = age - 360;
}
return age;
}
//-------------------------------------------------------------------------
// Internal data....
//
// And an Astronomer object for the moon age calculations
private static CalendarAstronomer astro = new CalendarAstronomer();
private static CalendarCache cache = new CalendarCache();
/**
* true if this object uses the fixed-cycle Islamic civil calendar,
* and false if it approximates the true religious calendar using
* astronomical calculations for the time of the new moon.
*
* @serial
*/
private boolean civil = true;
//----------------------------------------------------------------------
// Calendar framework
//----------------------------------------------------------------------
/**
* Return the length (in days) of the given month.
*
* @param extendedYear The hijri year
* @param month The hijri month, 0-based
* @stable ICU 2.8
*/
protected int handleGetMonthLength(int extendedYear, int month) {
int length = 0;
if (civil) {
length = 29 + (month+1) % 2;
if (month == DHU_AL_HIJJAH && civilLeapYear(extendedYear)) {
length++;
}
} else {
month = 12*(extendedYear-1) + month;
length = (int)( trueMonthStart(month+1) - trueMonthStart(month) );
}
return length;
}
/**
* Return the number of days in the given Islamic year
* @stable ICU 2.8
*/
protected int handleGetYearLength(int extendedYear) {
if (civil) {
return 354 + (civilLeapYear(extendedYear) ? 1 : 0);
} else {
int month = 12*(extendedYear-1);
return (int)(trueMonthStart(month + 12) - trueMonthStart(month));
}
}
//-------------------------------------------------------------------------
// Functions for converting from field values to milliseconds....
//-------------------------------------------------------------------------
// Return JD of start of given month/year
/**
* @stable ICU 2.8
*/
protected int handleComputeMonthStart(int eyear, int month, boolean useMonth) {
return (int) monthStart(eyear, month) + 1948439;
}
//-------------------------------------------------------------------------
// Functions for converting from milliseconds to field values
//-------------------------------------------------------------------------
/**
* @stable ICU 2.8
*/
protected int handleGetExtendedYear() {
int year;
if (newerField(EXTENDED_YEAR, YEAR) == EXTENDED_YEAR) {
year = internalGet(EXTENDED_YEAR, 1); // Default to year 1
} else {
year = internalGet(YEAR, 1); // Default to year 1
}
return year;
}
/**
* Override Calendar to compute several fields specific to the Islamic
* calendar system. These are:
*
*
*
* The DAY_OF_WEEK and DOW_LOCAL fields are already set when this
* method is called. The getGregorianXxx() methods return Gregorian
* calendar equivalents for the given Julian day.
* @stable ICU 2.8
*/
protected void handleComputeFields(int julianDay) {
int year, month, dayOfMonth, dayOfYear;
long monthStart;
long days = julianDay - 1948440;
if (civil) {
// Use the civil calendar approximation, which is just arithmetic
year = (int)Math.floor( (30 * days + 10646) / 10631.0 );
month = (int)Math.ceil((days - 29 - yearStart(year)) / 29.5 );
month = Math.min(month, 11);
monthStart = monthStart(year, month);
} else {
// Guess at the number of elapsed full months since the epoch
int months = (int)Math.floor(days / CalendarAstronomer.SYNODIC_MONTH);
monthStart = (long)Math.floor(months * CalendarAstronomer.SYNODIC_MONTH - 1);
if ( days - monthStart >= 28 && moonAge(internalGetTimeInMillis()) > 0) {
// If we're near the end of the month, assume next month and search backwards
months++;
}
// Find out the last time that the new moon was actually visible at this longitude
// This returns midnight the night that the moon was visible at sunset.
while ((monthStart = trueMonthStart(months)) > days) {
// If it was after the date in question, back up a month and try again
months--;
}
year = months / 12 + 1;
month = months % 12;
}
dayOfMonth = (int)(days - monthStart(year, month)) + 1;
// Now figure out the day of the year.
dayOfYear = (int)(days - monthStart(year, 0) + 1);
internalSet(ERA, 0);
internalSet(YEAR, year);
internalSet(EXTENDED_YEAR, year);
internalSet(MONTH, month);
internalSet(DAY_OF_MONTH, dayOfMonth);
internalSet(DAY_OF_YEAR, dayOfYear);
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public String getType() {
return "islamic";
}
/*
private static CalendarFactory factory;
public static CalendarFactory factory() {
if (factory == null) {
factory = new CalendarFactory() {
public Calendar create(TimeZone tz, ULocale loc) {
return new IslamicCalendar(tz, loc);
}
public String factoryName() {
return "Islamic";
}
};
}
return factory;
}
*/
}
icu4j-4.2.1.1/src/com/ibm/icu/util/CurrencyServiceShim.java 0000644 0001750 0001750 00000005055 10775324256 023321 0 ustar twerner twerner /**
*******************************************************************************
* Copyright (C) 2001-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.Locale;
import com.ibm.icu.impl.ICUResourceBundle;
import com.ibm.icu.impl.ICUService;
import com.ibm.icu.impl.ICUService.Factory;
import com.ibm.icu.impl.ICULocaleService;
/**
* This is a package-access implementation of registration for
* currency. The shim is instantiated by reflection in Currency, all
* dependencies on ICUService are located in this file. This structure
* is to allow ICU4J to be built without service registration support.
*/
final class CurrencyServiceShim extends Currency.ServiceShim {
Locale[] getAvailableLocales() {
if (service.isDefault()) {
return ICUResourceBundle.getAvailableLocales(ICUResourceBundle.ICU_BASE_NAME);
}
return service.getAvailableLocales();
}
ULocale[] getAvailableULocales() {
if (service.isDefault()) {
return ICUResourceBundle.getAvailableULocales(ICUResourceBundle.ICU_BASE_NAME);
}
return service.getAvailableULocales();
}
Currency createInstance(ULocale loc) {
// TODO: convert to ULocale when service switches over
if (service.isDefault()) {
return Currency.createCurrency(loc);
}
ULocale[] actualLoc = new ULocale[1];
Currency curr = (Currency)service.get(loc, actualLoc);
ULocale uloc = actualLoc[0];
curr.setLocale(uloc, uloc); // services make no distinction between actual & valid
return curr;
}
Object registerInstance(Currency currency, ULocale locale) {
return service.registerObject(currency, locale);
}
boolean unregister(Object registryKey) {
return service.unregisterFactory((Factory)registryKey);
}
private static class CFService extends ICULocaleService {
CFService() {
super("Currency");
class CurrencyFactory extends ICUResourceBundleFactory {
protected Object handleCreate(ULocale loc, int kind, ICUService srvc) {
return Currency.createCurrency(loc);
}
}
registerFactory(new CurrencyFactory());
markDefault();
}
}
static final ICULocaleService service = new CFService();
}
icu4j-4.2.1.1/src/com/ibm/icu/util/GlobalizationPreferences.java 0000644 0001750 0001750 00000150342 11157074147 024341 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2004-2009, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import com.ibm.icu.impl.Utility;
import com.ibm.icu.impl.ZoneMeta;
import com.ibm.icu.text.BreakIterator;
import com.ibm.icu.text.Collator;
import com.ibm.icu.text.DateFormat;
import com.ibm.icu.text.NumberFormat;
import com.ibm.icu.text.SimpleDateFormat;
/**
* This convenience class provides a mechanism for bundling together different
* globalization preferences. It includes:
*
*
* The class will heuristically compute implicit, heuristic values for the above
* based on available data if explicit values are not supplied. These implicit
* values can be presented to users for confirmation, or replacement if the
* values are incorrect.
*
*
*
* @draft ICU 3.6 (retainAll)
* @provisional This API might change or be removed in a future release.
*/
//TODO:
// - Add Holidays
// - Add convenience to get/take Locale as well as ULocale.
// - Add Lenient datetime formatting when that is available.
// - Should this be serializable?
// - Other utilities?
public class GlobalizationPreferences implements Freezable {
/**
* Default constructor
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences(){}
/**
* Number Format type
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public static final int
NF_NUMBER = 0, // NumberFormat.NUMBERSTYLE
NF_CURRENCY = 1, // NumberFormat.CURRENCYSTYLE
NF_PERCENT = 2, // NumberFormat.PERCENTSTYLE
NF_SCIENTIFIC = 3, // NumberFormat.SCIENTIFICSTYLE
NF_INTEGER = 4; // NumberFormat.INTEGERSTYLE
private static final int NF_LIMIT = NF_INTEGER + 1;
/**
* Date Format type
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public static final int
DF_FULL = DateFormat.FULL, // 0
DF_LONG = DateFormat.LONG, // 1
DF_MEDIUM = DateFormat.MEDIUM, // 2
DF_SHORT = DateFormat.SHORT, // 3
DF_NONE = 4;
private static final int DF_LIMIT = DF_NONE + 1;
/**
* For selecting a choice of display names
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public static final int
ID_LOCALE = 0,
ID_LANGUAGE = 1,
ID_SCRIPT = 2,
ID_TERRITORY = 3,
ID_VARIANT = 4,
ID_KEYWORD = 5,
ID_KEYWORD_VALUE = 6,
ID_CURRENCY = 7,
ID_CURRENCY_SYMBOL = 8,
ID_TIMEZONE = 9;
//private static final int ID_LIMIT = ID_TIMEZONE + 1;
/**
* Break iterator type
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public static final int
BI_CHARACTER = BreakIterator.KIND_CHARACTER, // 0
BI_WORD = BreakIterator.KIND_WORD, // 1
BI_LINE = BreakIterator.KIND_LINE, // 2
BI_SENTENCE = BreakIterator.KIND_SENTENCE, // 3
BI_TITLE = BreakIterator.KIND_TITLE; // 4
private static final int BI_LIMIT = BI_TITLE + 1;
/**
* Sets the language/locale priority list. If other information is
* not (yet) available, this is used to to produce a default value
* for the appropriate territory, currency, timezone, etc. The
* user should be given the opportunity to correct those defaults
* in case they are incorrect.
*
* @param inputLocales list of locales in priority order, eg {"be", "fr"}
* for Breton first, then French if that fails.
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setLocales(List inputLocales) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
locales = processLocales(inputLocales);
return this;
}
/**
* Get a copy of the language/locale priority list
*
* @return a copy of the language/locale priority list.
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public List getLocales() {
List result;
if (locales == null) {
result = guessLocales();
} else {
result = new ArrayList();
result.addAll(locales);
}
return result;
}
/**
* Convenience function for getting the locales in priority order
* @param index The index (0..n) of the desired item.
* @return desired item. null if index is out of range
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public ULocale getLocale(int index) {
List lcls = locales;
if (lcls == null) {
lcls = guessLocales();
}
if (index >= 0 && index < lcls.size()) {
return (ULocale)lcls.get(index);
}
return null;
}
/**
* Convenience routine for setting the language/locale priority
* list from an array.
*
* @see #setLocales(List locales)
* @param uLocales list of locales in an array
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setLocales(ULocale[] uLocales) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
return setLocales(Arrays.asList(uLocales));
}
/**
* Convenience routine for setting the language/locale priority
* list from a single locale/language.
*
* @see #setLocales(List locales)
* @param uLocale single locale
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setLocale(ULocale uLocale) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
return setLocales(new ULocale[]{uLocale});
}
/**
* Convenience routine for setting the locale priority list from
* an Accept-Language string.
* @see #setLocales(List locales)
* @param acceptLanguageString Accept-Language list, as defined by
* Section 14.4 of the RFC 2616 (HTTP 1.1)
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setLocales(String acceptLanguageString) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
ULocale[] acceptLocales = null;
try {
acceptLocales = ULocale.parseAcceptLanguage(acceptLanguageString, true);
} catch (ParseException pe) {
//TODO: revisit after 3.8
throw new IllegalArgumentException("Invalid Accept-Language string");
}
return setLocales(acceptLocales);
}
/**
* Convenience function to get a ResourceBundle instance using
* the specified base name based on the language/locale priority list
* stored in this object.
*
* @param baseName the base name of the resource bundle, a fully qualified
* class name
* @return a resource bundle for the given base name and locale based on the
* language/locale priority list stored in this object
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public ResourceBundle getResourceBundle(String baseName) {
return getResourceBundle(baseName, null);
}
/**
* Convenience function to get a ResourceBundle instance using
* the specified base name and class loader based on the language/locale
* priority list stored in this object.
*
* @param baseName the base name of the resource bundle, a fully qualified
* class name
* @param loader the class object from which to load the resource bundle
* @return a resource bundle for the given base name and locale based on the
* language/locale priority list stored in this object
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public ResourceBundle getResourceBundle(String baseName, ClassLoader loader) {
UResourceBundle urb = null;
UResourceBundle candidate = null;
String actualLocaleName = null;
List fallbacks = getLocales();
for (int i = 0; i < fallbacks.size(); i++) {
String localeName = ((ULocale)fallbacks.get(i)).toString();
if (actualLocaleName != null && localeName.equals(actualLocaleName)) {
// Actual locale name in the previous round may exactly matches
// with the next fallback locale
urb = candidate;
break;
}
try {
if (loader == null) {
candidate = UResourceBundle.getBundleInstance(baseName, localeName);
}
else {
candidate = UResourceBundle.getBundleInstance(baseName, localeName, loader);
}
if (candidate != null) {
actualLocaleName = candidate.getULocale().getName();
if (actualLocaleName.equals(localeName)) {
urb = candidate;
break;
}
if (urb == null) {
// Preserve the available bundle as the last resort
urb = candidate;
}
}
} catch (MissingResourceException mre) {
actualLocaleName = null;
continue;
}
}
if (urb == null) {
throw new MissingResourceException("Can't find bundle for base name "
+ baseName, baseName, "");
}
return urb;
}
/**
* Sets the territory, which is a valid territory according to for
* RFC 3066 (or successor). If not otherwise set, default
* currency and timezone values will be set from this. The user
* should be given the opportunity to correct those defaults in
* case they are incorrect.
*
* @param territory code
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setTerritory(String territory) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
this.territory = territory; // immutable, so don't need to clone
return this;
}
/**
* Gets the territory setting. If it wasn't explicitly set, it is
* computed from the general locale setting.
*
* @return territory code, explicit or implicit.
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public String getTerritory() {
if (territory == null) {
return guessTerritory();
}
return territory; // immutable, so don't need to clone
}
/**
* Sets the currency code. If this has not been set, uses default for territory.
*
* @param currency Valid ISO 4217 currency code.
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setCurrency(Currency currency) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
this.currency = currency; // immutable, so don't need to clone
return this;
}
/**
* Get a copy of the currency computed according to the settings.
*
* @return currency code, explicit or implicit.
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public Currency getCurrency() {
if (currency == null) {
return guessCurrency();
}
return currency; // immutable, so don't have to clone
}
/**
* Sets the calendar. If this has not been set, uses default for territory.
*
* @param calendar arbitrary calendar
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setCalendar(Calendar calendar) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
this.calendar = (Calendar) calendar.clone(); // clone for safety
return this;
}
/**
* Get a copy of the calendar according to the settings.
*
* @return calendar explicit or implicit.
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public Calendar getCalendar() {
if (calendar == null) {
return guessCalendar();
}
Calendar temp = (Calendar) calendar.clone(); // clone for safety
temp.setTimeZone(getTimeZone());
temp.setTimeInMillis(System.currentTimeMillis());
return temp;
}
/**
* Sets the timezone ID. If this has not been set, uses default for territory.
*
* @param timezone a valid TZID (see UTS#35).
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setTimeZone(TimeZone timezone) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
this.timezone = (TimeZone) timezone.clone(); // clone for safety;
return this;
}
/**
* Get the timezone. It was either explicitly set, or is
* heuristically computed from other settings.
*
* @return timezone, either implicitly or explicitly set
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public TimeZone getTimeZone() {
if (timezone == null) {
return guessTimeZone();
}
return (TimeZone) timezone.clone(); // clone for safety
}
/**
* Get a copy of the collator according to the settings.
*
* @return collator explicit or implicit.
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public Collator getCollator() {
if (collator == null) {
return guessCollator();
}
try {
return (Collator) collator.clone(); // clone for safety
} catch (CloneNotSupportedException e) {
throw new IllegalStateException("Error in cloning collator");
}
}
/**
* Explicitly set the collator for this object.
* @param collator
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setCollator(Collator collator) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
try {
this.collator = (Collator) collator.clone(); // clone for safety
} catch (CloneNotSupportedException e) {
throw new IllegalStateException("Error in cloning collator");
}
return this;
}
/**
* Get a copy of the break iterator for the specified type according to the
* settings.
*
* @param type
* break type - BI_CHARACTER or BI_WORD, BI_LINE, BI_SENTENCE, BI_TITLE
* @return break iterator explicit or implicit
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public BreakIterator getBreakIterator(int type) {
if (type < BI_CHARACTER || type >= BI_LIMIT) {
throw new IllegalArgumentException("Illegal break iterator type");
}
if (breakIterators == null || breakIterators[type] == null) {
return guessBreakIterator(type);
}
return (BreakIterator) breakIterators[type].clone(); // clone for safety
}
/**
* Explicitly set the break iterator for this object.
*
* @param type
* break type - BI_CHARACTER or BI_WORD, BI_LINE, BI_SENTENCE, BI_TITLE
* @param iterator a break iterator
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setBreakIterator(int type, BreakIterator iterator) {
if (type < BI_CHARACTER || type >= BI_LIMIT) {
throw new IllegalArgumentException("Illegal break iterator type");
}
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
if (breakIterators == null)
breakIterators = new BreakIterator[BI_LIMIT];
breakIterators[type] = (BreakIterator) iterator.clone(); // clone for safety
return this;
}
/**
* Get the display name for an ID: language, script, territory, currency, timezone...
* Uses the language priority list to do so.
*
* @param id language code, script code, ...
* @param type specifies the type of the ID: ID_LANGUAGE, etc.
* @return the display name
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public String getDisplayName(String id, int type) {
String result = id;
for (Iterator it = getLocales().iterator(); it.hasNext();) {
ULocale locale = (ULocale) it.next();
if (!isAvailableLocale(locale, TYPE_GENERIC)) {
continue;
}
switch (type) {
case ID_LOCALE:
result = ULocale.getDisplayName(id, locale);
break;
case ID_LANGUAGE:
result = ULocale.getDisplayLanguage(id, locale);
break;
case ID_SCRIPT:
result = ULocale.getDisplayScript("und-" + id, locale);
break;
case ID_TERRITORY:
result = ULocale.getDisplayCountry("und-" + id, locale);
break;
case ID_VARIANT:
// TODO fix variant parsing
result = ULocale.getDisplayVariant("und-QQ-" + id, locale);
break;
case ID_KEYWORD:
result = ULocale.getDisplayKeyword(id, locale);
break;
case ID_KEYWORD_VALUE:
String[] parts = new String[2];
Utility.split(id,'=',parts);
result = ULocale.getDisplayKeywordValue("und@"+id, parts[0], locale);
// TODO fix to tell when successful
if (result.equals(parts[1])) {
continue;
}
break;
case ID_CURRENCY_SYMBOL:
case ID_CURRENCY:
Currency temp = new Currency(id);
result =temp.getName(locale, type==ID_CURRENCY
? Currency.LONG_NAME
: Currency.SYMBOL_NAME, new boolean[1]);
// TODO: have method that doesn't take parameter. Add
// function to determine whether string is choice
// format.
// TODO: have method that doesn't require us
// to create a currency
break;
case ID_TIMEZONE:
SimpleDateFormat dtf = new SimpleDateFormat("vvvv",locale);
dtf.setTimeZone(TimeZone.getTimeZone(id));
result = dtf.format(new Date());
// TODO, have method that doesn't require us to create a timezone
// fix other hacks
// hack for couldn't match
boolean isBadStr = false;
// Matcher badTimeZone = Pattern.compile("[A-Z]{2}|.*\\s\\([A-Z]{2}\\)").matcher("");
// badtzstr = badTimeZone.reset(result).matches();
String teststr = result;
int sidx = result.indexOf('(');
int eidx = result.indexOf(')');
if (sidx != -1 && eidx != -1 && (eidx - sidx) == 3) {
teststr = result.substring(sidx+1, eidx);
}
if (teststr.length() == 2) {
isBadStr = true;
for (int i = 0; i < 2; i++) {
char c = teststr.charAt(i);
if (c < 'A' || 'Z' < c) {
isBadStr = false;
break;
}
}
}
if (isBadStr) {
continue;
}
break;
default:
throw new IllegalArgumentException("Unknown type: " + type);
}
// TODO need better way of seeing if we fell back to root!!
// This will not work at all for lots of stuff
if (!id.equals(result)) {
return result;
}
}
return result;
}
/**
* Set an explicit date format. Overrides the locale priority list for
* a particular combination of dateStyle and timeStyle. DF_NONE should
* be used if for the style, where only the date or time format individually
* is being set.
*
* @param dateStyle DF_FULL, DF_LONG, DF_MEDIUM, DF_SHORT or DF_NONE
* @param timeStyle DF_FULL, DF_LONG, DF_MEDIUM, DF_SHORT or DF_NONE
* @param format The date format
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setDateFormat(int dateStyle, int timeStyle, DateFormat format) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
if (dateFormats == null) {
dateFormats = new DateFormat[DF_LIMIT][DF_LIMIT];
}
dateFormats[dateStyle][timeStyle] = (DateFormat) format.clone(); // for safety
return this;
}
/**
* Gets a date format according to the current settings. If there
* is an explicit (non-null) date/time format set, a copy of that
* is returned. Otherwise, the language priority list is used.
* DF_NONE should be used for the style, where only the date or
* time format individually is being gotten.
*
* @param dateStyle DF_FULL, DF_LONG, DF_MEDIUM, DF_SHORT or DF_NONE
* @param timeStyle DF_FULL, DF_LONG, DF_MEDIUM, DF_SHORT or DF_NONE
* @return a DateFormat, according to the above description
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public DateFormat getDateFormat(int dateStyle, int timeStyle) {
if (dateStyle == DF_NONE && timeStyle == DF_NONE
|| dateStyle < 0 || dateStyle >= DF_LIMIT
|| timeStyle < 0 || timeStyle >= DF_LIMIT) {
throw new IllegalArgumentException("Illegal date format style arguments");
}
DateFormat result = null;
if (dateFormats != null) {
result = dateFormats[dateStyle][timeStyle];
}
if (result != null) {
result = (DateFormat) result.clone(); // clone for safety
// Not sure overriding configuration is what we really want...
result.setTimeZone(getTimeZone());
} else {
result = guessDateFormat(dateStyle, timeStyle);
}
return result;
}
/**
* Gets a number format according to the current settings. If
* there is an explicit (non-null) number format set, a copy of
* that is returned. Otherwise, the language priority list is
* used.
*
* @param style NF_NUMBER, NF_CURRENCY, NF_PERCENT, NF_SCIENTIFIC, NF_INTEGER
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public NumberFormat getNumberFormat(int style) {
if (style < 0 || style >= NF_LIMIT) {
throw new IllegalArgumentException("Illegal number format type");
}
NumberFormat result = null;
if (numberFormats != null) {
result = numberFormats[style];
}
if (result != null) {
result = (NumberFormat) result.clone(); // clone for safety (later optimize)
} else {
result = guessNumberFormat(style);
}
return result;
}
/**
* Sets a number format explicitly. Overrides the general locale settings.
*
* @param style NF_NUMBER, NF_CURRENCY, NF_PERCENT, NF_SCIENTIFIC, NF_INTEGER
* @param format The number format
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences setNumberFormat(int style, NumberFormat format) {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
if (numberFormats == null) {
numberFormats = new NumberFormat[NF_LIMIT];
}
numberFormats[style] = (NumberFormat) format.clone(); // for safety
return this;
}
/**
* Restore the object to the initial state.
*
* @return this, for chaining
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public GlobalizationPreferences reset() {
if (isFrozen()) {
throw new UnsupportedOperationException("Attempt to modify immutable object");
}
locales = null;
territory = null;
calendar = null;
collator = null;
breakIterators = null;
timezone = null;
currency = null;
dateFormats = null;
numberFormats = null;
implicitLocales = null;
return this;
}
/**
* Process a language/locale priority list specified via setLocales.
* The input locale list may be expanded or re-ordered to represent the prioritized
* language/locale order actually used by this object by the algorithm explained
* below.
*
*
* Step 1: Move later occurrence of more specific locale before earlier
* occurrence of less specific locale.
*
* Before: en, fr_FR, en_US, en_GB
*
* After: en_US, en_GB, en, fr_FR
*
*
* Step 2: Append a fallback locale to each locale.
*
* Before: en_US, en_GB, en, fr_FR
*
* After: en_US, en, en_GB, en, en, fr_FR, fr
*
*
* Step 3: Remove earlier occurrence of duplicated locale entries.
*
* Before: en_US, en, en_GB, en, en, fr_FR, fr
*
* After: en_US, en_GB, en, fr_FR, fr
*
*
* The final locale list is used to produce a default value for the appropriate territory,
* currency, timezone, etc. The list also represents the lookup order used in
* getResourceBundle for this object. A subclass may override this method
* to customize the algorithm used for populating the locale list.
*
* @param inputLocales The list of input locales
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
protected List processLocales(List inputLocales) {
List result = new ArrayList();
/*
* Step 1: Relocate later occurrence of more specific locale
* before earlier occurrence of less specific locale.
*
* Example:
* Before - en_US, fr_FR, zh, en_US_Boston, zh_TW, zh_Hant, fr_CA
* After - en_US_Boston, en_US, fr_FR, zh_TW, zh_Hant, zh, fr_CA
*/
for (int i = 0; i < inputLocales.size(); i++) {
ULocale uloc = (ULocale)inputLocales.get(i);
String language = uloc.getLanguage();
String script = uloc.getScript();
String country = uloc.getCountry();
String variant = uloc.getVariant();
boolean bInserted = false;
for (int j = 0; j < result.size(); j++) {
// Check if this locale is more specific
// than existing locale entries already inserted
// in the destination list
ULocale u = (ULocale)result.get(j);
if (!u.getLanguage().equals(language)) {
continue;
}
String s = u.getScript();
String c = u.getCountry();
String v = u.getVariant();
if (!s.equals(script)) {
if (s.length() == 0 && c.length() == 0 && v.length() == 0) {
result.add(j, uloc);
bInserted = true;
break;
} else if (s.length() == 0 && c.equals(country)) {
// We want to see zh_Hant_HK before zh_HK
result.add(j, uloc);
bInserted = true;
break;
} else if (script.length() == 0 && country.length() > 0 && c.length() == 0) {
// We want to see zh_HK before zh_Hant
result.add(j, uloc);
bInserted = true;
break;
}
continue;
}
if (!c.equals(country)) {
if (c.length() == 0 && v.length() == 0) {
result.add(j, uloc);
bInserted = true;
break;
}
}
if (!v.equals(variant) && v.length() == 0) {
result.add(j, uloc);
bInserted = true;
break;
}
}
if (!bInserted) {
// Add this locale at the end of the list
result.add(uloc);
}
}
// TODO: Locale aliases might be resolved here
// For example, zh_Hant_TW = zh_TW
/*
* Step 2: Append fallback locales for each entry
*
* Example:
* Before - en_US_Boston, en_US, fr_FR, zh_TW, zh_Hant, zh, fr_CA
* After - en_US_Boston, en_US, en, en_US, en, fr_FR, fr,
* zh_TW, zn, zh_Hant, zh, zh, fr_CA, fr
*/
int index = 0;
while (index < result.size()) {
ULocale uloc = (ULocale)result.get(index);
while (true) {
uloc = uloc.getFallback();
if (uloc.getLanguage().length() == 0) {
break;
}
index++;
result.add(index, uloc);
}
index++;
}
/*
* Step 3: Remove earlier occurrence of duplicated locales
*
* Example:
* Before - en_US_Boston, en_US, en, en_US, en, fr_FR, fr,
* zh_TW, zn, zh_Hant, zh, zh, fr_CA, fr
* After - en_US_Boston, en_US, en, fr_FR, zh_TW, zh_Hant,
* zh, fr_CA, fr
*/
index = 0;
while (index < result.size() - 1) {
ULocale uloc = (ULocale)result.get(index);
boolean bRemoved = false;
for (int i = index + 1; i < result.size(); i++) {
if (uloc.equals((ULocale)result.get(i))) {
// Remove earlier one
result.remove(index);
bRemoved = true;
break;
}
}
if (!bRemoved) {
index++;
}
}
return result;
}
/**
* This function can be overridden by subclasses to use different heuristics.
* It MUST return a 'safe' value,
* one whose modification will not affect this object.
*
* @param dateStyle
* @param timeStyle
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
protected DateFormat guessDateFormat(int dateStyle, int timeStyle) {
DateFormat result;
ULocale dfLocale = getAvailableLocale(TYPE_DATEFORMAT);
if (dfLocale == null) {
dfLocale = ULocale.ROOT;
}
if (timeStyle == DF_NONE) {
result = DateFormat.getDateInstance(getCalendar(), dateStyle, dfLocale);
} else if (dateStyle == DF_NONE) {
result = DateFormat.getTimeInstance(getCalendar(), timeStyle, dfLocale);
} else {
result = DateFormat.getDateTimeInstance(getCalendar(), dateStyle, timeStyle, dfLocale);
}
return result;
}
/**
* This function can be overridden by subclasses to use different heuristics.
* It MUST return a 'safe' value,
* one whose modification will not affect this object.
*
* @param style
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
protected NumberFormat guessNumberFormat(int style) {
NumberFormat result;
ULocale nfLocale = getAvailableLocale(TYPE_NUMBERFORMAT);
if (nfLocale == null) {
nfLocale = ULocale.ROOT;
}
switch (style) {
case NF_NUMBER:
result = NumberFormat.getInstance(nfLocale);
break;
case NF_SCIENTIFIC:
result = NumberFormat.getScientificInstance(nfLocale);
break;
case NF_INTEGER:
result = NumberFormat.getIntegerInstance(nfLocale);
break;
case NF_PERCENT:
result = NumberFormat.getPercentInstance(nfLocale);
break;
case NF_CURRENCY:
result = NumberFormat.getCurrencyInstance(nfLocale);
result.setCurrency(getCurrency());
break;
default:
throw new IllegalArgumentException("Unknown number format style");
}
return result;
}
/**
* This function can be overridden by subclasses to use different heuristics.
*
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
protected String guessTerritory() {
String result;
// pass through locales to see if there is a territory.
for (Iterator it = getLocales().iterator(); it.hasNext();) {
ULocale locale = (ULocale)it.next();
result = locale.getCountry();
if (result.length() != 0) {
return result;
}
}
// if not, guess from the first language tag, or maybe from
// intersection of languages, eg nl + fr => BE
// TODO: fix using real data
// for now, just use fixed values
ULocale firstLocale = getLocale(0);
String language = firstLocale.getLanguage();
String script = firstLocale.getScript();
result = null;
if (script.length() != 0) {
result = (String) language_territory_hack_map.get(language + "_" + script);
}
if (result == null) {
result = (String) language_territory_hack_map.get(language);
}
if (result == null) {
result = "US"; // need *some* default
}
return result;
}
/**
* This function can be overridden by subclasses to use different heuristics
*
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
protected Currency guessCurrency() {
return Currency.getInstance(new ULocale("und-" + getTerritory()));
}
/**
* This function can be overridden by subclasses to use different heuristics
* It MUST return a 'safe' value,
* one whose modification will not affect this object.
*
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
protected List guessLocales() {
if (implicitLocales == null) {
List result = new ArrayList(1);
result.add(ULocale.getDefault());
implicitLocales = processLocales(result);
}
return implicitLocales;
}
/**
* This function can be overridden by subclasses to use different heuristics.
* It MUST return a 'safe' value,
* one whose modification will not affect this object.
*
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
protected Collator guessCollator() {
ULocale collLocale = getAvailableLocale(TYPE_COLLATOR);
if (collLocale == null) {
collLocale = ULocale.ROOT;
}
return Collator.getInstance(collLocale);
}
/**
* This function can be overridden by subclasses to use different heuristics.
* It MUST return a 'safe' value,
* one whose modification will not affect this object.
*
* @param type
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
protected BreakIterator guessBreakIterator(int type) {
BreakIterator bitr = null;
ULocale brkLocale = getAvailableLocale(TYPE_BREAKITERATOR);
if (brkLocale == null) {
brkLocale = ULocale.ROOT;
}
switch (type) {
case BI_CHARACTER:
bitr = BreakIterator.getCharacterInstance(brkLocale);
break;
case BI_TITLE:
bitr = BreakIterator.getTitleInstance(brkLocale);
break;
case BI_WORD:
bitr = BreakIterator.getWordInstance(brkLocale);
break;
case BI_LINE:
bitr = BreakIterator.getLineInstance(brkLocale);
break;
case BI_SENTENCE:
bitr = BreakIterator.getSentenceInstance(brkLocale);
break;
default:
throw new IllegalArgumentException("Unknown break iterator type");
}
return bitr;
}
/**
* This function can be overridden by subclasses to use different heuristics.
* It MUST return a 'safe' value,
* one whose modification will not affect this object.
*
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
protected TimeZone guessTimeZone() {
// TODO fix using real data
// for single-zone countries, pick that zone
// for others, pick the most populous zone
// for now, just use fixed value
// NOTE: in a few cases can do better by looking at language.
// Eg haw+US should go to Pacific/Honolulu
// fr+CA should go to America/Montreal
String timezoneString = (String) territory_tzid_hack_map.get(getTerritory());
if (timezoneString == null) {
String[] attempt = ZoneMeta.getAvailableIDs(getTerritory());
if (attempt.length == 0) {
timezoneString = "Etc/GMT"; // gotta do something
} else {
int i;
// this all needs to be fixed to use real data. But for now, do slightly better by skipping cruft
for (i = 0; i < attempt.length; ++i) {
if (attempt[i].indexOf("/") >= 0) break;
}
if (i > attempt.length) i = 0;
timezoneString = attempt[i];
}
}
return TimeZone.getTimeZone(timezoneString);
}
/**
* This function can be overridden by subclasses to use different heuristics.
* It MUST return a 'safe' value,
* one whose modification will not affect this object.
*
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
protected Calendar guessCalendar() {
ULocale calLocale = getAvailableLocale(TYPE_CALENDAR);
if (calLocale == null) {
calLocale = ULocale.US;
}
return Calendar.getInstance(getTimeZone(), calLocale);
}
// PRIVATES
private List locales;
private String territory;
private Currency currency;
private TimeZone timezone;
private Calendar calendar;
private Collator collator;
private BreakIterator[] breakIterators;
private DateFormat[][] dateFormats;
private NumberFormat[] numberFormats;
private List implicitLocales;
{
reset();
}
private ULocale getAvailableLocale(int type) {
List locs = getLocales();
ULocale result = null;
for (int i = 0; i < locs.size(); i++) {
ULocale l = (ULocale)locs.get(i);
if (isAvailableLocale(l, type)) {
result = l;
break;
}
}
return result;
}
private boolean isAvailableLocale(ULocale loc, int type) {
BitSet bits = (BitSet)available_locales.get(loc);
if (bits != null && bits.get(type)) {
return true;
}
return false;
}
/*
* Available locales for service types
*/
private static final HashMap available_locales = new HashMap();
private static final int
TYPE_GENERIC = 0,
TYPE_CALENDAR = 1,
TYPE_DATEFORMAT= 2,
TYPE_NUMBERFORMAT = 3,
TYPE_COLLATOR = 4,
TYPE_BREAKITERATOR = 5,
TYPE_LIMIT = TYPE_BREAKITERATOR + 1;
static {
BitSet bits;
ULocale[] allLocales = ULocale.getAvailableLocales();
for (int i = 0; i < allLocales.length; i++) {
bits = new BitSet(TYPE_LIMIT);
available_locales.put(allLocales[i], bits);
bits.set(TYPE_GENERIC);
}
ULocale[] calLocales = Calendar.getAvailableULocales();
for (int i = 0; i < calLocales.length; i++) {
bits = (BitSet)available_locales.get(calLocales[i]);
if (bits == null) {
bits = new BitSet(TYPE_LIMIT);
available_locales.put(allLocales[i], bits);
}
bits.set(TYPE_CALENDAR);
}
ULocale[] dateLocales = DateFormat.getAvailableULocales();
for (int i = 0; i < dateLocales.length; i++) {
bits = (BitSet)available_locales.get(dateLocales[i]);
if (bits == null) {
bits = new BitSet(TYPE_LIMIT);
available_locales.put(allLocales[i], bits);
}
bits.set(TYPE_DATEFORMAT);
}
ULocale[] numLocales = NumberFormat.getAvailableULocales();
for (int i = 0; i < numLocales.length; i++) {
bits = (BitSet)available_locales.get(numLocales[i]);
if (bits == null) {
bits = new BitSet(TYPE_LIMIT);
available_locales.put(allLocales[i], bits);
}
bits.set(TYPE_NUMBERFORMAT);
}
ULocale[] collLocales = Collator.getAvailableULocales();
for (int i = 0; i < collLocales.length; i++) {
bits = (BitSet)available_locales.get(collLocales[i]);
if (bits == null) {
bits = new BitSet(TYPE_LIMIT);
available_locales.put(allLocales[i], bits);
}
bits.set(TYPE_COLLATOR);
}
ULocale[] brkLocales = BreakIterator.getAvailableULocales();
for (int i = 0; i < brkLocales.length; i++) {
bits = (BitSet)available_locales.get(brkLocales[i]);
bits.set(TYPE_BREAKITERATOR);
}
}
/** WARNING: All of this data is temporary, until we start importing from CLDR!!!
*
*/
private static final Map language_territory_hack_map = new HashMap();
private static final String[][] language_territory_hack = {
{"af", "ZA"},
{"am", "ET"},
{"ar", "SA"},
{"as", "IN"},
{"ay", "PE"},
{"az", "AZ"},
{"bal", "PK"},
{"be", "BY"},
{"bg", "BG"},
{"bn", "IN"},
{"bs", "BA"},
{"ca", "ES"},
{"ch", "MP"},
{"cpe", "SL"},
{"cs", "CZ"},
{"cy", "GB"},
{"da", "DK"},
{"de", "DE"},
{"dv", "MV"},
{"dz", "BT"},
{"el", "GR"},
{"en", "US"},
{"es", "ES"},
{"et", "EE"},
{"eu", "ES"},
{"fa", "IR"},
{"fi", "FI"},
{"fil", "PH"},
{"fj", "FJ"},
{"fo", "FO"},
{"fr", "FR"},
{"ga", "IE"},
{"gd", "GB"},
{"gl", "ES"},
{"gn", "PY"},
{"gu", "IN"},
{"gv", "GB"},
{"ha", "NG"},
{"he", "IL"},
{"hi", "IN"},
{"ho", "PG"},
{"hr", "HR"},
{"ht", "HT"},
{"hu", "HU"},
{"hy", "AM"},
{"id", "ID"},
{"is", "IS"},
{"it", "IT"},
{"ja", "JP"},
{"ka", "GE"},
{"kk", "KZ"},
{"kl", "GL"},
{"km", "KH"},
{"kn", "IN"},
{"ko", "KR"},
{"kok", "IN"},
{"ks", "IN"},
{"ku", "TR"},
{"ky", "KG"},
{"la", "VA"},
{"lb", "LU"},
{"ln", "CG"},
{"lo", "LA"},
{"lt", "LT"},
{"lv", "LV"},
{"mai", "IN"},
{"men", "GN"},
{"mg", "MG"},
{"mh", "MH"},
{"mk", "MK"},
{"ml", "IN"},
{"mn", "MN"},
{"mni", "IN"},
{"mo", "MD"},
{"mr", "IN"},
{"ms", "MY"},
{"mt", "MT"},
{"my", "MM"},
{"na", "NR"},
{"nb", "NO"},
{"nd", "ZA"},
{"ne", "NP"},
{"niu", "NU"},
{"nl", "NL"},
{"nn", "NO"},
{"no", "NO"},
{"nr", "ZA"},
{"nso", "ZA"},
{"ny", "MW"},
{"om", "KE"},
{"or", "IN"},
{"pa", "IN"},
{"pau", "PW"},
{"pl", "PL"},
{"ps", "PK"},
{"pt", "BR"},
{"qu", "PE"},
{"rn", "BI"},
{"ro", "RO"},
{"ru", "RU"},
{"rw", "RW"},
{"sd", "IN"},
{"sg", "CF"},
{"si", "LK"},
{"sk", "SK"},
{"sl", "SI"},
{"sm", "WS"},
{"so", "DJ"},
{"sq", "CS"},
{"sr", "CS"},
{"ss", "ZA"},
{"st", "ZA"},
{"sv", "SE"},
{"sw", "KE"},
{"ta", "IN"},
{"te", "IN"},
{"tem", "SL"},
{"tet", "TL"},
{"th", "TH"},
{"ti", "ET"},
{"tg", "TJ"},
{"tk", "TM"},
{"tkl", "TK"},
{"tvl", "TV"},
{"tl", "PH"},
{"tn", "ZA"},
{"to", "TO"},
{"tpi", "PG"},
{"tr", "TR"},
{"ts", "ZA"},
{"uk", "UA"},
{"ur", "IN"},
{"uz", "UZ"},
{"ve", "ZA"},
{"vi", "VN"},
{"wo", "SN"},
{"xh", "ZA"},
{"zh", "CN"},
{"zh_Hant", "TW"},
{"zu", "ZA"},
{"aa", "ET"},
{"byn", "ER"},
{"eo", "DE"},
{"gez", "ET"},
{"haw", "US"},
{"iu", "CA"},
{"kw", "GB"},
{"sa", "IN"},
{"sh", "HR"},
{"sid", "ET"},
{"syr", "SY"},
{"tig", "ER"},
{"tt", "RU"},
{"wal", "ET"}, };
static {
for (int i = 0; i < language_territory_hack.length; ++i) {
language_territory_hack_map.put(language_territory_hack[i][0],language_territory_hack[i][1]);
}
}
static final Map territory_tzid_hack_map = new HashMap();
static final String[][] territory_tzid_hack = {
{"AQ", "Antarctica/McMurdo"},
{"AR", "America/Buenos_Aires"},
{"AU", "Australia/Sydney"},
{"BR", "America/Sao_Paulo"},
{"CA", "America/Toronto"},
{"CD", "Africa/Kinshasa"},
{"CL", "America/Santiago"},
{"CN", "Asia/Shanghai"},
{"EC", "America/Guayaquil"},
{"ES", "Europe/Madrid"},
{"GB", "Europe/London"},
{"GL", "America/Godthab"},
{"ID", "Asia/Jakarta"},
{"ML", "Africa/Bamako"},
{"MX", "America/Mexico_City"},
{"MY", "Asia/Kuala_Lumpur"},
{"NZ", "Pacific/Auckland"},
{"PT", "Europe/Lisbon"},
{"RU", "Europe/Moscow"},
{"UA", "Europe/Kiev"},
{"US", "America/New_York"},
{"UZ", "Asia/Tashkent"},
{"PF", "Pacific/Tahiti"},
{"FM", "Pacific/Kosrae"},
{"KI", "Pacific/Tarawa"},
{"KZ", "Asia/Almaty"},
{"MH", "Pacific/Majuro"},
{"MN", "Asia/Ulaanbaatar"},
{"SJ", "Arctic/Longyearbyen"},
{"UM", "Pacific/Midway"},
};
static {
for (int i = 0; i < territory_tzid_hack.length; ++i) {
territory_tzid_hack_map.put(territory_tzid_hack[i][0],territory_tzid_hack[i][1]);
}
}
// Freezable implementation
private boolean frozen;
/**
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public boolean isFrozen() {
return frozen;
}
/**
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public Object freeze() {
frozen = true;
return this;
}
/**
* @draft ICU 3.6
* @provisional This API might change or be removed in a future release.
*/
public Object cloneAsThawed() {
try {
GlobalizationPreferences result = (GlobalizationPreferences) clone();
result.frozen = false;
return result;
} catch (CloneNotSupportedException e) {
// will always work
return null;
}
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/Currency.java 0000644 0001750 0001750 00000130142 11157074147 021147 0 ustar twerner twerner /**
*******************************************************************************
* Copyright (C) 2001-2009, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.io.Serializable;
import java.text.ChoiceFormat;
import java.text.ParsePosition;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.Vector;
import com.ibm.icu.impl.ICUCache;
import com.ibm.icu.impl.ICUDebug;
import com.ibm.icu.impl.ICUResourceBundle;
import com.ibm.icu.impl.SimpleCache;
import com.ibm.icu.impl.TextTrieMap;
/**
* A class encapsulating a currency, as defined by ISO 4217. A
* Currency object can be created given a Locale or
* given an ISO 4217 code. Once created, the Currency object
* can return various data necessary to its proper display:
*
*
*
* The DecimalFormat class uses these data to display
* currencies.
*
* theISOCode is null.
* @throws IllegalArgumentException if theISOCode is not a
* 3-letter alpha code.
* @stable ICU 2.2
*/
public static Currency getInstance(String theISOCode) {
if (theISOCode == null) {
throw new NullPointerException("The input currency code is null.");
}
boolean is3alpha = true;
if (theISOCode.length() != 3) {
is3alpha = false;
} else {
for (int i = 0; i < 3; i++) {
char ch = theISOCode.charAt(i);
if (ch < 'A' || (ch > 'Z' && ch < 'a') || ch > 'z') {
is3alpha = false;
break;
}
}
}
if (!is3alpha) {
throw new IllegalArgumentException(
"The input currency code is not 3-letter alphabetic code.");
}
return new Currency(theISOCode.toUpperCase(Locale.US));
}
/**
* Registers a new currency for the provided locale. The returned object
* is a key that can be used to unregister this currency object.
* @param currency the currency to register
* @param locale the ulocale under which to register the currency
* @return a registry key that can be used to unregister this currency
* @see #unregister
* @stable ICU 3.2
*/
public static Object registerInstance(Currency currency, ULocale locale) {
return getShim().registerInstance(currency, locale);
}
/**
* Unregister the currency associated with this key (obtained from
* registerInstance).
* @param registryKey the registry key returned from registerInstance
* @see #registerInstance
* @stable ICU 2.6
*/
public static boolean unregister(Object registryKey) {
if (registryKey == null) {
throw new IllegalArgumentException("registryKey must not be null");
}
if (shim == null) {
return false;
}
return shim.unregister(registryKey);
}
/**
* Return an array of the locales for which a currency
* is defined.
* @return an array of the available locales
* @stable ICU 2.2
*/
public static Locale[] getAvailableLocales() {
if (shim == null) {
return ICUResourceBundle.getAvailableLocales(ICUResourceBundle.ICU_BASE_NAME);
} else {
return shim.getAvailableLocales();
}
}
/**
* Return an array of the ulocales for which a currency
* is defined.
* @return an array of the available ulocales
* @stable ICU 3.2
*/
public static ULocale[] getAvailableULocales() {
if (shim == null) {
return ICUResourceBundle.getAvailableULocales(ICUResourceBundle.ICU_BASE_NAME);
} else {
return shim.getAvailableULocales();
}
}
// end registry stuff
/**
* Given a key and a locale, returns an array of string values in a preferred
* order that would make a difference. These are all and only those values where
* the open (creation) of the service with the locale formed from the input locale
* plus input keyword and that value has different behavior than creation with the
* input locale alone.
* @param key one of the keys supported by this service. For now, only
* "currency" is supported.
* @param locale the locale
* @param commonlyUsed if set to true it will return only commonly used values
* with the given locale in preferred order. Otherwise,
* it will return all the available values for the locale.
* @return an array of string values for the given key and the locale.
* @draft ICU 4.2
* @provisional This API might change or be removed in a future release.
*/
public static final String[] getKeywordValuesForLocale(String key, ULocale locale, boolean commonlyUsed) {
// Resolve region
String prefRegion = locale.getCountry();
if (prefRegion.length() == 0){
ULocale loc = ULocale.addLikelySubtags(locale);
prefRegion = loc.getCountry();
}
// Read values from supplementalData
LinkedList values = new LinkedList();
LinkedList otherValues = new LinkedList();
UResourceBundle bundle = UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "supplementalData");
bundle = bundle.get("CurrencyMap");
Enumeration keyEnum = bundle.getKeys();
boolean done = false;
while (keyEnum.hasMoreElements() && !done) {
String region = (String)keyEnum.nextElement();
boolean isPrefRegion = prefRegion.equals(region);
if (!isPrefRegion && commonlyUsed) {
// With commonlyUsed=true, we do not put
// currencies for other regions in the
// result list.
continue;
}
UResourceBundle regbndl = bundle.get(region);
for (int i = 0; i < regbndl.getSize(); i++) {
UResourceBundle curbndl = regbndl.get(i);
if (curbndl.getType() != UResourceBundle.TABLE) {
// Currently, an empty ARRAY is mixed in..
continue;
}
String curID = curbndl.getString("id");
boolean hasTo = false;
try {
UResourceBundle to = curbndl.get("to");
if (to != null) {
hasTo = true;
}
} catch (MissingResourceException e) {
// Do nothing here...
}
if (isPrefRegion && !hasTo && !values.contains(curID)) {
// Currently active currency for the target country
values.add(curID);
} else if (!otherValues.contains(curID) && !commonlyUsed){
otherValues.add(curID);
}
}
}
if (commonlyUsed) {
if (values.size() == 0) {
// This could happen if no valid region is supplied in the input
// locale. In this case, we use the CLDR's default.
return getKeywordValuesForLocale(key, new ULocale("und"), true);
}
} else {
// Consolidate the list
Iterator itr = otherValues.iterator();
while (itr.hasNext()) {
String curID = (String)itr.next();
if (!values.contains(curID)) {
values.add(curID);
}
}
}
return (String[]) values.toArray(new String[values.size()]);
}
/**
* Return a hashcode for this currency.
* @stable ICU 2.2
*/
public int hashCode() {
return isoCode.hashCode();
}
/**
* Return true if rhs is a Currency instance,
* is non-null, and has the same currency code.
* @stable ICU 2.2
*/
public boolean equals(Object rhs) {
if (rhs == null) return false;
if (rhs == this) return true;
try {
Currency c = (Currency) rhs;
return isoCode.equals(c.isoCode);
}
catch (ClassCastException e) {
return false;
}
}
/**
* Returns the ISO 4217 3-letter code for this currency object.
* @stable ICU 2.2
*/
public String getCurrencyCode() {
return isoCode;
}
/**
* Convenience and compatibility override of getName that
* requests the symbol name.
* @see #getName
* @stable ICU 3.4
*/
public String getSymbol() {
return getSymbol(ULocale.getDefault());
}
/**
* Convenience and compatibility override of getName that
* requests the symbol name.
* @param loc the Locale for the symbol
* @see #getName
* @stable ICU 3.4
*/
public String getSymbol(Locale loc) {
return getSymbol(ULocale.forLocale(loc));
}
/**
* Convenience and compatibility override of getName that
* requests the symbol name.
* @param uloc the ULocale for the symbol
* @see #getName
* @stable ICU 3.4
*/
public String getSymbol(ULocale uloc) {
return getName(uloc, SYMBOL_NAME, new boolean[1]);
}
/**
* Returns the display name for the given currency in the
* given locale.
* This is a convenient method for
* getName(ULocale, int, boolean[]);
* @stable ICU 3.2
*/
public String getName(Locale locale,
int nameStyle,
boolean[] isChoiceFormat) {
return getName(ULocale.forLocale(locale), nameStyle, isChoiceFormat);
}
/**
* Returns the display name for the given currency in the
* given locale. For example, the display name for the USD
* currency object in the en_US locale is "$".
* @param locale locale in which to display currency
* @param nameStyle selector for which kind of name to return.
* The nameStyle should be either SYMBOL_NAME or
* LONG_NAME. Otherwise, throw IllegalArgumentException.
* @param isChoiceFormat fill-in; isChoiceFormat[0] is set to true
* if the returned value is a ChoiceFormat pattern; otherwise it
* is set to false
* @return display string for this currency. If the resource data
* contains no entry for this currency, then the ISO 4217 code is
* returned. If isChoiceFormat[0] is true, then the result is a
* ChoiceFormat pattern. Otherwise it is a static string.
* @throws IllegalArgumentException if the nameStyle is not SYMBOL_NAME
* or LONG_NAME.
* @stable ICU 3.2
*/
public String getName(ULocale locale,
int nameStyle,
boolean[] isChoiceFormat) {
// Look up the Currencies resource for the given locale. The
// Currencies locale data looks like this:
//|en {
//| Currencies {
//| USD { "US$", "US Dollar" }
//| CHF { "Sw F", "Swiss Franc" }
//| INR { "=0#Rs|1#Re|1ULocale
* with the tag "@calendar=ethiopic".EthiopicCalendar using the current time
* in the default time zone with the default locale.
* @stable ICU 3.4
*/
public EthiopicCalendar() {
super();
}
/**
* Constructs a EthiopicCalendar based on the current time
* in the given time zone with the default locale.
*
* @param zone The time zone for the new calendar.
* @stable ICU 3.4
*/
public EthiopicCalendar(TimeZone zone) {
super(zone);
}
/**
* Constructs a EthiopicCalendar based on the current time
* in the default time zone with the given locale.
*
* @param aLocale The locale for the new calendar.
* @stable ICU 3.4
*/
public EthiopicCalendar(Locale aLocale) {
super(aLocale);
}
/**
* Constructs a EthiopicCalendar based on the current time
* in the default time zone with the given locale.
*
* @param locale The icu locale for the new calendar.
* @stable ICU 3.4
*/
public EthiopicCalendar(ULocale locale) {
super(locale);
}
/**
* Constructs a EthiopicCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone The time zone for the new calendar.
* @param aLocale The locale for the new calendar.
* @stable ICU 3.4
*/
public EthiopicCalendar(TimeZone zone, Locale aLocale) {
super(zone, aLocale);
}
/**
* Constructs a EthiopicCalendar based on the current time
* in the given time zone with the given locale.
*
* @param zone The time zone for the new calendar.
* @param locale The icu locale for the new calendar.
* @stable ICU 3.4
*/
public EthiopicCalendar(TimeZone zone, ULocale locale) {
super(zone, locale);
}
/**
* Constructs a EthiopicCalendar with the given date set
* in the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for Meskerem.
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @stable ICU 3.4
*/
public EthiopicCalendar(int year, int month, int date) {
super(year, month, date);
}
/**
* Constructs a EthiopicCalendar with the given date set
* in the default time zone with the default locale.
*
* @param date The date to which the new calendar is set.
* @stable ICU 3.4
*/
public EthiopicCalendar(Date date) {
super(date);
}
/**
* Constructs a EthiopicCalendar with the given date
* and time set for the default time zone with the default locale.
*
* @param year The value used to set the calendar's {@link #YEAR YEAR} time field.
* @param month The value used to set the calendar's {@link #MONTH MONTH} time field.
* The value is 0-based. e.g., 0 for Meskerem.
* @param date The value used to set the calendar's {@link #DATE DATE} time field.
* @param hour The value used to set the calendar's {@link #HOUR_OF_DAY HOUR_OF_DAY} time field.
* @param minute The value used to set the calendar's {@link #MINUTE MINUTE} time field.
* @param second The value used to set the calendar's {@link #SECOND SECOND} time field.
* @stable ICU 3.4
*/
public EthiopicCalendar(int year, int month, int date, int hour,
int minute, int second)
{
super(year, month, date, hour, minute, second);
}
/**
* {@inheritDoc}
* @return type of calendar
* @stable ICU 3.8
*/
public String getType() {
if (isAmeteAlemEra()) {
return "ethiopic-amete-alem";
}
return "ethiopic";
}
/**
* Set Alem or Mihret era.
*
* @param onOff Set Amete Alem era if true, otherwise set Amete Mihret era.
* @stable ICU 3.4
*/
public void setAmeteAlemEra(boolean onOff) {
eraType = onOff ? AMETE_ALEM_ERA : AMETE_MIHRET_ERA;
}
/**
* Return true if this calendar is set to the Amete Alem era.
*
* @return true if set to the Amete Alem era.
* @stable ICU 3.4
*/
public boolean isAmeteAlemEra() {
return (eraType == AMETE_ALEM_ERA);
}
/**
* {@inheritDoc}
* @internal
* @deprecated This API is ICU internal only.
*/
protected int handleGetExtendedYear() {
// Ethiopic calendar uses EXTENDED_YEAR aligned to
// Amelete Mihret year always.
int eyear;
if (newerField(EXTENDED_YEAR, YEAR) == EXTENDED_YEAR) {
eyear = internalGet(EXTENDED_YEAR, 1); // Default to year 1
} else if (isAmeteAlemEra()){
eyear = internalGet(YEAR, 1 + AMETE_MIHRET_DELTA)
- AMETE_MIHRET_DELTA; // Default to year 1 of Amelete Mihret
} else {
// The year defaults to the epoch start, the era to AMETE_MIHRET
int era = internalGet(ERA, AMETE_MIHRET);
if (era == AMETE_MIHRET) {
eyear = internalGet(YEAR, 1); // Default to year 1
} else {
eyear = internalGet(YEAR, 1) - AMETE_MIHRET_DELTA;
}
}
return eyear;
}
/**
* {@inheritDoc}
* @internal
* @deprecated This API is ICU internal only.
*/
protected void handleComputeFields(int julianDay) {
int era, year;
int[] fields = new int[3];
jdToCE(julianDay, getJDEpochOffset(), fields);
// fields[0] eyear
// fields[1] month
// fields[2] day
if (isAmeteAlemEra()) {
era = AMETE_ALEM;
year = fields[0] + AMETE_MIHRET_DELTA;
} else {
if (fields[0] > 0) {
era = AMETE_MIHRET;
year = fields[0];
} else {
era = AMETE_ALEM;
year = fields[0] + AMETE_MIHRET_DELTA;
}
}
internalSet(EXTENDED_YEAR, fields[0]);
internalSet(ERA, era);
internalSet(YEAR, year);
internalSet(MONTH, fields[1]);
internalSet(DAY_OF_MONTH, fields[2]);
internalSet(DAY_OF_YEAR, (30 * fields[1]) + fields[2]);
}
/**
* {@inheritDoc}
* @internal
* @deprecated This API is ICU internal only.
*/
protected int handleGetLimit(int field, int limitType) {
if (isAmeteAlemEra() && field == ERA) {
return 0; // Only one era in this mode, era is always 0
}
return super.handleGetLimit(field, limitType);
}
/**
* {@inheritDoc}
* @internal
* @deprecated This API is ICU internal only.
*/
protected int getJDEpochOffset() {
return JD_EPOCH_OFFSET_AMETE_MIHRET;
}
/**
* Convert an Ethiopic year, month, and day to a Julian day.
*
* @param year the year
* @param month the month
* @param date the day
*
* @draft ICU 3.4 (retain)
* @provisional This API might change or be removed in a future release.
*/
// The equivalent operation can be done by public Calendar API.
// This API was accidentally marked as @draft, but we have no good
// reason to keep this. For now, we leave it as is, but may be
// removed in future. 2008-03-21 yoshito
public static int EthiopicToJD(long year, int month, int date) {
return ceToJD(year, month, date, JD_EPOCH_OFFSET_AMETE_MIHRET);
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/CalendarServiceShim.java 0000644 0001750 0001750 00000007011 10775324256 023232 0 ustar twerner twerner /*
* Copyright (C) 2007-2008, International Business Machines
* Corporation and others. All Rights Reserved.
*/
package com.ibm.icu.util;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.Set;
import com.ibm.icu.impl.ICULocaleService;
import com.ibm.icu.impl.ICUResourceBundle;
import com.ibm.icu.impl.ICUService;
import com.ibm.icu.impl.ICULocaleService.LocaleKey;
import com.ibm.icu.impl.ICULocaleService.LocaleKeyFactory;
import com.ibm.icu.impl.ICUService.Factory;
import com.ibm.icu.impl.ICUService.Key;
import com.ibm.icu.util.Calendar.CalendarFactory;
class CalendarServiceShim extends Calendar.CalendarShim {
Locale[] getAvailableLocales() {
if (service.isDefault()) {
return ICUResourceBundle.getAvailableLocales(ICUResourceBundle.ICU_BASE_NAME);
}
return service.getAvailableLocales();
}
ULocale[] getAvailableULocales() {
if (service.isDefault()) {
return ICUResourceBundle.getAvailableULocales(ICUResourceBundle.ICU_BASE_NAME);
}
return service.getAvailableULocales();
}
private static final class CalFactory extends LocaleKeyFactory {
private CalendarFactory delegate;
CalFactory(CalendarFactory delegate) {
super(delegate.visible() ? VISIBLE : INVISIBLE);
this.delegate = delegate;
}
public Object create(Key key, ICUService srvc) {
if (handlesKey(key)) {
LocaleKey lkey = (LocaleKey)key;
ULocale loc = lkey.canonicalLocale();
Object result = delegate.createCalendar(loc);
if (result == null) {
result = srvc.getKey(key, null, this);
}
return result;
}
return null;
}
protected Set getSupportedIDs() {
return delegate.getSupportedLocaleNames();
}
}
Calendar createInstance(ULocale desiredLocale) {
ULocale[] actualLoc = new ULocale[1];
if (desiredLocale.equals(ULocale.ROOT)) {
desiredLocale = ULocale.ROOT;
}
Calendar cal = (Calendar)service.get(desiredLocale, actualLoc);
if (cal == null) {
throw new MissingResourceException("Unable to construct Calendar", "", "");
}
cal = (Calendar)cal.clone();
/* !!! TODO !!! actualLoc returned by service is not properly set.
* When this Calendar object is being created, cal.setLocale is called
* and proper actual locale is set at that time. Revisit this later.
* -yoshito
*/
/*
ULocale uloc = actualLoc[0];
cal.setLocale(uloc, uloc); // service make no distinction between actual and valid
*/
return cal;
}
Object registerFactory(CalendarFactory factory) {
return service.registerFactory(new CalFactory(factory));
}
boolean unregister(Object k) {
return service.unregisterFactory((Factory)k);
}
private static class CalService extends ICULocaleService {
CalService() {
super("Calendar");
class RBCalendarFactory extends ICUResourceBundleFactory {
protected Object handleCreate(ULocale loc, int kind, ICUService sercice) {
return Calendar.createInstance(loc);
}
}
this.registerFactory(new RBCalendarFactory());
markDefault();
}
}
private static ICULocaleService service = new CalService();
}
icu4j-4.2.1.1/src/com/ibm/icu/util/DateRule.java 0000644 0001750 0001750 00000005461 10666355147 021075 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2007, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.Date;
/**
* DateRule is an interface for calculating the date of an event.
* It supports both recurring events and those which occur only once.
* DateRule is useful for storing information about holidays,
* Daylight Savings Time rules, and other events such as meetings.
*
* @see SimpleDateRule
* @draft ICU 2.8 (retainAll)
* @provisional This API might change or be removed in a future release.
*/
public interface DateRule
{
/**
* Return the first occurrance of the event represented by this rule
* that is on or after the given start date.
*
* @param start Only occurrances on or after this date are returned.
*
* @return The date on which this event occurs, or null if it
* does not occur on or after the start date.
*
* @see #firstBetween
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
abstract public Date firstAfter(Date start);
/**
* Return the first occurrance of the event represented by this rule
* that is on or after the given start date and before the given
* end date.
*
* @param start Only occurrances on or after this date are returned.
* @param end Only occurrances before this date are returned.
*
* @return The date on which this event occurs, or null if it
* does not occur between the start and end dates.
*
* @see #firstAfter
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
abstract public Date firstBetween(Date start, Date end);
/**
* Checks whether this event occurs on the given date. This does
* not take time of day into account; instead it checks
* whether this event and the given date are on the same day.
* This is useful for applications such as determining whether a given
* day is a holiday.
*
* @param date The date to check.
* @return true if this event occurs on the given date.
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
abstract public boolean isOn(Date date);
/**
* Check whether this event occurs at least once between the two
* dates given.
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
abstract public boolean isBetween(Date start, Date end);
}
icu4j-4.2.1.1/src/com/ibm/icu/util/RuleBasedTimeZone.java 0000644 0001750 0001750 00000064150 11017153155 022673 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2007-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import com.ibm.icu.impl.Grego;
/**
* RuleBasedTimeZone is a concrete subclass of TimeZone that allows users to define
* custom historic time transition rules.
*
* @see com.ibm.icu.util.TimeZoneRule
*
* @stable ICU 3.8
*/
public class RuleBasedTimeZone extends BasicTimeZone {
private static final long serialVersionUID = 7580833058949327935L;
private final InitialTimeZoneRule initialRule;
private List historicRules;
private AnnualTimeZoneRule[] finalRules;
private transient List historicTransitions;
private transient boolean upToDate;
/**
* Constructs a RuleBasedTimeZone object with the ID and the
* InitialTimeZoneRule
*
* @param id The time zone ID.
* @param initialRule The initial time zone rule.
*
* @stable ICU 3.8
*/
public RuleBasedTimeZone(String id, InitialTimeZoneRule initialRule) {
super.setID(id);
this.initialRule = initialRule;
}
/**
* Adds the TimeZoneRule which represents time transitions.
* The TimeZoneRule must have start times, that is, the result
* of {@link com.ibm.icu.util.TimeZoneRule#isTransitionRule()} must be true.
* Otherwise, IllegalArgumentException is thrown.
*
* @param rule The TimeZoneRule.
*
* @stable ICU 3.8
*/
public void addTransitionRule(TimeZoneRule rule) {
if (!rule.isTransitionRule()) {
throw new IllegalArgumentException("Rule must be a transition rule");
}
if (rule instanceof AnnualTimeZoneRule
&& ((AnnualTimeZoneRule)rule).getEndYear() == AnnualTimeZoneRule.MAX_YEAR) {
// One of the final rules applicable in future forever
if (finalRules == null) {
finalRules = new AnnualTimeZoneRule[2];
finalRules[0] = (AnnualTimeZoneRule)rule;
} else if (finalRules[1] == null) {
finalRules[1] = (AnnualTimeZoneRule)rule;
} else {
// Only a pair of AnnualTimeZoneRule is allowed.
throw new IllegalStateException("Too many final rules");
}
} else {
// If this is not a final rule, add it to the historic rule list
if (historicRules == null) {
historicRules = new ArrayList();
}
historicRules.add(rule);
}
// Mark dirty, so transitions are recalculated when offset information is
// accessed next time.
upToDate = false;
}
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public int getOffset(int era, int year, int month, int day, int dayOfWeek,
int milliseconds) {
if (era == GregorianCalendar.BC) {
// Convert to extended year
year = 1 - year;
}
long time = Grego.fieldsToDay(year, month, day) * Grego.MILLIS_PER_DAY + milliseconds;
int[] offsets = new int[2];
getOffset(time, true, LOCAL_DST, LOCAL_STD, offsets);
return (offsets[0] + offsets[1]);
}
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public void getOffset(long time, boolean local, int[] offsets) {
getOffset(time, local, LOCAL_FORMER, LOCAL_LATTER, offsets);
}
/**
* {@inheritDoc}
* @internal
* @deprecated This API is ICU internal only.
*/
public void getOffsetFromLocal(long date,
int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets) {
getOffset(date, true, nonExistingTimeOpt, duplicatedTimeOpt, offsets);
}
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public int getRawOffset() {
// Note: This implementation returns standard GMT offset
// as of current time.
long now = System.currentTimeMillis();
int[] offsets = new int[2];
getOffset(now, false, offsets);
return offsets[0];
}
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public boolean inDaylightTime(Date date) {
int[] offsets = new int[2];
getOffset(date.getTime(), false, offsets);
return (offsets[1] != 0);
}
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
///CLOVER:OFF
public void setRawOffset(int offsetMillis) {
// TODO: Do nothing for now..
throw new UnsupportedOperationException("setRawOffset in RuleBasedTimeZone is not supported.");
}
///CLOVER:ON
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public boolean useDaylightTime() {
// Note: This implementation returns true when
// daylight saving time is used as of now or
// after the next transition.
long now = System.currentTimeMillis();
int[] offsets = new int[2];
getOffset(now, false, offsets);
if (offsets[1] != 0) {
return true;
}
// If DST is not used now, check if DST is used after the next transition
TimeZoneTransition tt = getNextTransition(now, false);
if (tt != null && tt.getTo().getDSTSavings() != 0) {
return true;
}
return false;
}
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public boolean hasSameRules(TimeZone other) {
if (!(other instanceof RuleBasedTimeZone)) {
// We cannot reasonably compare rules in different types
return false;
}
RuleBasedTimeZone otherRBTZ = (RuleBasedTimeZone)other;
// initial rule
if (!initialRule.isEquivalentTo(otherRBTZ.initialRule)) {
return false;
}
// final rules
if (finalRules != null && otherRBTZ.finalRules != null) {
for (int i = 0; i < finalRules.length; i++) {
if (finalRules[i] == null && otherRBTZ.finalRules[i] == null) {
continue;
}
if (finalRules[i] != null && otherRBTZ.finalRules[i] != null
&& finalRules[i].isEquivalentTo(otherRBTZ.finalRules[i])) {
continue;
}
return false;
}
} else if (finalRules != null || otherRBTZ.finalRules != null) {
return false;
}
// historic rules
if (historicRules != null && otherRBTZ.historicRules != null) {
if (historicRules.size() != otherRBTZ.historicRules.size()) {
return false;
}
Iterator it = historicRules.iterator();
while (it.hasNext()) {
TimeZoneRule rule = (TimeZoneRule)it.next();
Iterator oit = otherRBTZ.historicRules.iterator();
boolean foundSameRule = false;
while (oit.hasNext()) {
TimeZoneRule orule = (TimeZoneRule)oit.next();
if (rule.isEquivalentTo(orule)) {
foundSameRule = true;
break;
}
}
if (!foundSameRule) {
return false;
}
}
} else if (historicRules != null || otherRBTZ.historicRules != null) {
return false;
}
return true;
}
// BasicTimeZone methods
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public TimeZoneRule[] getTimeZoneRules() {
int size = 1;
if (historicRules != null) {
size += historicRules.size();
}
if (finalRules != null) {
if (finalRules[1] != null) {
size += 2;
} else {
size++;
}
}
TimeZoneRule[] rules = new TimeZoneRule[size];
rules[0] = initialRule;
int idx = 1;
if (historicRules != null) {
for (; idx < historicRules.size() + 1; idx++) {
rules[idx] = (TimeZoneRule)historicRules.get(idx - 1);
}
}
if (finalRules != null) {
rules[idx++] = finalRules[0];
if (finalRules[1] != null) {
rules[idx] = finalRules[1];
}
}
return rules;
}
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public TimeZoneTransition getNextTransition(long base, boolean inclusive) {
complete();
if (historicTransitions == null) {
return null;
}
boolean isFinal = false;
TimeZoneTransition result = null;
TimeZoneTransition tzt = (TimeZoneTransition)historicTransitions.get(0);
long tt = tzt.getTime();
if (tt > base || (inclusive && tt == base)) {
result = tzt;
} else {
int idx = historicTransitions.size() - 1;
tzt = (TimeZoneTransition)historicTransitions.get(idx);
tt = tzt.getTime();
if (inclusive && tt == base) {
result = tzt;
} else if (tt <= base) {
if (finalRules != null) {
// Find a transion time with finalRules
Date start0 = finalRules[0].getNextStart(base,
finalRules[1].getRawOffset(), finalRules[1].getDSTSavings(), inclusive);
Date start1 = finalRules[1].getNextStart(base,
finalRules[0].getRawOffset(), finalRules[0].getDSTSavings(), inclusive);
if (start1.after(start0)) {
tzt = new TimeZoneTransition(start0.getTime(), finalRules[1], finalRules[0]);
} else {
tzt = new TimeZoneTransition(start1.getTime(), finalRules[0], finalRules[1]);
}
result = tzt;
isFinal = true;
} else {
return null;
}
} else {
// Find a transition within the historic transitions
idx--;
TimeZoneTransition prev = tzt;
while (idx > 0) {
tzt = (TimeZoneTransition)historicTransitions.get(idx);
tt = tzt.getTime();
if (tt < base || (!inclusive && tt == base)) {
break;
}
idx--;
prev = tzt;
}
result = prev;
}
}
if (result != null) {
// For now, this implementation ignore transitions with only zone name changes.
TimeZoneRule from = result.getFrom();
TimeZoneRule to = result.getTo();
if (from.getRawOffset() == to.getRawOffset()
&& from.getDSTSavings() == to.getDSTSavings()) {
// No offset changes. Try next one if not final
if (isFinal) {
return null;
} else {
result = getNextTransition(result.getTime(), false /* always exclusive */);
}
}
}
return result;
}
/**
* {@inheritDoc}
*
* @stable ICU 3.8
*/
public TimeZoneTransition getPreviousTransition(long base, boolean inclusive) {
complete();
if (historicTransitions == null) {
return null;
}
TimeZoneTransition result = null;
TimeZoneTransition tzt = (TimeZoneTransition)historicTransitions.get(0);
long tt = tzt.getTime();
if (inclusive && tt == base) {
result = tzt;
} else if (tt >= base) {
return null;
} else {
int idx = historicTransitions.size() - 1;
tzt = (TimeZoneTransition)historicTransitions.get(idx);
tt = tzt.getTime();
if (inclusive && tt == base) {
result = tzt;
} else if (tt < base) {
if (finalRules != null) {
// Find a transion time with finalRules
Date start0 = finalRules[0].getPreviousStart(base,
finalRules[1].getRawOffset(), finalRules[1].getDSTSavings(), inclusive);
Date start1 = finalRules[1].getPreviousStart(base,
finalRules[0].getRawOffset(), finalRules[0].getDSTSavings(), inclusive);
if (start1.before(start0)) {
tzt = new TimeZoneTransition(start0.getTime(), finalRules[1], finalRules[0]);
} else {
tzt = new TimeZoneTransition(start1.getTime(), finalRules[0], finalRules[1]);
}
}
result = tzt;
} else {
// Find a transition within the historic transitions
idx--;
while (idx >= 0) {
tzt = (TimeZoneTransition)historicTransitions.get(idx);
tt = tzt.getTime();
if (tt < base || (inclusive && tt == base)) {
break;
}
idx--;
}
result = tzt;
}
}
if (result != null) {
// For now, this implementation ignore transitions with only zone name changes.
TimeZoneRule from = result.getFrom();
TimeZoneRule to = result.getTo();
if (from.getRawOffset() == to.getRawOffset()
&& from.getDSTSavings() == to.getDSTSavings()) {
// No offset changes. Try previous one
result = getPreviousTransition(result.getTime(), false /* always exclusive */);
}
}
return result;
}
/**
* {@inheritDoc}
* @stable ICU 3.8
*/
public Object clone() {
RuleBasedTimeZone other = (RuleBasedTimeZone)super.clone();
if (historicRules != null) {
other.historicRules = (List)((ArrayList)historicRules).clone(); // rules are immutable
}
if (finalRules != null) {
other.finalRules = (AnnualTimeZoneRule[])finalRules.clone();
}
return other;
}
// private stuff
/*
* Resolve historic transition times and update fields used for offset
* calculation.
*/
private void complete() {
if (upToDate) {
// No rules were added since last time.
return;
}
// Make sure either no final rules or a pair of AnnualTimeZoneRules
// are available.
if (finalRules != null && finalRules[1] == null) {
throw new IllegalStateException("Incomplete final rules");
}
// Create a TimezoneTransition and add to the list
if (historicRules != null || finalRules != null) {
TimeZoneRule curRule = initialRule;
long lastTransitionTime = Grego.MIN_MILLIS;
// Build the transition array which represents historical time zone
// transitions.
if (historicRules != null) {
BitSet done = new BitSet(historicRules.size()); // for skipping rules already processed
while (true) {
int curStdOffset = curRule.getRawOffset();
int curDstSavings = curRule.getDSTSavings();
long nextTransitionTime = Grego.MAX_MILLIS;
TimeZoneRule nextRule = null;
Date d;
long tt;
for (int i = 0; i < historicRules.size(); i++) {
if (done.get(i)) {
continue;
}
TimeZoneRule r = (TimeZoneRule)historicRules.get(i);
d = r.getNextStart(lastTransitionTime, curStdOffset, curDstSavings, false);
if (d == null) {
// No more transitions from this rule - skip this rule next time
done.set(i);
} else {
if (r == curRule ||
(r.getName().equals(curRule.getName())
&& r.getRawOffset() == curRule.getRawOffset()
&& r.getDSTSavings() == curRule.getDSTSavings())) {
continue;
}
tt = d.getTime();
if (tt < nextTransitionTime) {
nextTransitionTime = tt;
nextRule = r;
}
}
}
if (nextRule == null) {
// Check if all historic rules are done
boolean bDoneAll = true;
for (int j = 0; j < historicRules.size(); j++) {
if (!done.get(j)) {
bDoneAll = false;
break;
}
}
if (bDoneAll) {
break;
}
}
if (finalRules != null) {
// Check if one of final rules has earlier transition date
for (int i = 0; i < 2 /* finalRules.length */; i++) {
if (finalRules[i] == curRule) {
continue;
}
d = finalRules[i].getNextStart(lastTransitionTime, curStdOffset, curDstSavings, false);
if (d != null) {
tt = d.getTime();
if (tt < nextTransitionTime) {
nextTransitionTime = tt;
nextRule = finalRules[i];
}
}
}
}
if (nextRule == null) {
// Nothing more
break;
}
if (historicTransitions == null) {
historicTransitions = new ArrayList();
}
historicTransitions.add(new TimeZoneTransition(nextTransitionTime, curRule, nextRule));
lastTransitionTime = nextTransitionTime;
curRule = nextRule;
}
}
if (finalRules != null) {
if (historicTransitions == null) {
historicTransitions = new ArrayList();
}
// Append the first transition for each
Date d0 = finalRules[0].getNextStart(lastTransitionTime, curRule.getRawOffset(), curRule.getDSTSavings(), false);
Date d1 = finalRules[1].getNextStart(lastTransitionTime, curRule.getRawOffset(), curRule.getDSTSavings(), false);
if (d1.after(d0)) {
historicTransitions.add(new TimeZoneTransition(d0.getTime(), curRule, finalRules[0]));
d1 = finalRules[1].getNextStart(d0.getTime(), finalRules[0].getRawOffset(), finalRules[0].getDSTSavings(), false);
historicTransitions.add(new TimeZoneTransition(d1.getTime(), finalRules[0], finalRules[1]));
} else {
historicTransitions.add(new TimeZoneTransition(d1.getTime(), curRule, finalRules[1]));
d0 = finalRules[0].getNextStart(d1.getTime(), finalRules[1].getRawOffset(), finalRules[1].getDSTSavings(), false);
historicTransitions.add(new TimeZoneTransition(d0.getTime(), finalRules[1], finalRules[0]));
}
}
}
upToDate = true;
}
/*
* getOffset internal implementation
*/
private void getOffset(long time, boolean local, int NonExistingTimeOpt, int DuplicatedTimeOpt, int[] offsets) {
complete();
TimeZoneRule rule;
if (historicTransitions == null) {
rule = initialRule;
} else {
long tstart = getTransitionTime((TimeZoneTransition)historicTransitions.get(0),
local, NonExistingTimeOpt, DuplicatedTimeOpt);
if (time < tstart) {
rule = initialRule;
} else {
int idx = historicTransitions.size() - 1;
long tend = getTransitionTime((TimeZoneTransition)historicTransitions.get(idx),
local, NonExistingTimeOpt, DuplicatedTimeOpt);
if (time > tend) {
if (finalRules != null) {
rule = findRuleInFinal(time, local, NonExistingTimeOpt, DuplicatedTimeOpt);
} else {
// no final rule, use the last rule
rule = ((TimeZoneTransition)historicTransitions.get(idx)).getTo();
}
} else {
// Find a historical transition
while (idx >= 0) {
if (time >= getTransitionTime((TimeZoneTransition)historicTransitions.get(idx),
local, NonExistingTimeOpt, DuplicatedTimeOpt)) {
break;
}
idx--;
}
rule = ((TimeZoneTransition)historicTransitions.get(idx)).getTo();
}
}
}
offsets[0] = rule.getRawOffset();
offsets[1] = rule.getDSTSavings();
}
/*
* Find a time zone rule applicable to the specified time
*/
private TimeZoneRule findRuleInFinal(long time, boolean local, int NonExistingTimeOpt, int DuplicatedTimeOpt) {
if (finalRules == null || finalRules.length != 2 || finalRules[0] == null || finalRules[1] == null) {
return null;
}
Date start0, start1;
long base;
int localDelta;
base = time;
if (local) {
localDelta = getLocalDelta(finalRules[1].getRawOffset(), finalRules[1].getDSTSavings(),
finalRules[0].getRawOffset(), finalRules[0].getDSTSavings(),
NonExistingTimeOpt, DuplicatedTimeOpt);
base -= localDelta;
}
start0 = finalRules[0].getPreviousStart(base, finalRules[1].getRawOffset(), finalRules[1].getDSTSavings(), true);
base = time;
if (local) {
localDelta = getLocalDelta(finalRules[0].getRawOffset(), finalRules[0].getDSTSavings(),
finalRules[1].getRawOffset(), finalRules[1].getDSTSavings(),
NonExistingTimeOpt, DuplicatedTimeOpt);
base -= localDelta;
}
start1 = finalRules[1].getPreviousStart(base, finalRules[0].getRawOffset(), finalRules[0].getDSTSavings(), true);
return start0.after(start1) ? finalRules[0] : finalRules[1];
}
/*
* Get the transition time in local wall clock
*/
private static long getTransitionTime(TimeZoneTransition tzt, boolean local,
int NonExistingTimeOpt, int DuplicatedTimeOpt) {
long time = tzt.getTime();
if (local) {
time += getLocalDelta(tzt.getFrom().getRawOffset(), tzt.getFrom().getDSTSavings(),
tzt.getTo().getRawOffset(), tzt.getTo().getDSTSavings(),
NonExistingTimeOpt, DuplicatedTimeOpt);
}
return time;
}
/*
* Returns amount of local time adjustment used for checking rule transitions
*/
private static int getLocalDelta(int rawBefore, int dstBefore, int rawAfter, int dstAfter,
int NonExistingTimeOpt, int DuplicatedTimeOpt) {
int delta = 0;
int offsetBefore = rawBefore + dstBefore;
int offsetAfter = rawAfter + dstAfter;
boolean dstToStd = (dstBefore != 0) && (dstAfter == 0);
boolean stdToDst = (dstBefore == 0) && (dstAfter != 0);
if (offsetAfter - offsetBefore >= 0) {
// Positive transition, which makes a non-existing local time range
if (((NonExistingTimeOpt & STD_DST_MASK) == LOCAL_STD && dstToStd)
|| ((NonExistingTimeOpt & STD_DST_MASK) == LOCAL_DST && stdToDst)) {
delta = offsetBefore;
} else if (((NonExistingTimeOpt & STD_DST_MASK) == LOCAL_STD && stdToDst)
|| ((NonExistingTimeOpt & STD_DST_MASK) == LOCAL_DST && dstToStd)) {
delta = offsetAfter;
} else if ((NonExistingTimeOpt & FORMER_LATTER_MASK) == LOCAL_LATTER) {
delta = offsetBefore;
} else {
// Interprets the time with rule before the transition,
// default for non-existing time range
delta = offsetAfter;
}
} else {
// Negative transition, which makes a duplicated local time range
if (((DuplicatedTimeOpt & STD_DST_MASK) == LOCAL_STD && dstToStd)
|| ((DuplicatedTimeOpt & STD_DST_MASK) == LOCAL_DST && stdToDst)) {
delta = offsetAfter;
} else if (((DuplicatedTimeOpt & STD_DST_MASK) == LOCAL_STD && stdToDst)
|| ((DuplicatedTimeOpt & STD_DST_MASK) == LOCAL_DST && dstToStd)) {
delta = offsetBefore;
} else if ((DuplicatedTimeOpt & FORMER_LATTER_MASK) == LOCAL_FORMER) {
delta = offsetBefore;
} else {
// Interprets the time with rule after the transition,
// default for duplicated local time range
delta = offsetAfter;
}
}
return delta;
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/HebrewHoliday.java 0000644 0001750 0001750 00000015212 10666355147 022111 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2006, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
/**
* @draft ICU 2.8 (retainAll)
* @provisional This API might change or be removed in a future release.
*/
public class HebrewHoliday extends Holiday
{
private static final HebrewCalendar gCalendar = new HebrewCalendar();
/**
* Construct a holiday defined in reference to the Hebrew calendar.
*
* @param name The name of the holiday
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public HebrewHoliday(int month, int date, String name)
{
this(month, date, 1, name);
}
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public HebrewHoliday(int month, int date, int length, String name)
{
super(name, new SimpleDateRule(month, date, gCalendar));
}
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday ROSH_HASHANAH = new HebrewHoliday(HebrewCalendar.TISHRI, 1, 2, "Rosh Hashanah");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday GEDALIAH = new HebrewHoliday(HebrewCalendar.TISHRI, 3, "Fast of Gedaliah");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday YOM_KIPPUR = new HebrewHoliday(HebrewCalendar.TISHRI, 10, "Yom Kippur");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday SUKKOT = new HebrewHoliday(HebrewCalendar.TISHRI, 15, 6, "Sukkot");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday HOSHANAH_RABBAH = new HebrewHoliday(HebrewCalendar.TISHRI, 21, "Hoshanah Rabbah");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday SHEMINI_ATZERET = new HebrewHoliday(HebrewCalendar.TISHRI, 22, "Shemini Atzeret");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday SIMCHAT_TORAH = new HebrewHoliday(HebrewCalendar.TISHRI, 23, "Simchat Torah");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday HANUKKAH = new HebrewHoliday(HebrewCalendar.KISLEV, 25, "Hanukkah");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday TEVET_10 = new HebrewHoliday(HebrewCalendar.TEVET, 10, "Fast of Tevet 10");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday TU_BSHEVAT = new HebrewHoliday(HebrewCalendar.SHEVAT, 15, "Tu B'Shevat");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday ESTHER = new HebrewHoliday(HebrewCalendar.ADAR, 13, "Fast of Esther");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday PURIM = new HebrewHoliday(HebrewCalendar.ADAR, 14, "Purim");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday SHUSHAN_PURIM = new HebrewHoliday(HebrewCalendar.ADAR, 15, "Shushan Purim");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday PASSOVER = new HebrewHoliday(HebrewCalendar.NISAN, 15, 8, "Passover");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday YOM_HASHOAH = new HebrewHoliday(HebrewCalendar.NISAN, 27, "Yom Hashoah");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday YOM_HAZIKARON = new HebrewHoliday(HebrewCalendar.IYAR, 4, "Yom Hazikaron");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday YOM_HAATZMAUT = new HebrewHoliday(HebrewCalendar.IYAR, 5, "Yom Ha'Atzmaut");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday PESACH_SHEINI = new HebrewHoliday(HebrewCalendar.IYAR, 14, "Pesach Sheini");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday LAG_BOMER = new HebrewHoliday(HebrewCalendar.IYAR, 18, "Lab B'Omer");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday YOM_YERUSHALAYIM = new HebrewHoliday(HebrewCalendar.IYAR, 28, "Yom Yerushalayim");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday SHAVUOT = new HebrewHoliday(HebrewCalendar.SIVAN, 6, 2, "Shavuot");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday TAMMUZ_17 = new HebrewHoliday(HebrewCalendar.TAMUZ, 17, "Fast of Tammuz 17");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday TISHA_BAV = new HebrewHoliday(HebrewCalendar.AV, 9, "Fast of Tisha B'Av");
/**
* @draft ICU 2.8
* @provisional This API might change or be removed in a future release.
*/
public static HebrewHoliday SELIHOT = new HebrewHoliday(HebrewCalendar.ELUL, 21, "Selihot");
}
icu4j-4.2.1.1/src/com/ibm/icu/util/CurrencyAmount.java 0000644 0001750 0001750 00000002670 10501435666 022336 0 ustar twerner twerner /*
**********************************************************************
* Copyright (c) 2004-2006, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Author: Alan Liu
* Created: April 12, 2004
* Since: ICU 3.0
**********************************************************************
*/
package com.ibm.icu.util;
import java.lang.Number;
/**
* An amount of currency, consisting of a Number and a Currency.
* CurrencyAmount objects are immutable.
*
* @see java.lang.Number
* @see Currency
* @author Alan Liu
* @stable ICU 3.0
*/
public class CurrencyAmount extends Measure {
/**
* Constructs a new object given a number and a currency.
* @param number the number
* @param currency the currency
* @stable ICU 3.0
*/
public CurrencyAmount(Number number, Currency currency) {
super(number, currency);
}
/**
* Constructs a new object given a double value and a currency.
* @param number a double value
* @param currency the currency
* @stable ICU 3.0
*/
public CurrencyAmount(double number, Currency currency) {
super(new Double(number), currency);
}
/**
* Returns the currency of this object.
* @return this object's Currency
* @stable ICU 3.0
*/
public Currency getCurrency() {
return (Currency) getUnit();
}
}
icu4j-4.2.1.1/src/com/ibm/icu/util/BasicTimeZone.java 0000644 0001750 0001750 00000062542 11323140624 022046 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2007-2010, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.util;
import java.util.BitSet;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import com.ibm.icu.impl.Grego;
/**
* BasicTimeZone is an abstract class extending TimeZone.
* This class provides some additional methods to access time zone transitions
* and rules. All ICU TimeZone concrete subclasses extend this
* class.
*
* @see com.ibm.icu.util.TimeZoneRule
* @see com.ibm.icu.util.TimeZoneTransition
*
* @stable ICU 3.8
*/
public abstract class BasicTimeZone extends TimeZone {
private static final long serialVersionUID = -3204278532246180932L;
private static final long MILLIS_PER_YEAR = 365*24*60*60*1000L;
/**
* Gets the first time zone transition after the base time.
*
* @param base The base time.
* @param inclusive Whether the base time is inclusive or not.
*
* @return A Date holding the first time zone transition time
* after the given base time, or null if no time zone transitions
* are available after the base time.
*
* @stable ICU 3.8
*/
public abstract TimeZoneTransition getNextTransition(long base, boolean inclusive);
/**
* Gets the last time zone transition before the base time.
*
* @param base The base time.
* @param inclusive Whether the base time is inclusive or not.
*
* @return A Date holding the last time zone transition time
* before the given base time, or null if no time zone transitions
* are available before the base time.
*
* @stable ICU 3.8
*/
public abstract TimeZoneTransition getPreviousTransition(long base, boolean inclusive);
/**
* Checks if the time zone has equivalent transitions in the time range.
* This method returns true when all of transition times, from/to standard
* offsets and DST savings used by this time zone match the other in the
* time range.
*
* @param tz The instance of TimeZone
* @param start The start time of the evaluated time range (inclusive)
* @param end The end time of the evaluated time range (inclusive)
*
* @return true if the other time zone has the equivalent transitions in the
* time range. When tz is not a BasicTimeZone, this method
* returns false.
*
* @stable ICU 3.8
*/
public boolean hasEquivalentTransitions(TimeZone tz, long start, long end) {
return hasEquivalentTransitions(tz, start, end, false);
}
/**
* Checks if the time zone has equivalent transitions in the time range.
* This method returns true when all of transition times, from/to standard
* offsets and DST savings used by this time zone match the other in the
* time range.
*
* @param tz The instance of TimeZone
* @param start The start time of the evaluated time range (inclusive)
* @param end The end time of the evaluated time range (inclusive)
* @param ignoreDstAmount
* When true, any transitions with only daylight saving amount
* changes will be ignored, except either of them is zero.
* For example, a transition from rawoffset 3:00/dstsavings 1:00
* to rawoffset 2:00/dstsavings 2:00 is excluded from the comparison,
* but a transtion from rawoffset 2:00/dstsavings 1:00 to
* rawoffset 3:00/dstsavings 0:00 is included.
*
* @return true if the other time zone has the equivalent transitions in the
* time range. When tz is not a BasicTimeZone, this method
* returns false.
*
* @stable ICU 3.8
*/
public boolean hasEquivalentTransitions(TimeZone tz, long start, long end, boolean ignoreDstAmount) {
if (hasSameRules(tz)) {
return true;
}
if (!(tz instanceof BasicTimeZone)) {
return false;
}
// Check the offsets at the start time
int[] offsets1 = new int[2];
int[] offsets2 = new int[2];
getOffset(start, false, offsets1);
tz.getOffset(start, false, offsets2);
if (ignoreDstAmount) {
if ((offsets1[0] + offsets1[1] != offsets2[0] + offsets2[1])
|| (offsets1[1] != 0 && offsets2[1] == 0)
|| (offsets1[1] == 0 && offsets2[1] != 0)) {
return false;
}
} else {
if (offsets1[0] != offsets2[0] || offsets1[1] != offsets2[1]) {
return false;
}
}
// Check transitions in the range
long time = start;
while (true) {
TimeZoneTransition tr1 = getNextTransition(time, false);
TimeZoneTransition tr2 = ((BasicTimeZone)tz).getNextTransition(time, false);
if (ignoreDstAmount) {
// Skip a transition which only differ the amount of DST savings
if (tr1 != null
&& (tr1.getFrom().getRawOffset() + tr1.getFrom().getDSTSavings()
== tr1.getTo().getRawOffset() + tr1.getTo().getDSTSavings())
&& (tr1.getFrom().getDSTSavings() != 0 && tr1.getTo().getDSTSavings() != 0)) {
tr1 = getNextTransition(tr1.getTime(), false);
}
if (tr2 != null
&& (tr2.getFrom().getRawOffset() + tr2.getFrom().getDSTSavings()
== tr2.getTo().getRawOffset() + tr2.getTo().getDSTSavings())
&& (tr2.getFrom().getDSTSavings() != 0 && tr2.getTo().getDSTSavings() != 0)) {
tr2 = getNextTransition(tr2.getTime(), false);
}
}
boolean inRange1 = false;
boolean inRange2 = false;
if (tr1 != null) {
if (tr1.getTime() <= end) {
inRange1 = true;
}
}
if (tr2 != null) {
if (tr2.getTime() <= end) {
inRange2 = true;
}
}
if (!inRange1 && !inRange2) {
// No more transition in the range
break;
}
if (!inRange1 || !inRange2) {
return false;
}
if (tr1.getTime() != tr2.getTime()) {
return false;
}
if (ignoreDstAmount) {
if (tr1.getTo().getRawOffset() + tr1.getTo().getDSTSavings()
!= tr2.getTo().getRawOffset() + tr2.getTo().getDSTSavings()
|| tr1.getTo().getDSTSavings() != 0 && tr2.getTo().getDSTSavings() == 0
|| tr1.getTo().getDSTSavings() == 0 && tr2.getTo().getDSTSavings() != 0) {
return false;
}
} else {
if (tr1.getTo().getRawOffset() != tr2.getTo().getRawOffset() ||
tr1.getTo().getDSTSavings() != tr2.getTo().getDSTSavings()) {
return false;
}
}
time = tr1.getTime();
}
return true;
}
/**
* Gets the array of TimeZoneRule which represents the rule
* of this time zone object. The first element in the result array will
* be the InitialTimeZoneRule instance for the initial rule.
* The rest will be either AnnualTimeZoneRule or
* TimeArrayTimeZoneRule instances representing transitions.
*
* @return The array of TimeZoneRule which represents this
* time zone.
*
* @stable ICU 3.8
*/
public abstract TimeZoneRule[] getTimeZoneRules();
/**
* Gets the array of TimeZoneRule which represents the rule
* of this time zone object since the specified start time. The first
* element in the result array will be the InitialTimeZoneRule
* instance for the initial rule. The rest will be either
* AnnualTimeZoneRule or TimeArrayTimeZoneRule
* instances representing transitions.
*
* @param start The start time (inclusive).
* @return The array of TimeZoneRule which represents this
* time zone since the start time.
*
* @stable ICU 3.8
*/
public TimeZoneRule[] getTimeZoneRules(long start) {
TimeZoneRule[] all = getTimeZoneRules();
TimeZoneTransition tzt = getPreviousTransition(start, true);
if (tzt == null) {
// No need to filter out rules only applicable to time before the start
return all;
}
BitSet isProcessed = new BitSet(all.length);
List filteredRules = new LinkedList();
// Create initial rule
TimeZoneRule initial = new InitialTimeZoneRule(tzt.getTo().getName(),
tzt.getTo().getRawOffset(), tzt.getTo().getDSTSavings());
filteredRules.add(initial);
isProcessed.set(0);
// Mark rules which does not need to be processed
for (int i = 1; i < all.length; i++) {
Date d = all[i].getNextStart(start, initial.getRawOffset(),
initial.getDSTSavings(), false);
if (d == null) {
isProcessed.set(i);
}
}
long time = start;
boolean bFinalStd = false, bFinalDst = false;
while(!bFinalStd || !bFinalDst) {
tzt = getNextTransition(time, false);
if (tzt == null) {
break;
}
time = tzt.getTime();
TimeZoneRule toRule = tzt.getTo();
int ruleIdx = 1;
for (; ruleIdx < all.length; ruleIdx++) {
if (all[ruleIdx].equals(toRule)) {
break;
}
}
if (ruleIdx >= all.length) {
throw new IllegalStateException("The rule was not found");
}
if (isProcessed.get(ruleIdx)) {
continue;
}
if (toRule instanceof TimeArrayTimeZoneRule) {
TimeArrayTimeZoneRule tar = (TimeArrayTimeZoneRule)toRule;
// Get the previous raw offset and DST savings before the very first start time
long t = start;
while(true) {
tzt = getNextTransition(t, false);
if (tzt == null) {
break;
}
if (tzt.getTo().equals(tar)) {
break;
}
t = tzt.getTime();
}
if (tzt != null) {
// Check if the entire start times to be added
Date firstStart = tar.getFirstStart(tzt.getFrom().getRawOffset(),
tzt.getFrom().getDSTSavings());
if (firstStart.getTime() > start) {
// Just add the rule as is
filteredRules.add(tar);
} else {
// Collect transitions after the start time
long[] times = tar.getStartTimes();
int timeType = tar.getTimeType();
int idx;
for (idx = 0; idx < times.length; idx++) {
t = times[idx];
if (timeType == DateTimeRule.STANDARD_TIME) {
t -= tzt.getFrom().getRawOffset();
}
if (timeType == DateTimeRule.WALL_TIME) {
t -= tzt.getFrom().getDSTSavings();
}
if (t > start) {
break;
}
}
int asize = times.length - idx;
if (asize > 0) {
long[] newtimes = new long[asize];
System.arraycopy(times, idx, newtimes, 0, asize);
TimeArrayTimeZoneRule newtar = new TimeArrayTimeZoneRule(
tar.getName(), tar.getRawOffset(), tar.getDSTSavings(),
newtimes, tar.getTimeType());
filteredRules.add(newtar);
}
}
}
} else if (toRule instanceof AnnualTimeZoneRule) {
AnnualTimeZoneRule ar = (AnnualTimeZoneRule)toRule;
Date firstStart = ar.getFirstStart(tzt.getFrom().getRawOffset(),
tzt.getFrom().getDSTSavings());
if (firstStart.getTime() == tzt.getTime()) {
// Just add the rule as is
filteredRules.add(ar);
} else {
// Calculate the transition year
int[] dfields = new int[6];
Grego.timeToFields(tzt.getTime(), dfields);
// Recreate the rule
AnnualTimeZoneRule newar = new AnnualTimeZoneRule(ar.getName(),
ar.getRawOffset(), ar.getDSTSavings(),
ar.getRule(), dfields[0], ar.getEndYear());
filteredRules.add(newar);
}
// Check if this is a final rule
if (ar.getEndYear() == AnnualTimeZoneRule.MAX_YEAR) {
// After both final standard and dst rule are processed,
// exit this while loop.
if (ar.getDSTSavings() == 0) {
bFinalStd = true;
} else {
bFinalDst = true;
}
}
}
isProcessed.set(ruleIdx);
}
TimeZoneRule[] rules = new TimeZoneRule[filteredRules.size()];
filteredRules.toArray(rules);
return rules;
}
/**
* Gets the array of TimeZoneRule which represents the rule of
* this time zone object near the specified date. Some applications are not
* capable to handle historic time zone rule changes. Also some applications
* can only handle certain type of rule definitions. This method returns
* either a single InitialTimeZoneRule if this time zone does not
* have any daylight saving time within 1 year from the specified time, or a
* pair of AnnualTimeZoneRule whose rule type is
* DateTimeRule.DOW for date and DateTimeRule.WALL_TIME
* for time with a single InitialTimeZoneRule representing the
* initial time, when this time zone observes daylight saving time near the
* specified date. Thus, the result may be only valid for dates around the
* specified date.
*
* @param date The date to be used for TimeZoneRule extraction.
* @return The array of TimeZoneRule, either a single
* InitialTimeZoneRule object, or a pair of AnnualTimeZoneRule
* with a single InitialTimeZoneRule. The first element in the
* array is always a InitialTimeZoneRule.
*
* @stable ICU 3.8
*/
public TimeZoneRule[] getSimpleTimeZoneRulesNear(long date) {
AnnualTimeZoneRule[] annualRules = null;
TimeZoneRule initialRule = null;
// Get the next transition
TimeZoneTransition tr = getNextTransition(date, false);
if (tr != null) {
String initialName = tr.getFrom().getName();
int initialRaw = tr.getFrom().getRawOffset();
int initialDst = tr.getFrom().getDSTSavings();
// Check if the next transition is either DST->STD or STD->DST and
// within roughly 1 year from the specified date
long nextTransitionTime = tr.getTime();
if (((tr.getFrom().getDSTSavings() == 0 && tr.getTo().getDSTSavings() != 0)
|| (tr.getFrom().getDSTSavings() != 0 && tr.getTo().getDSTSavings() == 0))
&& date + MILLIS_PER_YEAR > nextTransitionTime) {
annualRules = new AnnualTimeZoneRule[2];
// Get local wall time for the transition time
int dtfields[] = Grego.timeToFields(nextTransitionTime
+ tr.getFrom().getRawOffset() + tr.getFrom().getDSTSavings(), null);
int weekInMonth = Grego.getDayOfWeekInMonth(dtfields[0], dtfields[1], dtfields[2]);
// Create DOW rule
DateTimeRule dtr = new DateTimeRule(dtfields[1], weekInMonth, dtfields[3],
dtfields[5], DateTimeRule.WALL_TIME);
AnnualTimeZoneRule secondRule = null;
// Note: SimpleTimeZone does not support raw offset change.
// So we always use raw offset of the given time for the rule,
// even raw offset is changed. This will result that the result
// zone to return wrong offset after the transition.
// When we encounter such case, we do not inspect next next
// transition for another rule.
annualRules[0] = new AnnualTimeZoneRule(tr.getTo().getName(),
initialRaw, tr.getTo().getDSTSavings(),
dtr, dtfields[0], AnnualTimeZoneRule.MAX_YEAR);
if (tr.getTo().getRawOffset() == initialRaw) {
// Get the next next transition
tr = getNextTransition(nextTransitionTime, false);
if (tr != null) {
// Check if the next next transition is either DST->STD or STD->DST
// and within roughly 1 year from the next transition
if (((tr.getFrom().getDSTSavings() == 0 && tr.getTo().getDSTSavings() != 0)
|| (tr.getFrom().getDSTSavings() != 0 && tr.getTo().getDSTSavings() == 0))
&& nextTransitionTime + MILLIS_PER_YEAR > tr.getTime()) {
// Generate another DOW rule
dtfields = Grego.timeToFields(tr.getTime()
+ tr.getFrom().getRawOffset() + tr.getFrom().getDSTSavings(), dtfields);
weekInMonth = Grego.getDayOfWeekInMonth(dtfields[0], dtfields[1], dtfields[2]);
dtr = new DateTimeRule(dtfields[1], weekInMonth, dtfields[3], dtfields[5],
DateTimeRule.WALL_TIME);
secondRule = new AnnualTimeZoneRule(tr.getTo().getName(),
tr.getTo().getRawOffset(), tr.getTo().getDSTSavings(),
dtr, dtfields[0] - 1, AnnualTimeZoneRule.MAX_YEAR);
// Make sure this rule can be applied to the specified date
Date d = secondRule.getPreviousStart(date, tr.getFrom().getRawOffset(),
tr.getFrom().getDSTSavings(), true);
if (d != null && d.getTime() <= date
&& initialRaw == tr.getTo().getRawOffset()
&& initialDst == tr.getTo().getDSTSavings()) {
// We can use this rule as the second transition rule
annualRules[1] = secondRule;
}
}
}
}
if (annualRules[1] == null) {
// Try previous transition
tr = getPreviousTransition(date, true);
if (tr != null) {
// Check if the previous transition is either DST->STD or STD->DST.
// The actual transition time does not matter here.
if ((tr.getFrom().getDSTSavings() == 0 && tr.getTo().getDSTSavings() != 0)
|| (tr.getFrom().getDSTSavings() != 0 && tr.getTo().getDSTSavings() == 0)) {
// Generate another DOW rule
dtfields = Grego.timeToFields(tr.getTime()
+ tr.getFrom().getRawOffset() + tr.getFrom().getDSTSavings(), dtfields);
weekInMonth = Grego.getDayOfWeekInMonth(dtfields[0], dtfields[1], dtfields[2]);
dtr = new DateTimeRule(dtfields[1], weekInMonth, dtfields[3], dtfields[5],
DateTimeRule.WALL_TIME);
// second rule raw/dst offsets should match raw/dst offsets
// at the given time
secondRule = new AnnualTimeZoneRule(tr.getTo().getName(),
initialRaw, initialDst,
dtr, annualRules[0].getStartYear() - 1, AnnualTimeZoneRule.MAX_YEAR);
// Check if this rule start after the first rule after the specified date
Date d = secondRule.getNextStart(date,
tr.getFrom().getRawOffset(), tr.getFrom().getDSTSavings(), false);
if (d.getTime() > nextTransitionTime) {
// We can use this rule as the second transition rule
annualRules[1] = secondRule;
}
}
}
}
if (annualRules[1] == null) {
// Cannot generate a good pair of AnnualTimeZoneRule
annualRules = null;
} else {
// The initial rule should represent the rule before the previous transition
initialName = annualRules[0].getName();
initialRaw = annualRules[0].getRawOffset();
initialDst = annualRules[0].getDSTSavings();
}
}
initialRule = new InitialTimeZoneRule(initialName, initialRaw, initialDst);
} else {
// Try the previous one
tr = getPreviousTransition(date, true);
if (tr != null) {
initialRule = new InitialTimeZoneRule(tr.getTo().getName(),
tr.getTo().getRawOffset(), tr.getTo().getDSTSavings());
} else {
// No transitions in the past. Just use the current offsets
int[] offsets = new int[2];
getOffset(date, false, offsets);
initialRule = new InitialTimeZoneRule(getID(), offsets[0], offsets[1]);
}
}
TimeZoneRule[] result = null;
if (annualRules == null) {
result = new TimeZoneRule[1];
result[0] = initialRule;
} else {
result = new TimeZoneRule[3];
result[0] = initialRule;
result[1] = annualRules[0];
result[2] = annualRules[1];
}
return result;
}
/**
* The time type option for standard time used by
* {@link #getOffsetFromLocal(long, int, int, int[])}
* @internal
* @deprecated This API is ICU internal only.
*/
public static final int LOCAL_STD = 0x01;
/**
* The time type option for daylight saving time used by
* {@link #getOffsetFromLocal(long, int, int, int[])}
* @internal
* @deprecated This API is ICU internal only.
*/
public static final int LOCAL_DST = 0x03;
/**
* The option designate former time to be used by
* {@link #getOffsetFromLocal(long, int, int, int[])}
* @internal
* @deprecated This API is ICU internal only.
*/
public static final int LOCAL_FORMER = 0x04;
/**
* The option designate latter time to be used by
* {@link #getOffsetFromLocal(long, int, int, int[])}
* @internal
* @deprecated This API is ICU internal only.
*/
public static final int LOCAL_LATTER = 0x0C;
/**
* The bit mask for the time type option used by
* {@link #getOffsetFromLocal(long, int, int, int[])}
* @internal
* @deprecated This API is ICU internal only.
*/
protected static final int STD_DST_MASK = 0x03;
/**
* The bit mask for the former/latter option used by
* {@link #getOffsetFromLocal(long, int, int, int[])}
* @internal
* @deprecated This API is ICU internal only.
*/
protected static final int FORMER_LATTER_MASK = 0x0C;
/**
* Get time zone offsets from local wall time.
* @internal
* @deprecated This API is ICU internal only.
*/
public void getOffsetFromLocal(long date,
int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets) {
throw new IllegalStateException("Not implemented");
}
/**
* Protected no arg constructor.
* @stable ICU 3.8
*/
protected BasicTimeZone() {
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/ 0000755 0001750 0001750 00000000000 11627232337 016474 5 ustar twerner twerner icu4j-4.2.1.1/src/com/ibm/icu/impl/ICUNotifier.java 0000644 0001750 0001750 00000013104 10421032307 021440 0 ustar twerner twerner /**
*******************************************************************************
* Copyright (C) 2001-2006, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
import java.util.ArrayList;
import java.util.EventListener;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
/**
* TimeZoneAdapter wraps a com.ibm.icu.util.TimeZone
* subclass and inherits from java.util.TimeZone.
* Without this class, we would need to 'port' java.util.Date to
* com.ibm.icu.util as well, so that Date could interoperate properly
* with the com.ibm.icu.util TimeZone and Calendar classes. With this
* class, we can use java.util.Date together with com.ibm.icu.util
* classes.
*
* @see com.ibm.icu.util.TimeZone#setDefault
* @author Alan Liu
* @since ICU 2.8
*/
public class TimeZoneAdapter extends java.util.TimeZone {
// Generated by serialver from JDK 1.4.1_01
static final long serialVersionUID = -2040072218820018557L;
/**
* The contained com.ibm.icu.util.TimeZone object. Must not be null.
* We delegate all methods to this object.
*/
private TimeZone zone;
/**
* Given a java.util.TimeZone, wrap it in the appropriate adapter
* subclass of com.ibm.icu.util.TimeZone and return the adapter.
*/
public static java.util.TimeZone wrap(com.ibm.icu.util.TimeZone tz) {
return new TimeZoneAdapter(tz);
}
/**
* Return the java.util.TimeZone wrapped by this object.
*/
public com.ibm.icu.util.TimeZone unwrap() {
return zone;
}
/**
* Constructs an adapter for a com.ibm.icu.util.TimeZone object.
*/
public TimeZoneAdapter(TimeZone zone) {
this.zone = zone;
super.setID(zone.getID());
}
/**
* TimeZone API; calls through to wrapped time zone.
*/
public void setID(String ID) {
super.setID(ID);
zone.setID(ID);
}
/**
* TimeZone API; calls through to wrapped time zone.
*/
public boolean hasSameRules(java.util.TimeZone other) {
return other instanceof TimeZoneAdapter &&
zone.hasSameRules(((TimeZoneAdapter)other).zone);
}
/**
* TimeZone API; calls through to wrapped time zone.
*/
public int getOffset(int era, int year, int month, int day, int dayOfWeek,
int millis) {
return zone.getOffset(era, year, month, day, dayOfWeek, millis);
}
/**
* TimeZone API; calls through to wrapped time zone.
*/
public int getRawOffset() {
return zone.getRawOffset();
}
/**
* TimeZone API; calls through to wrapped time zone.
*/
public void setRawOffset(int offsetMillis) {
zone.setRawOffset(offsetMillis);
}
/**
* TimeZone API; calls through to wrapped time zone.
*/
public boolean useDaylightTime() {
return zone.useDaylightTime();
}
/**
* TimeZone API; calls through to wrapped time zone.
*/
public boolean inDaylightTime(Date date) {
return zone.inDaylightTime(date);
}
/**
* Boilerplate API; calls through to wrapped object.
*/
public Object clone() {
return new TimeZoneAdapter((TimeZone)zone.clone());
}
/**
* Boilerplate API; calls through to wrapped object.
*/
public synchronized int hashCode() {
return zone.hashCode();
}
/**
* Boilerplate API; calls through to wrapped object.
*/
public boolean equals(Object obj) {
if (obj instanceof TimeZoneAdapter) {
obj = ((TimeZoneAdapter) obj).zone;
}
return zone.equals(obj);
}
/**
* Returns a string representation of this object.
* @return a string representation of this object.
*/
public String toString() {
return "TimeZoneAdapter: " + zone.toString();
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/UBiDiProps.java 0000644 0001750 0001750 00000023753 10574350122 021322 0 ustar twerner twerner /*
*******************************************************************************
*
* Copyright (C) 2004-2007, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
* file name: UBiDiProps.java
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:4
*
* created on: 2005jan16
* created by: Markus W. Scherer
*
* Low-level Unicode bidi/shaping properties access.
* Java port of ubidi_props.h/.c.
*/
package com.ibm.icu.impl;
import java.io.InputStream;
import java.io.DataInputStream;
import java.io.BufferedInputStream;
import java.io.IOException;
import com.ibm.icu.util.RangeValueIterator;
import com.ibm.icu.text.UnicodeSet;
import com.ibm.icu.lang.UCharacter;
import com.ibm.icu.lang.UProperty;
public final class UBiDiProps {
// constructors etc. --------------------------------------------------- ***
// port of ubidi_openProps()
public UBiDiProps() throws IOException{
InputStream is=ICUData.getStream(ICUResourceBundle.ICU_BUNDLE+"/"+DATA_FILE_NAME);
BufferedInputStream b=new BufferedInputStream(is, 4096 /* data buffer size */);
readData(b);
b.close();
is.close();
}
private void readData(InputStream is) throws IOException {
DataInputStream inputStream=new DataInputStream(is);
// read the header
ICUBinary.readHeader(inputStream, FMT, new IsAcceptable());
// read indexes[]
int i, count;
count=inputStream.readInt();
if(countStringobject
* @return copy of this iterator
*/
///CLOVER:OFF
public Object clone()
{
try {
return super.clone();
} catch (CloneNotSupportedException e) {
return null; // never invoked
}
}
///CLOVER:ON
/**
* Returns the current UTF16 character.
* @return current UTF16 character
*/
public int current()
{
if (m_currentIndex_ < m_text_.length()) {
return m_text_.charAt(m_currentIndex_);
}
return DONE;
}
/**
* Returns the length of the text
* @return length of the text
*/
public int getLength()
{
return m_text_.length();
}
/**
* Gets the current currentIndex in text.
* @return current currentIndex in text.
*/
public int getIndex()
{
return m_currentIndex_;
}
/**
* Returns next UTF16 character and increments the iterator's currentIndex
* by 1.
* If the resulting currentIndex is greater or equal to the text length,
* the currentIndex is reset to the text length and a value of DONE is
* returned.
* @return next UTF16 character in text or DONE if the new currentIndex is
* off the end of the text range.
*/
public int next()
{
if (m_currentIndex_ < m_text_.length())
{
return m_text_.charAt(m_currentIndex_ ++);
}
return DONE;
}
/**
* Returns previous UTF16 character and decrements the iterator's
* currentIndex by 1.
* If the resulting currentIndex is less than 0, the currentIndex is reset
* to 0 and a value of DONE is returned.
* @return next UTF16 character in text or DONE if the new currentIndex is
* off the start of the text range.
*/
public int previous()
{
if (m_currentIndex_ > 0) {
return m_text_.charAt(-- m_currentIndex_);
}
return DONE;
}
/**
* getLength()Usage:
*
*
*
*
* @param fillIn an array of chars to fill with the underlying UTF-16 code
* units.
* @param offset the position within the array to start putting the data.
* @return the number of code units added to fillIn, as a convenience
* @exception IndexOutOfBoundsException exception if there is not enough
* room after offset in the array, or if offset < 0.
*/
///CLOVER:OFF
public int getText(char[] fillIn, int offset)
{
int length = m_text_.length();
if (offset < 0 || offset + length > fillIn.length) {
throw new IndexOutOfBoundsException(Integer.toString(length));
}
m_text_.getChars(0, length, fillIn, offset);
return length;
}
///CLOVER:ON
/**
* Convenience method for returning the underlying text storage as as
* string
* @return the underlying text storage in the iterator as a string
*/
public String getText()
{
return m_text_;
}
/**
* Reset this iterator to point to a new string. This method is used by
* other classes that want to avoid allocating new
* ReplaceableCharacterIterator objects every time their setText method
* is called.
* @param text The String to be iterated over
*/
public void setText(String text)
{
if (text == null) {
throw new NullPointerException();
}
m_text_ = text;
m_currentIndex_ = 0;
}
// private data members ----------------------------------------------------
/**
* Text string object
*/
private String m_text_;
/**
* Current currentIndex
*/
private int m_currentIndex_;
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/PluralRulesLoader.java 0000644 0001750 0001750 00000014261 11037002737 022736 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
import com.ibm.icu.text.PluralRules;
import com.ibm.icu.util.ULocale;
import com.ibm.icu.util.UResourceBundle;
import java.text.ParseException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Set;
import java.util.TreeMap;
/**
* Loader for plural rules data.
*/
public class PluralRulesLoader {
private final Map rulesIdToRules;
private Map localeIdToRulesId; // lazy init, use getLocaleIdToRulesIdMap to access
private Map rulesIdToEquivalentULocale; // lazy init, use getRulesIdToEquivalentULocaleMap to access
/**
* Access through singleton.
*/
private PluralRulesLoader() {
rulesIdToRules = new HashMap();
}
/**
* Returns the locales for which we have plurals data.
* Utility for testing.
*/
public ULocale[] getAvailableULocales() {
Set keys = getLocaleIdToRulesIdMap().keySet();
ULocale[] locales = new ULocale[keys.size()];
int n = 0;
for (Iterator iter = keys.iterator(); iter.hasNext();) {
locales[n++] = ULocale.createCanonical((String) iter.next());
}
return locales;
}
/**
* Returns the functionally equivalent locale.
*/
public ULocale getFunctionalEquivalent(ULocale locale, boolean[] isAvailable) {
if (isAvailable != null && isAvailable.length > 0) {
String localeId = ULocale.canonicalize(locale.getBaseName());
Map idMap = getLocaleIdToRulesIdMap();
isAvailable[0] = idMap.containsKey(localeId);
}
String rulesId = getRulesIdForLocale(locale);
if (rulesId == null || rulesId.trim().length() == 0) {
return ULocale.ROOT; // ultimate fallback
}
ULocale result = (ULocale) getRulesIdToEquivalentULocaleMap().get(rulesId);
if (result == null) {
return ULocale.ROOT; // ultimate fallback
}
return result;
}
/**
* Returns the lazily-constructed map.
*/
private Map getLocaleIdToRulesIdMap() {
checkBuildRulesIdMaps();
return localeIdToRulesId;
}
/**
* Returns the lazily-constructed map.
*/
private Map getRulesIdToEquivalentULocaleMap() {
checkBuildRulesIdMaps();
return rulesIdToEquivalentULocale;
}
/**
* Lazily constructs the localeIdToRulesId and rulesIdToEquivalentULocale
* maps if necessary. These exactly reflect the contents of the locales resource
* in plurals.res.
*/
private void checkBuildRulesIdMaps() {
if (localeIdToRulesId == null) {
try {
UResourceBundle pluralb = getPluralBundle();
UResourceBundle localeb = pluralb.get("locales");
localeIdToRulesId = new TreeMap(); // sort for convenience of getAvailableULocales
rulesIdToEquivalentULocale = new HashMap(); // not visible
for (int i = 0; i < localeb.getSize(); ++i) {
UResourceBundle b = localeb.get(i);
String id = b.getKey();
String value = b.getString().intern();
localeIdToRulesId.put(id, value);
if (!rulesIdToEquivalentULocale.containsKey(value)) {
rulesIdToEquivalentULocale.put(value, new ULocale(id));
}
}
}
catch (MissingResourceException e) {
localeIdToRulesId = new HashMap(); // dummy so we don't try again, can read
rulesIdToEquivalentULocale = new HashMap();
}
}
}
/**
* Gets the rulesId from the locale,with locale fallback. If there is no
* rulesId, return null. The rulesId might be the empty string if the
* rule is the default rule.
*/
public String getRulesIdForLocale(ULocale locale) {
Map idMap = getLocaleIdToRulesIdMap();
String localeId = ULocale.canonicalize(locale.getBaseName());
String rulesId = null;
while (null == (rulesId = (String) idMap.get(localeId))) {
int ix = localeId.lastIndexOf("_");
if (ix == -1) {
break;
}
localeId = localeId.substring(0, ix);
}
return rulesId;
}
/**
* Gets the rule from the rulesId. If there is no rule for this rulesId,
* return null.
*/
public PluralRules getRulesForRulesId(String rulesId) {
PluralRules rules = (PluralRules) rulesIdToRules.get(rulesId);
if (rules == null) {
try {
UResourceBundle pluralb = getPluralBundle();
UResourceBundle rulesb = pluralb.get("rules");
UResourceBundle setb = rulesb.get(rulesId);
StringBuffer sb = new StringBuffer();
for (int i = 0; i < setb.getSize(); ++i) {
UResourceBundle b = setb.get(i);
if (i > 0) {
sb.append("; ");
}
sb.append(b.getKey());
sb.append(": ");
sb.append(b.getString());
}
rules = PluralRules.parseDescription(sb.toString());
} catch (ParseException e) {
} catch (MissingResourceException e) {
}
rulesIdToRules.put(rulesId, rules); // put even if null
}
return rules;
}
/**
* Return the plurals resource.
* Note MissingResourceException is unchecked, listed here for clarity.
* Callers should handle this exception.
*/
public UResourceBundle getPluralBundle() throws MissingResourceException {
return ICUResourceBundle.getBundleInstance(
ICUResourceBundle.ICU_BASE_NAME,
"plurals",
ICUResourceBundle.ICU_DATA_CLASS_LOADER,
true);
}
/**
* Returns the plural rules for the the locale.
* If we don't have data,
* com.ibm.icu.text.PluralRules.DEFAULT is returned.
*/
public PluralRules forLocale(ULocale locale) {
String rulesId = getRulesIdForLocale(locale);
if (rulesId == null || rulesId.trim().length() == 0) {
return PluralRules.DEFAULT;
}
PluralRules rules = getRulesForRulesId(rulesId);
if (rules == null) {
rules = PluralRules.DEFAULT;
}
return rules;
}
/**
* The only instance of the loader.
*/
public static final PluralRulesLoader loader = new PluralRulesLoader();
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/ICUResourceBundleImpl.java 0000644 0001750 0001750 00000033441 11135716003 023437 0 ustar twerner twerner //##header
/*
*******************************************************************************
* Copyright (C) 2004-2009, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
import java.util.HashMap;
import java.util.MissingResourceException;
import com.ibm.icu.util.ULocale;
import com.ibm.icu.util.UResourceBundle;
import com.ibm.icu.util.UResourceBundleIterator;
import com.ibm.icu.util.UResourceTypeMismatchException;
//#if defined(FOUNDATION10) || defined(J2SE13) || defined(ECLIPSE_FRAGMENT)
//#else
import java.nio.ByteBuffer;
//#endif
class ICUResourceBundleImpl {
static final class ResourceArray extends ICUResourceBundle {
protected String[] handleGetStringArray() {
String[] strings = new String[size];
UResourceBundleIterator iter = getIterator();
int i = 0;
while (iter.hasNext()) {
strings[i++] = iter.next().getString();
}
return strings;
}
/**
* @internal ICU 3.0
*/
public String[] getStringArray() {
return handleGetStringArray();
}
protected UResourceBundle handleGetImpl(String indexStr, HashMap table, UResourceBundle requested,
int[] index, boolean[] isAlias) {
index[0] = getIndex(indexStr);
if (index[0] > -1) {
return handleGetImpl(index[0], table, requested, isAlias);
}
throw new UResourceTypeMismatchException("Could not get the correct value for index: "+ index);
}
protected UResourceBundle handleGetImpl(int index, HashMap table, UResourceBundle requested,
boolean[] isAlias) {
if (index > size) {
throw new IndexOutOfBoundsException();
}
int offset = RES_GET_OFFSET(resource);
int itemOffset = offset + getIntOffset(index + 1);
long itemResource = (UNSIGNED_INT_MASK) & ICUResourceBundle.getInt(rawData,itemOffset);
String path = (isTopLevel == true) ? Integer.toString(index) : resPath + "/" + index;
return createBundleObject(Integer.toString(index), itemResource, path, table, requested, this, isAlias);
}
private int countItems() {
int offset = RES_GET_OFFSET(resource);
int value = getInt(rawData,offset);
return value;
}
ResourceArray(String key, String resPath, long resource, ICUResourceBundle bundle) {
assign(this, bundle);
this.resource = resource;
this.key = key;
this.size = countItems();
this.resPath = resPath;
createLookupCache(); // Use bundle cache to access array entries
}
}
static final class ResourceBinary extends ICUResourceBundle {
private byte[] value;
public ByteBuffer getBinary() {
return ByteBuffer.wrap(value);
}
public byte [] getBinary(byte []ba) {
return value;
}
private byte[] getValue() {
int offset = RES_GET_OFFSET(resource);
int length = ICUResourceBundle.getInt(rawData,offset);
int byteOffset = offset + getIntOffset(1);
byte[] dst = new byte[length];
//if (ASSERT) Assert.assrt("byteOffset+length < rawData.length", byteOffset+length < rawData.length);
System.arraycopy(rawData, byteOffset, dst, 0, length);
return dst;
}
ResourceBinary(String key, String resPath, long resource, ICUResourceBundle bundle) {
assign(this, bundle);
this.resource = resource;
this.key = key;
this.resPath = resPath;
value = getValue();
}
}
static final class ResourceInt extends ICUResourceBundle {
public int getInt() {
return RES_GET_INT(resource);
}
public int getUInt() {
long ret = RES_GET_UINT(resource);
return (int) ret;
}
ResourceInt(String key, String resPath, long resource, ICUResourceBundle bundle) {
assign(this, bundle);
this.key = key;
this.resource = resource;
this.resPath = resPath;
}
}
static final class ResourceString extends ICUResourceBundle {
private String value;
public String getString() {
return value;
}
ResourceString(String key, String resPath, long resource, ICUResourceBundle bundle) {
assign(this, bundle);
value = getStringValue(resource);
this.key = key;
this.resource = resource;
this.resPath = resPath;
}
}
static final class ResourceIntVector extends ICUResourceBundle {
private int[] value;
public int[] getIntVector() {
return value;
}
private int[] getValue() {
int offset = RES_GET_OFFSET(resource);
int length = ICUResourceBundle.getInt(rawData,offset);
int intOffset = offset + getIntOffset(1);
int[] val = new int[length];
//int byteLength = getIntOffset(length);
//if (ASSERT) Assert.assrt("(intOffset+byteLength)
* UChacterIterator iter = new UCharacterIterator.getInstance(text);
* char[] buf = new char[iter.getLength()];
* iter.getText(buf);
*
* OR
* char[] buf= new char[1];
* int len = 0;
* for(;;){
* try{
* len = iter.getText(buf);
* break;
* }catch(IndexOutOfBoundsException e){
* buf = new char[iter.getLength()];
* }
* }
*
*
*
*/
public class PatternTokenizer {
// settings used in the interpretation of the pattern
private UnicodeSet ignorableCharacters = new UnicodeSet();
private UnicodeSet syntaxCharacters = new UnicodeSet();
private UnicodeSet extraQuotingCharacters = new UnicodeSet();
private UnicodeSet escapeCharacters = new UnicodeSet();
private boolean usingSlash = false;
private boolean usingQuote = false;
// transient data, set when needed. Null it out for any changes in the above fields.
private transient UnicodeSet needingQuoteCharacters = null;
// data about the current pattern being parsed. start gets moved as we go along.
private int start;
private int limit;
private String pattern;
public UnicodeSet getIgnorableCharacters() {
return (UnicodeSet) ignorableCharacters.clone();
}
/**
* Sets the characters to be ignored in parsing, eg new UnicodeSet("[:pattern_whitespace:]");
* @param ignorableCharacters
* @return
*/
public PatternTokenizer setIgnorableCharacters(UnicodeSet ignorableCharacters) {
this.ignorableCharacters = (UnicodeSet) ignorableCharacters.clone();
needingQuoteCharacters = null;
return this;
}
public UnicodeSet getSyntaxCharacters() {
return (UnicodeSet) syntaxCharacters.clone();
}
public UnicodeSet getExtraQuotingCharacters() {
return (UnicodeSet) extraQuotingCharacters.clone();
}
/**
* Sets the characters to be interpreted as syntax characters in parsing, eg new UnicodeSet("[:pattern_syntax:]")
* @param syntaxCharacters
* @return
*/
public PatternTokenizer setSyntaxCharacters(UnicodeSet syntaxCharacters) {
this.syntaxCharacters = (UnicodeSet) syntaxCharacters.clone();
needingQuoteCharacters = null;
return this;
}
/**
* Sets the extra characters to be quoted in literals
* @param syntaxCharacters
* @return
*/
public PatternTokenizer setExtraQuotingCharacters(UnicodeSet syntaxCharacters) {
this.extraQuotingCharacters = (UnicodeSet) syntaxCharacters.clone();
needingQuoteCharacters = null;
return this;
}
public UnicodeSet getEscapeCharacters() {
return (UnicodeSet) escapeCharacters.clone();
}
/**
* Set characters to be escaped in literals, in quoteLiteral and normalize, eg new UnicodeSet("[^\\u0020-\\u007E]");
* @param escapeCharacters
* @return
*/
public PatternTokenizer setEscapeCharacters(UnicodeSet escapeCharacters) {
this.escapeCharacters = (UnicodeSet) escapeCharacters.clone();
return this;
}
public boolean isUsingQuote() {
return usingQuote;
}
public PatternTokenizer setUsingQuote(boolean usingQuote) {
this.usingQuote = usingQuote;
needingQuoteCharacters = null;
return this;
}
public boolean isUsingSlash() {
return usingSlash;
}
public PatternTokenizer setUsingSlash(boolean usingSlash) {
this.usingSlash = usingSlash;
needingQuoteCharacters = null;
return this;
}
// public UnicodeSet getQuoteCharacters() {
// return (UnicodeSet) quoteCharacters.clone();
// }
// public PatternTokenizer setQuoteCharacters(UnicodeSet quoteCharacters) {
// this.quoteCharacters = (UnicodeSet) quoteCharacters.clone();
// needingQuoteCharacters = null;
// return this;
// }
public int getLimit() {
return limit;
}
public PatternTokenizer setLimit(int limit) {
this.limit = limit;
return this;
}
public int getStart() {
return start;
}
public PatternTokenizer setStart(int start) {
this.start = start;
return this;
}
//#if defined(FOUNDATION10) || defined(J2SE13)
//## public PatternTokenizer setPattern(StringBuffer pattern) {
//## return setPattern(pattern.toString());
//## }
//#else
public PatternTokenizer setPattern(CharSequence pattern) {
return setPattern(pattern.toString());
}
//#endif
public PatternTokenizer setPattern(String pattern) {
if (pattern == null) {
throw new IllegalArgumentException("Inconsistent arguments");
}
this.start = 0;
this.limit = pattern.length();
this.pattern = pattern;
return this;
}
public static final char SINGLE_QUOTE = '\'';
public static final char BACK_SLASH = '\\';
private static int NO_QUOTE = -1, IN_QUOTE = -2;
//#if defined(FOUNDATION10) || defined(J2SE13)
//## public String quoteLiteral(StringBuffer string) {
//## return quoteLiteral(string.toString());
//## }
//#else
public String quoteLiteral(CharSequence string) {
return quoteLiteral(string.toString());
}
//#endif
/**
* Quote a literal string, using the available settings. Thus syntax characters, quote characters, and ignorable characters will be put into quotes.
* @param string
* @return
*/
public String quoteLiteral(String string) {
if (needingQuoteCharacters == null) {
needingQuoteCharacters = new UnicodeSet().addAll(syntaxCharacters).addAll(ignorableCharacters).addAll(extraQuotingCharacters); // .addAll(quoteCharacters)
if (usingSlash) needingQuoteCharacters.add(BACK_SLASH);
if (usingQuote) needingQuoteCharacters.add(SINGLE_QUOTE);
}
StringBuffer result = new StringBuffer();
int quotedChar = NO_QUOTE;
int cp;
for (int i = 0; i < string.length(); i += UTF16.getCharCount(cp)) {
cp = UTF16.charAt(string, i);
if (escapeCharacters.contains(cp)) {
// we may have to fix up previous characters
if (quotedChar == IN_QUOTE) {
result.append(SINGLE_QUOTE);
quotedChar = NO_QUOTE;
}
appendEscaped(result, cp);
continue;
}
if (needingQuoteCharacters.contains(cp)) {
// if we have already started a quote
if (quotedChar == IN_QUOTE) {
UTF16.append(result, cp);
if (usingQuote && cp == SINGLE_QUOTE) { // double it
result.append(SINGLE_QUOTE);
}
continue;
}
// otherwise not already in quote
if (usingSlash) {
result.append(BACK_SLASH);
UTF16.append(result, cp);
continue;
}
if (usingQuote) {
if (cp == SINGLE_QUOTE) { // double it and continue
result.append(SINGLE_QUOTE);
result.append(SINGLE_QUOTE);
continue;
}
result.append(SINGLE_QUOTE);
UTF16.append(result, cp);
quotedChar = IN_QUOTE;
continue;
}
// we have no choice but to use \\u or \\U
appendEscaped(result, cp);
continue;
}
// otherwise cp doesn't need quoting
// we may have to fix up previous characters
if (quotedChar == IN_QUOTE) {
result.append(SINGLE_QUOTE);
quotedChar = NO_QUOTE;
}
UTF16.append(result, cp);
}
// all done.
// we may have to fix up previous characters
if (quotedChar == IN_QUOTE) {
result.append(SINGLE_QUOTE);
}
return result.toString();
}
private void appendEscaped(StringBuffer result, int cp) {
if (cp <= 0xFFFF) {
result.append("\\u").append(Utility.hex(cp,4));
} else {
result.append("\\U").append(Utility.hex(cp,8));
}
}
public String normalize() {
int oldStart = start;
StringBuffer result = new StringBuffer();
StringBuffer buffer = new StringBuffer();
while (true) {
buffer.setLength(0);
int status = next(buffer);
if (status == DONE) {
start = oldStart;
return result.toString();
}
if (status != SYNTAX) {
result.append(quoteLiteral(buffer));
} else {
result.append(buffer);
}
}
}
public static final int DONE = 0, SYNTAX = 1, LITERAL = 2, BROKEN_QUOTE = 3, BROKEN_ESCAPE = 4, UNKNOWN = 5;
private static final int AFTER_QUOTE = -1, NONE = 0, START_QUOTE = 1, NORMAL_QUOTE = 2, SLASH_START = 3, HEX = 4;
public int next(StringBuffer buffer) {
if (start >= limit) return DONE;
int status = UNKNOWN;
int lastQuote = UNKNOWN;
int quoteStatus = NONE;
int hexCount = 0;
int hexValue = 0;
int cp;
main:
for (int i = start; i < limit; i += UTF16.getCharCount(cp)) {
cp = UTF16.charAt(pattern, i);
// if we are in a quote, then handle it.
switch (quoteStatus) {
case SLASH_START:
switch (cp) {
case 'u':
quoteStatus = HEX;
hexCount = 4;
hexValue = 0;
continue main;
case 'U':
quoteStatus = HEX;
hexCount = 8;
hexValue = 0;
continue main;
default:
if (usingSlash) {
UTF16.append(buffer, cp);
quoteStatus = NONE;
continue main;
} else {
buffer.append(BACK_SLASH);
quoteStatus = NONE;
}
}
break; // fall through to NONE
case HEX:
hexValue <<= 4;
hexValue += cp;
switch (cp) {
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
hexValue -= '0'; break;
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
hexValue -= 'a' - 10; break;
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
hexValue -= 'A' - 10; break;
default:
start = i;
return BROKEN_ESCAPE;
}
--hexCount;
if (hexCount == 0) {
quoteStatus = NONE;
UTF16.append(buffer, hexValue);
}
continue main;
case AFTER_QUOTE:
// see if we get another quote character
// if we just ended a quote BUT the following character is the lastQuote character, then we have a situation like '...''...', so we restart the quote
if (cp == lastQuote) {
UTF16.append(buffer, cp);
quoteStatus = NORMAL_QUOTE;
continue main;
}
quoteStatus = NONE;
break; // fall through to NONE
case START_QUOTE:
// if we are at the very start of a quote, and we hit another quote mark then we emit a literal quote character and end the quote
if (cp == lastQuote) {
UTF16.append(buffer, cp);
quoteStatus = NONE; // get out of quote, with no trace remaining
continue;
}
// otherwise get into quote
UTF16.append(buffer, cp);
quoteStatus = NORMAL_QUOTE;
continue main;
case NORMAL_QUOTE:
if (cp == lastQuote) {
quoteStatus = AFTER_QUOTE; // get out of quote
continue main;
}
UTF16.append(buffer, cp);
continue main;
}
if (ignorableCharacters.contains(cp)) {
continue;
}
// do syntax characters
if (syntaxCharacters.contains(cp)) {
if (status == UNKNOWN) {
UTF16.append(buffer, cp);
start = i + UTF16.getCharCount(cp);
return SYNTAX;
} else { // LITERAL, so back up and break
start = i;
return status;
}
}
// otherwise it is a literal; keep on going
status = LITERAL;
if (cp == BACK_SLASH) {
quoteStatus = SLASH_START;
continue;
} else if (usingQuote && cp == SINGLE_QUOTE) {
lastQuote = cp;
quoteStatus = START_QUOTE;
continue;
}
// normal literals
UTF16.append(buffer, cp);
}
// handle final cleanup
start = limit;
switch (quoteStatus) {
case HEX:
status = BROKEN_ESCAPE;
break;
case SLASH_START:
if (usingSlash) {
status = BROKEN_ESCAPE;
} else {
buffer.append(BACK_SLASH);
}
break;
case START_QUOTE: case NORMAL_QUOTE:
status = BROKEN_QUOTE;
break;
}
return status;
}
}
//eof
icu4j-4.2.1.1/src/com/ibm/icu/impl/ICUResourceBundleReader.java 0000644 0001750 0001750 00000031631 11024513123 023732 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2004-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import com.ibm.icu.util.ULocale;
import com.ibm.icu.util.VersionInfo;
/**
* This class reads the *.res resource bundle format
*
* (For the latest version of the file format documentation see
* ICU4C's source/common/uresdata.h file.)
*
* File format for .res resource bundle files (formatVersion=1.2)
*
* An ICU4C resource bundle file (.res) is a binary, memory-mappable file
* with nested, hierarchical data structures.
* It physically contains the following:
*
* Resource root; -- 32-bit Resource item, root item for this bundle's tree;
* currently, the root item must be a table or table32 resource item
* int32_t indexes[indexes[0]]; -- array of indexes for friendly
* reading and swapping; see URES_INDEX_* above
* new in formatVersion 1.1 (ICU 2.8)
* char keys[]; -- characters for key strings
* (formatVersion 1.0: up to 65k of characters; 1.1: <2G)
* (minus the space for root and indexes[]),
* which consist of invariant characters (ASCII/EBCDIC) and are NUL-terminated;
* padded to multiple of 4 bytes for 4-alignment of the following data
* data; -- data directly and indirectly indexed by the root item;
* the structure is determined by walking the tree
*
* Each resource bundle item has a 32-bit Resource handle (see typedef above)
* which contains the item type number in its upper 4 bits (31..28) and either
* an offset or a direct value in its lower 28 bits (27..0).
* The order of items is undefined and only determined by walking the tree.
* Leaves of the tree may be stored first or last or anywhere in between,
* and it is in theory possible to have unreferenced holes in the file.
*
* Direct values:
* - Empty Unicode strings have an offset value of 0 in the Resource handle itself.
* - Integer values are 28-bit values stored in the Resource handle itself;
* the interpretation of unsigned vs. signed integers is up to the application.
*
* All other types and values use 28-bit offsets to point to the item's data.
* The offset is an index to the first 32-bit word of the value, relative to the
* start of the resource data (i.e., the root item handle is at offset 0).
* To get byte offsets, the offset is multiplied by 4 (or shifted left by 2 bits).
* All resource item values are 4-aligned.
*
* The structures (memory layouts) for the values for each item type are listed
* in the table above.
*
* Nested, hierarchical structures: -------------
*
* Table items contain key-value pairs where the keys are 16-bit offsets to char * key strings.
* Key string offsets are also relative to the start of the resource data (of the root handle),
* i.e., the first string has an offset of 4 (after the 4-byte root handle).
*
* The values of these pairs are Resource handles.
*
* Array items are simple vectors of Resource handles.
*
* An alias item is special (and new in ICU 2.4): --------------
*
* Its memory layout is just like for a UnicodeString, but at runtime it resolves to
* another resource bundle's item according to the path in the string.
* This is used to share items across bundles that are in different lookup/fallback
* chains (e.g., large collation data among zh_TW and zh_HK).
* This saves space (for large items) and maintenance effort (less duplication of data).
*
* --------------------------------------------------------------------------
*
* Resource types:
*
* Most resources have their values stored at four-byte offsets from the start
* of the resource data. These values are at least 4-aligned.
* Some resource values are stored directly in the offset field of the Resource itself.
* See UResType in unicode/ures.h for enumeration constants for Resource types.
*
* Type Name Memory layout of values
* (in parentheses: scalar, non-offset values)
*
* 0 Unicode String: int32_t length, UChar[length], (UChar)0, (padding)
* or (empty string ("") if offset==0)
* 1 Binary: int32_t length, uint8_t[length], (padding)
* - this value should be 32-aligned -
* 2 Table: uint16_t count, uint16_t keyStringOffsets[count], (uint16_t padding), Resource[count]
* 3 Alias: (physically same value layout as string, new in ICU 2.4)
* 4 Table32: int32_t count, int32_t keyStringOffsets[count], Resource[count]
* (new in formatVersion 1.1/ICU 2.8)
*
* 7 Integer: (28-bit offset is integer value)
* 8 Array: int32_t count, Resource[count]
*
* 14 Integer Vector: int32_t length, int32_t[length]
* 15 Reserved: This value denotes special purpose resources and is for internal use.
*
* Note that there are 3 types with data vector values:
* - Vectors of 8-bit bytes stored as type Binary.
* - Vectors of 16-bit words stored as type Unicode String
* (no value restrictions, all values 0..ffff allowed!).
* - Vectors of 32-bit words stored as type Integer Vector.
*
*
*/
public final class ICUResourceBundleReader implements ICUBinary.Authenticate{
/**
* File format version that this class understands.
* "ResB"
*/
private static final byte DATA_FORMAT_ID[] = {(byte)0x52, (byte)0x65,
(byte)0x73, (byte)0x42};
private static final String ICU_RESOURCE_SUFFIX = ".res";
/* indexes[] value names; indexes are generally 32-bit (Resource) indexes */
private static final int URES_INDEX_LENGTH = 0; /* [0] contains URES_INDEX_TOP==the length of indexes[] */
//private static final int URES_INDEX_STRINGS_TOP = 1; /* [1] contains the top of the strings, */
/* same as the bottom of resources, rounded up */
//private static final int URES_INDEX_RESOURCES_TOP = 2; /* [2] contains the top of all resources */
private static final int URES_INDEX_BUNDLE_TOP = 3; /* [3] contains the top of the bundle, */
/* in case it were ever different from [2] */
//private static final int URES_INDEX_MAX_TABLE_LENGTH = 4; /* [4] max. length of any table */
private static final int URES_INDEX_ATTRIBUTES = 5; /* [5] attributes bit set, see URES_ATT_* (new in formatVersion 1.2) */
//private static final int URES_INDEX_TOP = 6;
//private static final int URES_STRINGS_BOTTOM=(1+URES_INDEX_TOP)*4;
/*
* Nofallback attribute, attribute bit 0 in indexes[URES_INDEX_ATTRIBUTES].
* New in formatVersion 1.2 (ICU 3.6).
*
* If set, then this resource bundle is a standalone bundle.
* If not set, then the bundle participates in locale fallback, eventually
* all the way to the root bundle.
* If indexes[] is missing or too short, then the attribute cannot be determined
* reliably. Dependency checking should ignore such bundles, and loading should
* use fallbacks.
*/
private static final int URES_ATT_NO_FALLBACK = 1;
private static final boolean DEBUG = false;
private byte[] /* formatVersion, */ dataVersion;
private int rootRes;
private int[] indexes;
private boolean noFallback; /* see URES_ATT_NO_FALLBACK */
private byte[] data;
private ICUResourceBundleReader(InputStream stream, String resolvedName){
BufferedInputStream bs = new BufferedInputStream(stream);
try{
if(DEBUG) System.out.println("The InputStream class is: " + stream.getClass().getName());
if(DEBUG) System.out.println("The BufferedInputStream class is: " + bs.getClass().getName());
if(DEBUG) System.out.println("The bytes avialable in stream before reading the header: " + bs.available());
dataVersion = ICUBinary.readHeader(bs,DATA_FORMAT_ID,this);
if(DEBUG) System.out.println("The bytes available in stream after reading the header: " + bs.available());
readData(bs);
stream.close();
}catch(IOException ex){
throw new RuntimeException("Data file "+ resolvedName+ " is corrupt - " + ex.getMessage());
}
}
public static ICUResourceBundleReader getReader(String baseName, String localeName, ClassLoader root){
String resolvedName = getFullName(baseName, localeName);
InputStream stream = ICUData.getStream(root,resolvedName);
if(stream==null){
return null;
}
ICUResourceBundleReader reader = new ICUResourceBundleReader(stream, resolvedName);
return reader;
}
private static void writeInt(int i, byte[] bytes, int offset) {
bytes[offset++]=(byte)(i>>24);
bytes[offset++]=(byte)(i>>16);
bytes[offset++]=(byte)(i>>8);
bytes[offset]=(byte)i;
}
private void readData(InputStream stream)
throws IOException{
DataInputStream ds = new DataInputStream(stream);
if(DEBUG) System.out.println("The DataInputStream class is: " + ds.getClass().getName());
if(DEBUG) System.out.println("The available bytes in the stream before reading the data: "+ds.available());
/*
* The following will read two integers before ds.mark().
* Later, the two integers need to be placed into data[],
* then ds.reset(), then ds.readFully(into rest of data[]).
*
* This is necessary because we don't know the readLimit for ds.mark()
* until we have read the second integer (indexLength).
*/
rootRes = ds.readInt();
// read the variable-length indexes[] array
int indexLength = ds.readInt();
ds.mark((indexLength-1)*4);
indexes = new int[indexLength];
indexes[URES_INDEX_LENGTH] = indexLength;
for(int i=1; ichoice, the character name written into the
* buffer is the "modern" name or the name that was defined in Unicode
* version 1.0.
* The name contains only "invariant" characters
* like A-Z, 0-9, space, and '-'.
*
* @param ch the code point for which to get the name.
* @param choice Selector for which name to get.
* @return if code point is above 0x1fff, null is returned
*/
public String getName(int ch, int choice)
{
if (ch < UCharacter.MIN_VALUE || ch > UCharacter.MAX_VALUE ||
choice > UCharacterNameChoice.CHAR_NAME_CHOICE_COUNT) {
return null;
}
String result = null;
result = getAlgName(ch, choice);
// getting normal character name
if (result == null || result.length() == 0) {
if (choice == UCharacterNameChoice.EXTENDED_CHAR_NAME) {
result = getExtendedName(ch);
} else {
result = getGroupName(ch, choice);
}
}
return result;
}
/**
* Find a character by its name and return its code point value
* @param choice selector to indicate if argument name is a Unicode 1.0
* or the most current version
* @param name the name to search for
* @return code point
*/
public int getCharFromName(int choice, String name)
{
// checks for illegal arguments
if (choice >= UCharacterNameChoice.CHAR_NAME_CHOICE_COUNT ||
name == null || name.length() == 0) {
return -1;
}
// try extended names first
int result = getExtendedChar(name.toLowerCase(), choice);
if (result >= -1) {
return result;
}
String upperCaseName = name.toUpperCase();
// try algorithmic names first, if fails then try group names
// int result = getAlgorithmChar(choice, uppercasename);
if (choice != UCharacterNameChoice.UNICODE_10_CHAR_NAME) {
int count = 0;
if (m_algorithm_ != null) {
count = m_algorithm_.length;
}
for (count --; count >= 0; count --) {
result = m_algorithm_[count].getChar(upperCaseName);
if (result >= 0) {
return result;
}
}
}
if (choice == UCharacterNameChoice.EXTENDED_CHAR_NAME) {
result = getGroupChar(upperCaseName,
UCharacterNameChoice.UNICODE_CHAR_NAME);
if (result == -1) {
result = getGroupChar(upperCaseName,
UCharacterNameChoice.UNICODE_10_CHAR_NAME);
}
}
else {
result = getGroupChar(upperCaseName, choice);
}
return result;
}
// these are all UCharacterNameIterator use methods -------------------
/**
* Reads a block of compressed lengths of 32 strings and expands them into
* offsets and lengths for each string. Lengths are stored with a
* variable-width encoding in consecutive nibbles:
* If a nibble<0xc, then it is the length itself (0 = empty string).
* If a nibble>=0xc, then it forms a length value with the following
* nibble.
* The offsets and lengths arrays must be at least 33 (one more) long
* because there is no check here at the end if the last nibble is still
* used.
* @param index of group string object in array
* @param offsets array to store the value of the string offsets
* @param lengths array to store the value of the string length
* @return next index of the data string immediately after the lengths
* in terms of byte address
*/
public int getGroupLengths(int index, char offsets[], char lengths[])
{
char length = 0xffff;
byte b = 0,
n = 0;
int shift;
index = index * m_groupsize_; // byte count offsets of group strings
int stringoffset = UCharacterUtility.toInt(
m_groupinfo_[index + OFFSET_HIGH_OFFSET_],
m_groupinfo_[index + OFFSET_LOW_OFFSET_]);
offsets[0] = 0;
// all 32 lengths must be read to get the offset of the first group
// string
for (int i = 0; i < LINES_PER_GROUP_; stringoffset ++) {
b = m_groupstring_[stringoffset];
shift = 4;
while (shift >= 0) {
// getting nibble
n = (byte)((b >> shift) & 0x0F);
if (length == 0xffff && n > SINGLE_NIBBLE_MAX_) {
length = (char)((n - 12) << 4);
}
else {
if (length != 0xffff) {
lengths[i] = (char)((length | n) + 12);
}
else {
lengths[i] = (char)n;
}
if (i < LINES_PER_GROUP_) {
offsets[i + 1] = (char)(offsets[i] + lengths[i]);
}
length = 0xffff;
i ++;
}
shift -= 4;
}
}
return stringoffset;
}
/**
* Gets the name of the argument group index.
* UnicodeData.txt uses ';' as a field separator, so no field can contain
* ';' as part of its contents. In unames.icu, it is marked as
* token[';'] == -1 only if the semicolon is used in the data file - which
* is iff we have Unicode 1.0 names or ISO comments.
* So, it will be token[';'] == -1 if we store U1.0 names/ISO comments
* although we know that it will never be part of a name.
* Equivalent to ICU4C's expandName.
* @param index of the group name string in byte count
* @param length of the group name string
* @param choice of Unicode 1.0 name or the most current name
* @return name of the group
*/
public String getGroupName(int index, int length, int choice)
{
if (choice == UCharacterNameChoice.UNICODE_10_CHAR_NAME
|| choice == UCharacterNameChoice.ISO_COMMENT_) {
if (';' >= m_tokentable_.length || m_tokentable_[';'] == 0xFFFF) {
// skip the modern name
int oldindex = index;
index += UCharacterUtility.skipByteSubString(m_groupstring_,
index, length, (byte)';');
length -= (index - oldindex);
if (choice == UCharacterNameChoice.ISO_COMMENT_) {
// skips the 1.0 Name to the iso comment part
oldindex = index;
index += UCharacterUtility.skipByteSubString(m_groupstring_,
index, length, (byte)';');
length -= (index - oldindex);
}
}
else {
// the semicolon byte is a token number, therefore only modern
// names are stored in unames.dat and there is no such
// requested Unicode 1.0 name here
length = 0;
}
}
synchronized (m_utilStringBuffer_) {
m_utilStringBuffer_.delete(0, m_utilStringBuffer_.length());
byte b;
char token;
for (int i = 0; i < length;) {
b = m_groupstring_[index + i];
i ++;
if (b >= m_tokentable_.length) {
if (b == ';') {
break;
}
m_utilStringBuffer_.append(b); // implicit letter
}
else {
token = m_tokentable_[b & 0x00ff];
if (token == 0xFFFE) {
// this is a lead byte for a double-byte token
token = m_tokentable_[b << 8 |
(m_groupstring_[index + i] & 0x00ff)];
i ++;
}
if (token == 0xFFFF) {
if (b == ';') {
// skip the semicolon if we are seeking extended
// names and there was no 2.0 name but there
// is a 1.0 name.
if (m_utilStringBuffer_.length() == 0 && choice ==
UCharacterNameChoice.EXTENDED_CHAR_NAME) {
continue;
}
break;
}
// explicit letter
m_utilStringBuffer_.append((char)(b & 0x00ff));
}
else { // write token word
UCharacterUtility.getNullTermByteSubString(
m_utilStringBuffer_, m_tokenstring_, token);
}
}
}
if (m_utilStringBuffer_.length() > 0) {
return m_utilStringBuffer_.toString();
}
}
return null;
}
/**
* Retrieves the extended name
*/
public String getExtendedName(int ch)
{
String result = getName(ch, UCharacterNameChoice.UNICODE_CHAR_NAME);
if (result == null) {
if (getType(ch) == UCharacterCategory.CONTROL) {
result = getName(ch,
UCharacterNameChoice.UNICODE_10_CHAR_NAME);
}
if (result == null) {
result = getExtendedOr10Name(ch);
}
}
return result;
}
/**
* Gets the group index for the codepoint, or the group before it.
* @param codepoint
* @return group index containing codepoint or the group before it.
*/
public int getGroup(int codepoint)
{
int endGroup = m_groupcount_;
int msb = getCodepointMSB(codepoint);
int result = 0;
// binary search for the group of names that contains the one for
// code
// find the group that contains codepoint, or the highest before it
while (result < endGroup - 1) {
int gindex = (result + endGroup) >> 1;
if (msb < getGroupMSB(gindex)) {
endGroup = gindex;
}
else {
result = gindex;
}
}
return result;
}
/**
* Gets the extended and 1.0 name when the most current unicode names
* fail
* @param ch codepoint
* @return name of codepoint extended or 1.0
*/
public String getExtendedOr10Name(int ch)
{
String result = null;
if (getType(ch) == UCharacterCategory.CONTROL) {
result = getName(ch,
UCharacterNameChoice.UNICODE_10_CHAR_NAME);
}
if (result == null) {
int type = getType(ch);
// Return unknown if the table of names above is not up to
// date.
if (type >= TYPE_NAMES_.length) {
result = UNKNOWN_TYPE_NAME_;
}
else {
result = TYPE_NAMES_[type];
}
synchronized (m_utilStringBuffer_) {
m_utilStringBuffer_.delete(0, m_utilStringBuffer_.length());
m_utilStringBuffer_.append('<');
m_utilStringBuffer_.append(result);
m_utilStringBuffer_.append('-');
String chStr = Integer.toHexString(ch).toUpperCase();
int zeros = 4 - chStr.length();
while (zeros > 0) {
m_utilStringBuffer_.append('0');
zeros --;
}
m_utilStringBuffer_.append(chStr);
m_utilStringBuffer_.append('>');
result = m_utilStringBuffer_.toString();
}
}
return result;
}
/**
* Gets the MSB from the group index
* @param gindex group index
* @return the MSB of the group if gindex is valid, -1 otherwise
*/
public int getGroupMSB(int gindex)
{
if (gindex >= m_groupcount_) {
return -1;
}
return m_groupinfo_[gindex * m_groupsize_];
}
/**
* Gets the MSB of the codepoint
* @param codepoint
* @return the MSB of the codepoint
*/
public static int getCodepointMSB(int codepoint)
{
return codepoint >> GROUP_SHIFT_;
}
/**
* Gets the maximum codepoint + 1 of the group
* @param msb most significant byte of the group
* @return limit codepoint of the group
*/
public static int getGroupLimit(int msb)
{
return (msb << GROUP_SHIFT_) + LINES_PER_GROUP_;
}
/**
* Gets the minimum codepoint of the group
* @param msb most significant byte of the group
* @return minimum codepoint of the group
*/
public static int getGroupMin(int msb)
{
return msb << GROUP_SHIFT_;
}
/**
* Gets the offset to a group
* @param codepoint
* @return offset to a group
*/
public static int getGroupOffset(int codepoint)
{
return codepoint & GROUP_MASK_;
}
/**
* Gets the minimum codepoint of a group
* @param codepoint
* @return minimum codepoint in the group which codepoint belongs to
*/
///CLOVER:OFF
public static int getGroupMinFromCodepoint(int codepoint)
{
return codepoint & ~GROUP_MASK_;
}
///CLOVER:ON
/**
* Get the Algorithm range length
* @return Algorithm range length
*/
public int getAlgorithmLength()
{
return m_algorithm_.length;
}
/**
* Gets the start of the range
* @param index algorithm index
* @return algorithm range start
*/
public int getAlgorithmStart(int index)
{
return m_algorithm_[index].m_rangestart_;
}
/**
* Gets the end of the range
* @param index algorithm index
* @return algorithm range end
*/
public int getAlgorithmEnd(int index)
{
return m_algorithm_[index].m_rangeend_;
}
/**
* Gets the Algorithmic name of the codepoint
* @param index algorithmic range index
* @param codepoint
* @return algorithmic name of codepoint
*/
public String getAlgorithmName(int index, int codepoint)
{
String result = null;
synchronized (m_utilStringBuffer_) {
m_utilStringBuffer_.delete(0, m_utilStringBuffer_.length());
m_algorithm_[index].appendName(codepoint, m_utilStringBuffer_);
result = m_utilStringBuffer_.toString();
}
return result;
}
/**
* Gets the group name of the character
* @param ch character to get the group name
* @param choice name choice selector to choose a unicode 1.0 or newer name
*/
public synchronized String getGroupName(int ch, int choice)
{
// gets the msb
int msb = getCodepointMSB(ch);
int group = getGroup(ch);
// return this if it is an exact match
if (msb == m_groupinfo_[group * m_groupsize_]) {
int index = getGroupLengths(group, m_groupoffsets_,
m_grouplengths_);
int offset = ch & GROUP_MASK_;
return getGroupName(index + m_groupoffsets_[offset],
m_grouplengths_[offset], choice);
}
return null;
}
// these are transliterator use methods ---------------------------------
/**
* Gets the maximum length of any codepoint name.
* Equivalent to uprv_getMaxCharNameLength.
* @return the maximum length of any codepoint name
*/
public int getMaxCharNameLength()
{
if (initNameSetsLengths()) {
return m_maxNameLength_;
}
else {
return 0;
}
}
/**
* Gets the maximum length of any iso comments.
* Equivalent to uprv_getMaxISOCommentLength.
* @return the maximum length of any codepoint name
*/
///CLOVER:OFF
public int getMaxISOCommentLength()
{
if (initNameSetsLengths()) {
return m_maxISOCommentLength_;
}
else {
return 0;
}
}
///CLOVER:ON
/**
* Fills set with characters that are used in Unicode character names.
* Equivalent to uprv_getCharNameCharacters.
* @param set USet to receive characters. Existing contents are deleted.
*/
public void getCharNameCharacters(UnicodeSet set)
{
convert(m_nameSet_, set);
}
/**
* Fills set with characters that are used in Unicode character names.
* Equivalent to uprv_getISOCommentCharacters.
* @param set USet to receive characters. Existing contents are deleted.
*/
///CLOVER:OFF
public void getISOCommentCharacters(UnicodeSet set)
{
convert(m_ISOCommentSet_, set);
}
///CLOVER:ON
// package private inner class --------------------------------------
/**
* Algorithmic name class
*/
static final class AlgorithmName
{
// package private data members ----------------------------------
/**
* Constant type value of the different AlgorithmName
*/
static final int TYPE_0_ = 0;
static final int TYPE_1_ = 1;
// package private constructors ----------------------------------
/**
* Constructor
*/
AlgorithmName()
{
}
// package private methods ---------------------------------------
/**
* Sets the information for accessing the algorithmic names
* @param rangestart starting code point that lies within this name group
* @param rangeend end code point that lies within this name group
* @param type algorithm type. There's 2 kinds of algorithmic type. First
* which uses code point as part of its name and the other uses
* variant postfix strings
* @param variant algorithmic variant
* @return true if values are valid
*/
boolean setInfo(int rangestart, int rangeend, byte type, byte variant)
{
if (rangestart >= UCharacter.MIN_VALUE && rangestart <= rangeend
&& rangeend <= UCharacter.MAX_VALUE &&
(type == TYPE_0_ || type == TYPE_1_)) {
m_rangestart_ = rangestart;
m_rangeend_ = rangeend;
m_type_ = type;
m_variant_ = variant;
return true;
}
return false;
}
/**
* Sets the factor data
* @param factor Array of factor
* @return true if factors are valid
*/
boolean setFactor(char factor[])
{
if (factor.length == m_variant_) {
m_factor_ = factor;
return true;
}
return false;
}
/**
* Sets the name prefix
* @param prefix
* @return true if prefix is set
*/
boolean setPrefix(String prefix)
{
if (prefix != null && prefix.length() > 0) {
m_prefix_ = prefix;
return true;
}
return false;
}
/**
* Sets the variant factorized name data
* @param string variant factorized name data
* @return true if values are set
*/
boolean setFactorString(byte string[])
{
// factor and variant string can be empty for things like
// hanggul code points
m_factorstring_ = string;
return true;
}
/**
* Checks if code point lies in Algorithm object at index
* @param ch code point
*/
boolean contains(int ch)
{
return m_rangestart_ <= ch && ch <= m_rangeend_;
}
/**
* Appends algorithm name of code point into StringBuffer.
* Note this method does not check for validity of code point in Algorithm,
* result is undefined if code point does not belong in Algorithm.
* @param ch code point
* @param str StringBuffer to append to
*/
void appendName(int ch, StringBuffer str)
{
str.append(m_prefix_);
switch (m_type_)
{
case TYPE_0_:
// prefix followed by hex digits indicating variants
Utility.hex(ch, m_variant_, str);
break;
case TYPE_1_:
// prefix followed by factorized-elements
int offset = ch - m_rangestart_;
int indexes[] = m_utilIntBuffer_;
int factor;
// write elements according to the factors
// the factorized elements are determined by modulo
// arithmetic
synchronized (m_utilIntBuffer_) {
for (int i = m_variant_ - 1; i > 0; i --)
{
factor = m_factor_[i] & 0x00FF;
indexes[i] = offset % factor;
offset /= factor;
}
// we don't need to calculate the last modulus because
// start <= code <= end guarantees here that
// code <= factors[0]
indexes[0] = offset;
// joining up the factorized strings
str.append(getFactorString(indexes, m_variant_));
}
break;
}
}
/**
* Gets the character for the argument algorithmic name
* @return the algorithmic char or -1 otherwise.
*/
int getChar(String name)
{
int prefixlen = m_prefix_.length();
if (name.length() < prefixlen ||
!m_prefix_.equals(name.substring(0, prefixlen))) {
return -1;
}
switch (m_type_)
{
case TYPE_0_ :
try
{
int result = Integer.parseInt(name.substring(prefixlen),
16);
// does it fit into the range?
if (m_rangestart_ <= result && result <= m_rangeend_) {
return result;
}
}
catch (NumberFormatException e)
{
return -1;
}
break;
case TYPE_1_ :
// repetitative suffix name comparison done here
// offset is the character code - start
for (int ch = m_rangestart_; ch <= m_rangeend_; ch ++)
{
int offset = ch - m_rangestart_;
int indexes[] = m_utilIntBuffer_;
int factor;
// write elements according to the factors
// the factorized elements are determined by modulo
// arithmetic
synchronized (m_utilIntBuffer_) {
for (int i = m_variant_ - 1; i > 0; i --)
{
factor = m_factor_[i] & 0x00FF;
indexes[i] = offset % factor;
offset /= factor;
}
// we don't need to calculate the last modulus
// because start <= code <= end guarantees here that
// code <= factors[0]
indexes[0] = offset;
// joining up the factorized strings
if (compareFactorString(indexes, m_variant_, name,
prefixlen)) {
return ch;
}
}
}
}
return -1;
}
/**
* Adds all chars in the set of algorithmic names into the set.
* Equivalent to part of calcAlgNameSetsLengths.
* @param set int set to add the chars of the algorithm names into
* @param maxlength maximum length to compare to
* @return the length that is either maxlength of the length of this
* algorithm name if it is longer than maxlength
*/
int add(int set[], int maxlength)
{
// prefix length
int length = UCharacterName.add(set, m_prefix_);
switch (m_type_) {
case TYPE_0_ : {
// name = prefix + (range->variant times) hex-digits
// prefix
length += m_variant_;
/* synwee to check
* addString(set, (const char *)(range + 1))
+ range->variant;*/
break;
}
case TYPE_1_ : {
// name = prefix factorized-elements
// get the set and maximum factor suffix length for each
// factor
for (int i = m_variant_ - 1; i > 0; i --)
{
int maxfactorlength = 0;
int count = 0;
for (int factor = m_factor_[i]; factor > 0; -- factor) {
synchronized (m_utilStringBuffer_) {
m_utilStringBuffer_.delete(0,
m_utilStringBuffer_.length());
count
= UCharacterUtility.getNullTermByteSubString(
m_utilStringBuffer_,
m_factorstring_, count);
UCharacterName.add(set, m_utilStringBuffer_);
if (m_utilStringBuffer_.length()
> maxfactorlength)
{
maxfactorlength
= m_utilStringBuffer_.length();
}
}
}
length += maxfactorlength;
}
}
}
if (length > maxlength) {
return length;
}
return maxlength;
}
// private data members ------------------------------------------
/**
* Algorithmic data information
*/
private int m_rangestart_;
private int m_rangeend_;
private byte m_type_;
private byte m_variant_;
private char m_factor_[];
private String m_prefix_;
private byte m_factorstring_[];
/**
* Utility StringBuffer
*/
private StringBuffer m_utilStringBuffer_ = new StringBuffer();
/**
* Utility int buffer
*/
private int m_utilIntBuffer_[] = new int[256];
// private methods -----------------------------------------------
/**
* Gets the indexth string in each of the argument factor block
* @param index array with each index corresponding to each factor block
* @param length length of the array index
* @return the combined string of the array of indexth factor string in
* factor block
*/
private String getFactorString(int index[], int length)
{
int size = m_factor_.length;
if (index == null || length != size) {
return null;
}
synchronized (m_utilStringBuffer_) {
m_utilStringBuffer_.delete(0, m_utilStringBuffer_.length());
int count = 0;
int factor;
size --;
for (int i = 0; i <= size; i ++) {
factor = m_factor_[i];
count = UCharacterUtility.skipNullTermByteSubString(
m_factorstring_, count, index[i]);
count = UCharacterUtility.getNullTermByteSubString(
m_utilStringBuffer_, m_factorstring_,
count);
if (i != size) {
count = UCharacterUtility.skipNullTermByteSubString(
m_factorstring_, count,
factor - index[i] - 1);
}
}
return m_utilStringBuffer_.toString();
}
}
/**
* Compares the indexth string in each of the argument factor block with
* the argument string
* @param index array with each index corresponding to each factor block
* @param length index array length
* @param str string to compare with
* @param offset of str to start comparison
* @return true if string matches
*/
private boolean compareFactorString(int index[], int length, String str,
int offset)
{
int size = m_factor_.length;
if (index == null || length != size)
return false;
int count = 0;
int strcount = offset;
int factor;
size --;
for (int i = 0; i <= size; i ++)
{
factor = m_factor_[i];
count = UCharacterUtility.skipNullTermByteSubString(
m_factorstring_, count, index[i]);
strcount = UCharacterUtility.compareNullTermByteSubString(str,
m_factorstring_, strcount, count);
if (strcount < 0) {
return false;
}
if (i != size) {
count = UCharacterUtility.skipNullTermByteSubString(
m_factorstring_, count, factor - index[i]);
}
}
if (strcount != str.length()) {
return false;
}
return true;
}
}
// package private data members --------------------------------------
/**
* Size of each groups
*/
int m_groupsize_ = 0;
// package private methods --------------------------------------------
/**
* Sets the token data
* @param token array of tokens
* @param tokenstring array of string values of the tokens
* @return false if there is a data error
*/
boolean setToken(char token[], byte tokenstring[])
{
if (token != null && tokenstring != null && token.length > 0 &&
tokenstring.length > 0) {
m_tokentable_ = token;
m_tokenstring_ = tokenstring;
return true;
}
return false;
}
/**
* Set the algorithm name information array
* @param alg Algorithm information array
* @return true if the group string offset has been set correctly
*/
boolean setAlgorithm(AlgorithmName alg[])
{
if (alg != null && alg.length != 0) {
m_algorithm_ = alg;
return true;
}
return false;
}
/**
* Sets the number of group and size of each group in number of char
* @param count number of groups
* @param size size of group in char
* @return true if group size is set correctly
*/
boolean setGroupCountSize(int count, int size)
{
if (count <= 0 || size <= 0) {
return false;
}
m_groupcount_ = count;
m_groupsize_ = size;
return true;
}
/**
* Sets the group name data
* @param group index information array
* @param groupstring name information array
* @return false if there is a data error
*/
boolean setGroup(char group[], byte groupstring[])
{
if (group != null && groupstring != null && group.length > 0 &&
groupstring.length > 0) {
m_groupinfo_ = group;
m_groupstring_ = groupstring;
return true;
}
return false;
}
// private data members ----------------------------------------------
/**
* Data used in unames.icu
*/
private char m_tokentable_[];
private byte m_tokenstring_[];
private char m_groupinfo_[];
private byte m_groupstring_[];
private AlgorithmName m_algorithm_[];
/**
* Group use. Note - access must be synchronized.
*/
private char m_groupoffsets_[] = new char[LINES_PER_GROUP_ + 1];
private char m_grouplengths_[] = new char[LINES_PER_GROUP_ + 1];
/**
* Default name of the name datafile
*/
private static final String NAME_FILE_NAME_ = ICUResourceBundle.ICU_BUNDLE+"/unames.icu";
/**
* Shift count to retrieve group information
*/
private static final int GROUP_SHIFT_ = 5;
/**
* Mask to retrieve the offset for a particular character within a group
*/
private static final int GROUP_MASK_ = LINES_PER_GROUP_ - 1;
/**
* Default buffer size of datafile
*/
private static final int NAME_BUFFER_SIZE_ = 100000;
/**
* Position of offsethigh in group information array
*/
private static final int OFFSET_HIGH_OFFSET_ = 1;
/**
* Position of offsetlow in group information array
*/
private static final int OFFSET_LOW_OFFSET_ = 2;
/**
* Double nibble indicator, any nibble > this number has to be combined
* with its following nibble
*/
private static final int SINGLE_NIBBLE_MAX_ = 11;
/*
* Maximum length of character names (regular & 1.0).
*/
//private static int MAX_NAME_LENGTH_ = 0;
/*
* Maximum length of ISO comments.
*/
//private static int MAX_ISO_COMMENT_LENGTH_ = 0;
/**
* Set of chars used in character names (regular & 1.0).
* Chars are platform-dependent (can be EBCDIC).
*/
private int m_nameSet_[] = new int[8];
/**
* Set of chars used in ISO comments. (regular & 1.0).
* Chars are platform-dependent (can be EBCDIC).
*/
private int m_ISOCommentSet_[] = new int[8];
/**
* Utility StringBuffer
*/
private StringBuffer m_utilStringBuffer_ = new StringBuffer();
/**
* Utility int buffer
*/
private int m_utilIntBuffer_[] = new int[2];
/**
* Maximum ISO comment length
*/
private int m_maxISOCommentLength_;
/**
* Maximum name length
*/
private int m_maxNameLength_;
/**
* Singleton instance
*/
private static UCharacterName INSTANCE_ = null;
/**
* Type names used for extended names
*/
private static final String TYPE_NAMES_[] = {"unassigned",
"uppercase letter",
"lowercase letter",
"titlecase letter",
"modifier letter",
"other letter",
"non spacing mark",
"enclosing mark",
"combining spacing mark",
"decimal digit number",
"letter number",
"other number",
"space separator",
"line separator",
"paragraph separator",
"control",
"format",
"private use area",
"surrogate",
"dash punctuation",
"start punctuation",
"end punctuation",
"connector punctuation",
"other punctuation",
"math symbol",
"currency symbol",
"modifier symbol",
"other symbol",
"initial punctuation",
"final punctuation",
"noncharacter",
"lead surrogate",
"trail surrogate"};
/**
* Unknown type name
*/
private static final String UNKNOWN_TYPE_NAME_ = "unknown";
/**
* Not a character type
*/
private static final int NON_CHARACTER_
= UCharacterCategory.CHAR_CATEGORY_COUNT;
/**
* Lead surrogate type
*/
private static final int LEAD_SURROGATE_
= UCharacterCategory.CHAR_CATEGORY_COUNT + 1;
/**
* Trail surrogate type
*/
private static final int TRAIL_SURROGATE_
= UCharacterCategory.CHAR_CATEGORY_COUNT + 2;
/**
* Extended category count
*/
static final int EXTENDED_CATEGORY_
= UCharacterCategory.CHAR_CATEGORY_COUNT + 3;
// private constructor ------------------------------------------------
/**
*
Remember the previous code point
* (initial 0). For each code point in the string, encode the
* difference with the previous one. Similar to a UTF, the length of
* the byte sequence is encoded in the lead bytes. Unlike a UTF, the
* trail byte values may overlap with lead/single byte values. The
* signedness of the difference must be encoded as the most
* significant part.
* There are two errors in SpecialCasing.txt.
* 1. Missing semicolons on two lines. ... [irrelevant for ICU]
* 2. An incorrect context definition. Correct as follows:
* < 0307; ; 0307; 0307; tr After_Soft_Dotted; # COMBINING DOT ABOVE
* < 0307; ; 0307; 0307; az After_Soft_Dotted; # COMBINING DOT ABOVE
* ---
* > 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
* > 0307; ; 0307; 0307; az After_I; # COMBINING DOT ABOVE
* where the context After_I is defined as:
* The last preceding base character was an uppercase I, and there is no
* intervening combining character class 230 (ABOVE).
*
*
* Note that SpecialCasing.txt even in Unicode 3.2 described the condition as:
*
* # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
* # This matches the behavior of the canonically equivalent I-dot_above
*
* See also the description in this place in older versions of uchar.c (revision 1.100).
*
* Markus W. Scherer 2003-feb-15
*/
/* Is preceded by base character 'I' with no intervening cc=230 ? */
private final boolean isPrecededBy_I(ContextIterator iter) {
int c;
int dotType;
if(iter==null) {
return false;
}
for(iter.reset(-1); (c=iter.next())>=0;) {
if(c==0x49) {
return true; /* preceded by I */
}
dotType=getDotType(c);
if(dotType!=OTHER_ACCENT) {
return false; /* preceded by different base character (not I), or intervening cc==230 */
}
}
return false; /* not preceded by I */
}
/* Is followed by one or more cc==230 ? */
private final boolean isFollowedByMoreAbove(ContextIterator iter) {
int c;
int dotType;
if(iter==null) {
return false;
}
for(iter.reset(1); (c=iter.next())>=0;) {
dotType=getDotType(c);
if(dotType==ABOVE) {
return true; /* at least one cc==230 following */
} else if(dotType!=OTHER_ACCENT) {
return false; /* next base character, no more cc==230 following */
}
}
return false; /* no more cc==230 following */
}
/* Is followed by a dot above (without cc==230 in between) ? */
private final boolean isFollowedByDotAbove(ContextIterator iter) {
int c;
int dotType;
if(iter==null) {
return false;
}
for(iter.reset(1); (c=iter.next())>=0; ) {
if(c==0x307) {
return true;
}
dotType=getDotType(c);
if(dotType!=OTHER_ACCENT) {
return false; /* next base character or cc==230 in between */
}
}
return false; /* no dot above following */
}
private static final String
iDot= "i\u0307",
jDot= "j\u0307",
iOgonekDot= "\u012f\u0307",
iDotGrave= "i\u0307\u0300",
iDotAcute= "i\u0307\u0301",
iDotTilde= "i\u0307\u0303";
/**
* Get the full lowercase mapping for c.
*
* @param c Character to be mapped.
* @param iter Character iterator, used for context-sensitive mappings.
* See ContextIterator for details.
* If iter==null then a context-independent result is returned.
* @param out If the mapping result is a string, then it is appended to out.
* @param locale Locale ID for locale-dependent mappings.
* @param locCache Initialize locCache[0] to 0; may be used to cache the result of parsing
* the locale ID for subsequent calls.
* Can be null.
* @return Output code point or string length, see MAX_STRING_LENGTH.
*
* @see ContextIterator
* @see #MAX_STRING_LENGTH
* @internal
*/
public final int toFullLower(int c, ContextIterator iter,
StringBuffer out,
ULocale locale, int[] locCache) {
int result, props;
result=c;
props=trie.getCodePointValue(c);
if(!propsHasException(props)) {
if(getTypeFromProps(props)>=UPPER) {
result=c+getDelta(props);
}
} else {
int excOffset=getExceptionsOffset(props), excOffset2;
int excWord=exceptions[excOffset++];
int full;
excOffset2=excOffset;
if((excWord&EXC_CONDITIONAL_SPECIAL)!=0) {
/* use hardcoded conditions and mappings */
int loc=getCaseLocale(locale, locCache);
/*
* Test for conditional mappings first
* (otherwise the unconditional default mappings are always taken),
* then test for characters that have unconditional mappings in SpecialCasing.txt,
* then get the UnicodeData.txt mappings.
*/
if( loc==LOC_LITHUANIAN &&
/* base characters, find accents above */
(((c==0x49 || c==0x4a || c==0x12e) &&
isFollowedByMoreAbove(iter)) ||
/* precomposed with accent above, no need to find one */
(c==0xcc || c==0xcd || c==0x128))
) {
/*
# Lithuanian
# Lithuanian retains the dot in a lowercase i when followed by accents.
# Introduce an explicit dot above when lowercasing capital I's and J's
# whenever there are more accents above.
# (of the accents used in Lithuanian: grave, acute, tilde above, and ogonek)
0049; 0069 0307; 0049; 0049; lt More_Above; # LATIN CAPITAL LETTER I
004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J
012E; 012F 0307; 012E; 012E; lt More_Above; # LATIN CAPITAL LETTER I WITH OGONEK
00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE
00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE
0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE
*/
switch(c) {
case 0x49: /* LATIN CAPITAL LETTER I */
out.append(iDot);
return 2;
case 0x4a: /* LATIN CAPITAL LETTER J */
out.append(jDot);
return 2;
case 0x12e: /* LATIN CAPITAL LETTER I WITH OGONEK */
out.append(iOgonekDot);
return 2;
case 0xcc: /* LATIN CAPITAL LETTER I WITH GRAVE */
out.append(iDotGrave);
return 3;
case 0xcd: /* LATIN CAPITAL LETTER I WITH ACUTE */
out.append(iDotAcute);
return 3;
case 0x128: /* LATIN CAPITAL LETTER I WITH TILDE */
out.append(iDotTilde);
return 3;
default:
return 0; /* will not occur */
}
/* # Turkish and Azeri */
} else if(loc==LOC_TURKISH && c==0x130) {
/*
# I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
# The following rules handle those cases.
0130; 0069; 0130; 0130; tr # LATIN CAPITAL LETTER I WITH DOT ABOVE
0130; 0069; 0130; 0130; az # LATIN CAPITAL LETTER I WITH DOT ABOVE
*/
return 0x69;
} else if(loc==LOC_TURKISH && c==0x307 && isPrecededBy_I(iter)) {
/*
# When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
# This matches the behavior of the canonically equivalent I-dot_above
0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
0307; ; 0307; 0307; az After_I; # COMBINING DOT ABOVE
*/
return 0; /* remove the dot (continue without output) */
} else if(loc==LOC_TURKISH && c==0x49 && !isFollowedByDotAbove(iter)) {
/*
# When lowercasing, unless an I is before a dot_above, it turns into a dotless i.
0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I
0049; 0131; 0049; 0049; az Not_Before_Dot; # LATIN CAPITAL LETTER I
*/
return 0x131;
} else if(c==0x130) {
/*
# Preserve canonical equivalence for I with dot. Turkic is handled below.
0130; 0069 0307; 0130; 0130; # LATIN CAPITAL LETTER I WITH DOT ABOVE
*/
out.append(iDot);
return 2;
} else if( c==0x3a3 &&
!isFollowedByCasedLetter(iter, 1) &&
isFollowedByCasedLetter(iter, -1) /* -1=preceded */
) {
/* greek capital sigma maps depending on surrounding cased letters (see SpecialCasing.txt) */
/*
# Special case for final form of sigma
03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA
*/
return 0x3c2; /* greek small final sigma */
} else {
/* no known conditional special case mapping, use a normal mapping */
}
} else if(hasSlot(excWord, EXC_FULL_MAPPINGS)) {
long value=getSlotValueAndOffset(excWord, EXC_FULL_MAPPINGS, excOffset);
full=(int)value&FULL_LOWER;
if(full!=0) {
/* start of full case mapping strings */
excOffset=(int)(value>>32)+1;
/* set the output pointer to the lowercase mapping */
out.append(new String(exceptions, excOffset, full));
/* return the string length */
return full;
}
}
if(hasSlot(excWord, EXC_LOWER)) {
result=getSlotValue(excWord, EXC_LOWER, excOffset2);
}
}
return (result==c) ? ~result : result;
}
/* internal */
private final int toUpperOrTitle(int c, ContextIterator iter,
StringBuffer out,
ULocale locale, int[] locCache,
boolean upperNotTitle) {
int result;
int props;
result=c;
props=trie.getCodePointValue(c);
if(!propsHasException(props)) {
if(getTypeFromProps(props)==LOWER) {
result=c+getDelta(props);
}
} else {
int excOffset=getExceptionsOffset(props), excOffset2;
int excWord=exceptions[excOffset++];
int full, index;
excOffset2=excOffset;
if((excWord&EXC_CONDITIONAL_SPECIAL)!=0) {
/* use hardcoded conditions and mappings */
int loc=getCaseLocale(locale, locCache);
if(loc==LOC_TURKISH && c==0x69) {
/*
# Turkish and Azeri
# I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
# The following rules handle those cases.
# When uppercasing, i turns into a dotted capital I
0069; 0069; 0130; 0130; tr; # LATIN SMALL LETTER I
0069; 0069; 0130; 0130; az; # LATIN SMALL LETTER I
*/
return 0x130;
} else if(loc==LOC_LITHUANIAN && c==0x307 && isPrecededBySoftDotted(iter)) {
/*
# Lithuanian
# Lithuanian retains the dot in a lowercase i when followed by accents.
# Remove DOT ABOVE after "i" with upper or titlecase
0307; 0307; ; ; lt After_Soft_Dotted; # COMBINING DOT ABOVE
*/
return 0; /* remove the dot (continue without output) */
} else {
/* no known conditional special case mapping, use a normal mapping */
}
} else if(hasSlot(excWord, EXC_FULL_MAPPINGS)) {
long value=getSlotValueAndOffset(excWord, EXC_FULL_MAPPINGS, excOffset);
full=(int)value&0xffff;
/* start of full case mapping strings */
excOffset=(int)(value>>32)+1;
/* skip the lowercase and case-folding result strings */
excOffset+=full&FULL_LOWER;
full>>=4;
excOffset+=full&0xf;
full>>=4;
if(upperNotTitle) {
full&=0xf;
} else {
/* skip the uppercase result string */
excOffset+=full&0xf;
full=(full>>4)&0xf;
}
if(full!=0) {
/* set the output pointer to the result string */
out.append(new String(exceptions, excOffset, full));
/* return the string length */
return full;
}
}
if(!upperNotTitle && hasSlot(excWord, EXC_TITLE)) {
index=EXC_TITLE;
} else if(hasSlot(excWord, EXC_UPPER)) {
/* here, titlecase is same as uppercase */
index=EXC_UPPER;
} else {
return ~c;
}
result=getSlotValue(excWord, index, excOffset2);
}
return (result==c) ? ~result : result;
}
public final int toFullUpper(int c, ContextIterator iter,
StringBuffer out,
ULocale locale, int[] locCache) {
return toUpperOrTitle(c, iter, out, locale, locCache, true);
}
public final int toFullTitle(int c, ContextIterator iter,
StringBuffer out,
ULocale locale, int[] locCache) {
return toUpperOrTitle(c, iter, out, locale, locCache, false);
}
/* case folding ------------------------------------------------------------- */
/*
* Case folding is similar to lowercasing.
* The result may be a simple mapping, i.e., a single code point, or
* a full mapping, i.e., a string.
* If the case folding for a code point is the same as its simple (1:1) lowercase mapping,
* then only the lowercase mapping is stored.
*
* Some special cases are hardcoded because their conditions cannot be
* parsed and processed from CaseFolding.txt.
*
* Unicode 3.2 CaseFolding.txt specifies for its status field:
# C: common case folding, common mappings shared by both simple and full mappings.
# F: full case folding, mappings that cause strings to grow in length. Multiple characters are separated by spaces.
# S: simple case folding, mappings to single characters where different from F.
# T: special case for uppercase I and dotted uppercase I
# - For non-Turkic languages, this mapping is normally not used.
# - For Turkic languages (tr, az), this mapping can be used instead of the normal mapping for these characters.
#
# Usage:
# A. To do a simple case folding, use the mappings with status C + S.
# B. To do a full case folding, use the mappings with status C + F.
#
# The mappings with status T can be used or omitted depending on the desired case-folding
# behavior. (The default option is to exclude them.)
* Unicode 3.2 has 'T' mappings as follows:
0049; T; 0131; # LATIN CAPITAL LETTER I
0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE
* while the default mappings for these code points are:
0049; C; 0069; # LATIN CAPITAL LETTER I
0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE
* U+0130 has no simple case folding (simple-case-folds to itself).
*/
/**
* Bit mask for getting just the options from a string compare options word
* that are relevant for case folding (of a single string or code point).
* @internal
*/
private static final int FOLD_CASE_OPTIONS_MASK = 0xff;
/* return the simple case folding mapping for c */
public final int fold(int c, int options) {
int props=trie.getCodePointValue(c);
if(!propsHasException(props)) {
if(getTypeFromProps(props)>=UPPER) {
c+=getDelta(props);
}
} else {
int excOffset=getExceptionsOffset(props);
int excWord=exceptions[excOffset++];
int index;
if((excWord&EXC_CONDITIONAL_FOLD)!=0) {
/* special case folding mappings, hardcoded */
if((options&FOLD_CASE_OPTIONS_MASK)==UCharacter.FOLD_CASE_DEFAULT) {
/* default mappings */
if(c==0x49) {
/* 0049; C; 0069; # LATIN CAPITAL LETTER I */
return 0x69;
} else if(c==0x130) {
/* no simple case folding for U+0130 */
return c;
}
} else {
/* Turkic mappings */
if(c==0x49) {
/* 0049; T; 0131; # LATIN CAPITAL LETTER I */
return 0x131;
} else if(c==0x130) {
/* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
return 0x69;
}
}
}
if(hasSlot(excWord, EXC_FOLD)) {
index=EXC_FOLD;
} else if(hasSlot(excWord, EXC_LOWER)) {
index=EXC_LOWER;
} else {
return c;
}
c=getSlotValue(excWord, index, excOffset);
}
return c;
}
/*
* Issue for canonical caseless match (UAX #21):
* Turkic casefolding (using "T" mappings in CaseFolding.txt) does not preserve
* canonical equivalence, unlike default-option casefolding.
* For example, I-grave and I + grave fold to strings that are not canonically
* equivalent.
* For more details, see the comment in unorm_compare() in unorm.cpp
* and the intermediate prototype changes for Jitterbug 2021.
* (For example, revision 1.104 of uchar.c and 1.4 of CaseFolding.txt.)
*
* This did not get fixed because it appears that it is not possible to fix
* it for uppercase and lowercase characters (I-grave vs. i-grave)
* together in a way that they still fold to common result strings.
*/
public final int toFullFolding(int c, StringBuffer out, int options) {
int result;
int props;
result=c;
props=trie.getCodePointValue(c);
if(!propsHasException(props)) {
if(getTypeFromProps(props)>=UPPER) {
result=c+getDelta(props);
}
} else {
int excOffset=getExceptionsOffset(props), excOffset2;
int excWord=exceptions[excOffset++];
int full, index;
excOffset2=excOffset;
if((excWord&EXC_CONDITIONAL_FOLD)!=0) {
/* use hardcoded conditions and mappings */
if((options&FOLD_CASE_OPTIONS_MASK)==UCharacter.FOLD_CASE_DEFAULT) {
/* default mappings */
if(c==0x49) {
/* 0049; C; 0069; # LATIN CAPITAL LETTER I */
return 0x69;
} else if(c==0x130) {
/* 0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
out.append(iDot);
return 2;
}
} else {
/* Turkic mappings */
if(c==0x49) {
/* 0049; T; 0131; # LATIN CAPITAL LETTER I */
return 0x131;
} else if(c==0x130) {
/* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
return 0x69;
}
}
} else if(hasSlot(excWord, EXC_FULL_MAPPINGS)) {
long value=getSlotValueAndOffset(excWord, EXC_FULL_MAPPINGS, excOffset);
full=(int)value&0xffff;
/* start of full case mapping strings */
excOffset=(int)(value>>32)+1;
/* skip the lowercase result string */
excOffset+=full&FULL_LOWER;
full=(full>>4)&0xf;
if(full!=0) {
/* set the output pointer to the result string */
out.append(new String(exceptions, excOffset, full));
/* return the string length */
return full;
}
}
if(hasSlot(excWord, EXC_FOLD)) {
index=EXC_FOLD;
} else if(hasSlot(excWord, EXC_LOWER)) {
index=EXC_LOWER;
} else {
return ~c;
}
result=getSlotValue(excWord, index, excOffset2);
}
return (result==c) ? ~result : result;
}
// data members -------------------------------------------------------- ***
private int indexes[];
private char exceptions[];
private char unfold[];
private CharTrie trie;
// data format constants ----------------------------------------------- ***
private static final String DATA_NAME="ucase";
private static final String DATA_TYPE="icu";
private static final String DATA_FILE_NAME=DATA_NAME+"."+DATA_TYPE;
/* format "cAsE" */
private static final byte FMT[]={ 0x63, 0x41, 0x53, 0x45 };
/* indexes into indexes[] */
private static final int IX_INDEX_TOP=0;
//private static final int IX_LENGTH=1;
//private static final int IX_TRIE_SIZE=2;
private static final int IX_EXC_LENGTH=3;
private static final int IX_UNFOLD_LENGTH=4;
//private static final int IX_MAX_FULL_LENGTH=15;
private static final int IX_TOP=16;
// definitions for 16-bit case properties word ------------------------- ***
/* 2-bit constants for types of cased characters */
public static final int TYPE_MASK=3;
public static final int NONE=0;
public static final int LOWER=1;
public static final int UPPER=2;
public static final int TITLE=3;
private static final int getTypeFromProps(int props) {
return props&TYPE_MASK;
}
private static final int SENSITIVE= 4;
private static final int EXCEPTION= 8;
private static final int DOT_MASK= 0x30;
//private static final int NO_DOT= 0; /* normal characters with cc=0 */
private static final int SOFT_DOTTED= 0x10; /* soft-dotted characters with cc=0 */
private static final int ABOVE= 0x20; /* "above" accents with cc=230 */
private static final int OTHER_ACCENT= 0x30; /* other accent character (0TimeZone.getTimeZone() to construct the
* corresponding TimeZone object.
* @param country a two-letter ISO 3166 country code, or null
* to return zones not associated with any country
* @return an array of IDs for system TimeZones in the given
* country. If there are none, return a zero-length array.
*/
public static synchronized String[] getAvailableIDs(String country) {
if(!getOlsonMeta()){
return EMPTY;
}
try{
UResourceBundle top = (ICUResourceBundle)ICUResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "zoneinfo", ICUResourceBundle.ICU_DATA_CLASS_LOADER);
UResourceBundle regions = top.get(kREGIONS);
UResourceBundle names = top.get(kNAMES); // dereference Zones section
UResourceBundle temp = regions.get(country);
int[] vector = temp.getIntVector();
if (ASSERT) Assert.assrt("vector.length>0", vector.length>0);
String[] ret = new String[vector.length];
for (int i=0; icountEquivalentIDs(id). For
* some value of 'index', the returned value will be equal to the
* given id. If the given id is not a valid system time zone, or
* if 'index' is out of range, then returns an empty string.
* @param id a system time zone ID
* @param index a value from 0 to n-1, where n is the value
* returned by countEquivalentIDs(id)
* @return the ID of the index-th zone in the equivalency group
* containing 'id', or an empty string if 'id' is not a valid
* system ID or 'index' is out of range
* @see #countEquivalentIDs
*/
public static synchronized String getEquivalentID(String id, int index) {
String result="";
UResourceBundle res = openOlsonResource(id);
if (res != null) {
int zone = -1;
int size = res.getSize();
if (size == 4 || size == 6) {
UResourceBundle r = res.get(size-1);
int[] v = r.getIntVector();
if (index >= 0 && index < v.length) {
zone = v[index];
}
}
if (zone >= 0) {
try {
UResourceBundle top = UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "zoneinfo",
ICUResourceBundle.ICU_DATA_CLASS_LOADER);
UResourceBundle ares = top.get(kNAMES); // dereference Zones section
result = ares.getString(zone);
} catch (MissingResourceException e) {
result = "";
}
}
}
return result;
}
private static String[] getCanonicalInfo(String id) {
if (id == null || id.length() == 0) {
return null;
}
if (canonicalMap == null) {
Map m = new HashMap();
Set s = new HashSet();
try {
UResourceBundle supplementalDataBundle = UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "supplementalData", ICUResourceBundle.ICU_DATA_CLASS_LOADER);
UResourceBundle zoneFormatting = supplementalDataBundle.get("zoneFormatting");
UResourceBundleIterator it = zoneFormatting.getIterator();
while ( it.hasNext()) {
UResourceBundle temp = it.next();
int resourceType = temp.getType();
switch(resourceType) {
case UResourceBundle.TABLE:
String [] result = { "", "" };
UResourceBundle zoneInfo = temp;
String canonicalID = zoneInfo.getKey().replace(':','/');
String territory = zoneInfo.get("territory").getString();
result[0] = canonicalID;
if ( territory.equals("001")) {
result[1] = null;
}
else {
result[1] = territory;
}
m.put(canonicalID,result);
try {
UResourceBundle aliasBundle = zoneInfo.get("aliases");
String [] aliases = aliasBundle.getStringArray();
for (int i=0 ; i
* Internally, icu4c's utrie_enum performs all iterations in its body. In Java
* sense, the caller will have to pass a object with a callback function
* UTrieEnumRange(const void *context, UChar32 start, UChar32 limit,
* uint32_t value) into utrie_enum. utrie_enum will then find ranges of
* codepoints with the same value as determined by
* UTrieEnumValue(const void *context, uint32_t value). for each range,
* utrie_enum calls the callback function to perform a task. In this way,
* icu4c performs the iteration within utrie_enum.
* To follow the JDK model, icu4j is slightly different from icu4c.
* Instead of requesting the caller to implement an object for a callback.
* The caller will have to implement a subclass of TrieIterator, fleshing out
* the method extract(int) (equivalent to UTrieEnumValue). Independent of icu4j,
* the caller will have to code his own iteration and flesh out the task
* (equivalent to UTrieEnumRange) to be performed in the iteration loop.
*
* In Java :
*
* class TrieIteratorImpl extends TrieIterator{
* public TrieIteratorImpl(Trie data){
* super(data);
* }
* public int extract(int value){
* // port the implementation of _enumPropertyStartsValue here
* }
* }
* ....
* TrieIterator fcdIter = new TrieIteratorImpl(fcdTrieImpl.fcdTrie);
* while(fcdIter.next(result)) {
* // port the implementation of _enumPropertyStartsRange
* }
*
*
* // utrie_enum(&fcdTrie, NULL, _enumPropertyStartsRange, set);
* TrieIterator fcdIter = new TrieIterator(fcdTrieImpl.fcdTrie);
* while(fcdIter.next(result)){
* set.add(result.start);
* }
* CalendarAstronomer is a class that can perform the calculations to
* determine the positions of the sun and moon, the time of sunrise and
* sunset, and other astronomy-related data. The calculations it performs
* are in some cases quite complicated, and this utility class saves you
* the trouble of worrying about them.
* CalendarAstronomer
* object has a time property that determines the date
* and time for which its calculations are performed. You can set and
* retrieve this property with {@link #setDate setDate}, {@link #getDate getDate}
* and related methods.
* CalendarAstronomer object that is initialized to
* the current date and time.
* @internal
*/
public CalendarAstronomer() {
this(System.currentTimeMillis());
}
/**
* Construct a new CalendarAstronomer object that is initialized to
* the specified date and time.
* @internal
*/
public CalendarAstronomer(Date d) {
this(d.getTime());
}
/**
* Construct a new CalendarAstronomer object that is initialized to
* the specified time. The time is expressed as a number of milliseconds since
* January 1, 1970 AD (Gregorian).
*
* @see java.util.Date#getTime()
* @internal
*/
public CalendarAstronomer(long aTime) {
time = aTime;
}
/**
* Construct a new CalendarAstronomer object with the given
* latitude and longitude. The object's time is set to the current
* date and time.
* CalendarAstronomer object. All
* astronomical calculations are performed based on this time setting.
*
* @param aTime the date and time, expressed as the number of milliseconds since
* 1/1/1970 0:00 GMT (Gregorian).
*
* @see #setDate
* @see #getTime
* @internal
*/
public void setTime(long aTime) {
time = aTime;
clearCache();
}
/**
* Set the current date and time of this CalendarAstronomer object. All
* astronomical calculations are performed based on this time setting.
*
* @param date the time and date, expressed as a Date object.
*
* @see #setTime
* @see #getDate
* @internal
*/
public void setDate(Date date) {
setTime(date.getTime());
}
/**
* Set the current date and time of this CalendarAstronomer object. All
* astronomical calculations are performed based on this time setting.
*
* @param jdn the desired time, expressed as a "julian day number",
* which is the number of elapsed days since
* 1/1/4713 BC (Julian), 12:00 GMT. Note that julian day
* numbers start at noon. To get the jdn for
* the corresponding midnight, subtract 0.5.
*
* @see #getJulianDay
* @see #JULIAN_EPOCH_MS
* @internal
*/
public void setJulianDay(double jdn) {
time = (long)(jdn * DAY_MS) + JULIAN_EPOCH_MS;
clearCache();
julianDay = jdn;
}
/**
* Get the current time of this CalendarAstronomer object,
* represented as the number of milliseconds since
* 1/1/1970 AD 0:00 GMT (Gregorian).
*
* @see #setTime
* @see #getDate
* @internal
*/
public long getTime() {
return time;
}
/**
* Get the current time of this CalendarAstronomer object,
* represented as a Date object.
*
* @see #setDate
* @see #getTime
* @internal
*/
public Date getDate() {
return new Date(time);
}
/**
* Get the current time of this CalendarAstronomer object,
* expressed as a "julian day number", which is the number of elapsed
* days since 1/1/4713 BC (Julian), 12:00 GMT.
*
* @see #setJulianDay
* @see #JULIAN_EPOCH_MS
* @internal
*/
public double getJulianDay() {
if (julianDay == INVALID) {
julianDay = (double)(time - JULIAN_EPOCH_MS) / (double)DAY_MS;
}
return julianDay;
}
/**
* Return this object's time expressed in julian centuries:
* the number of centuries after 1/1/1900 AD, 12:00 GMT
*
* @see #getJulianDay
* @internal
*/
public double getJulianCentury() {
if (julianCentury == INVALID) {
julianCentury = (getJulianDay() - 2415020.0) / 36525;
}
return julianCentury;
}
/**
* Returns the current Greenwich sidereal time, measured in hours
* @internal
*/
public double getGreenwichSidereal() {
if (siderealTime == INVALID) {
// See page 86 of "Practial Astronomy with your Calculator",
// by Peter Duffet-Smith, for details on the algorithm.
double UT = normalize((double)time/HOUR_MS, 24);
siderealTime = normalize(getSiderealOffset() + UT*1.002737909, 24);
}
return siderealTime;
}
private double getSiderealOffset() {
if (siderealT0 == INVALID) {
double JD = Math.floor(getJulianDay() - 0.5) + 0.5;
double S = JD - 2451545.0;
double T = S / 36525.0;
siderealT0 = normalize(6.697374558 + 2400.051336*T + 0.000025862*T*T, 24);
}
return siderealT0;
}
/**
* Returns the current local sidereal time, measured in hours
* @internal
*/
public double getLocalSidereal() {
return normalize(getGreenwichSidereal() + (double)fGmtOffset/HOUR_MS, 24);
}
/**
* Converts local sidereal time to Universal Time.
*
* @param lst The Local Sidereal Time, in hours since sidereal midnight
* on this object's current date.
*
* @return The corresponding Universal Time, in milliseconds since
* 1 Jan 1970, GMT.
*/
private long lstToUT(double lst) {
// Convert to local mean time
double lt = normalize((lst - getSiderealOffset()) * 0.9972695663, 24);
// Then find local midnight on this day
long base = DAY_MS * ((time + fGmtOffset)/DAY_MS) - fGmtOffset;
//out(" lt =" + lt + " hours");
//out(" base=" + new Date(base));
return base + (long)(lt * HOUR_MS);
}
//-------------------------------------------------------------------------
// Coordinate transformations, all based on the current time of this object
//-------------------------------------------------------------------------
/**
* Convert from ecliptic to equatorial coordinates.
*
* @param ecliptic A point in the sky in ecliptic coordinates.
* @return The corresponding point in equatorial coordinates.
* @internal
*/
public final Equatorial eclipticToEquatorial(Ecliptic ecliptic)
{
return eclipticToEquatorial(ecliptic.longitude, ecliptic.latitude);
}
/**
* Convert from ecliptic to equatorial coordinates.
*
* @param eclipLong The ecliptic longitude
* @param eclipLat The ecliptic latitude
*
* @return The corresponding point in equatorial coordinates.
* @internal
*/
public final Equatorial eclipticToEquatorial(double eclipLong, double eclipLat)
{
// See page 42 of "Practial Astronomy with your Calculator",
// by Peter Duffet-Smith, for details on the algorithm.
double obliq = eclipticObliquity();
double sinE = Math.sin(obliq);
double cosE = Math.cos(obliq);
double sinL = Math.sin(eclipLong);
double cosL = Math.cos(eclipLong);
double sinB = Math.sin(eclipLat);
double cosB = Math.cos(eclipLat);
double tanB = Math.tan(eclipLat);
return new Equatorial(Math.atan2(sinL*cosE - tanB*sinE, cosL),
Math.asin(sinB*cosE + cosB*sinE*sinL) );
}
/**
* Convert from ecliptic longitude to equatorial coordinates.
*
* @param eclipLong The ecliptic longitude
*
* @return The corresponding point in equatorial coordinates.
* @internal
*/
public final Equatorial eclipticToEquatorial(double eclipLong)
{
return eclipticToEquatorial(eclipLong, 0); // TODO: optimize
}
/**
* @internal
*/
public Horizon eclipticToHorizon(double eclipLong)
{
Equatorial equatorial = eclipticToEquatorial(eclipLong);
double H = getLocalSidereal()*PI/12 - equatorial.ascension; // Hour-angle
double sinH = Math.sin(H);
double cosH = Math.cos(H);
double sinD = Math.sin(equatorial.declination);
double cosD = Math.cos(equatorial.declination);
double sinL = Math.sin(fLatitude);
double cosL = Math.cos(fLatitude);
double altitude = Math.asin(sinD*sinL + cosD*cosL*cosH);
double azimuth = Math.atan2(-cosD*cosL*sinH, sinD - sinL * Math.sin(altitude));
return new Horizon(azimuth, altitude);
}
//-------------------------------------------------------------------------
// The Sun
//-------------------------------------------------------------------------
//
// Parameters of the Sun's orbit as of the epoch Jan 0.0 1990
// Angles are in radians (after multiplying by PI/180)
//
static final double JD_EPOCH = 2447891.5; // Julian day of epoch
static final double SUN_ETA_G = 279.403303 * PI/180; // Ecliptic longitude at epoch
static final double SUN_OMEGA_G = 282.768422 * PI/180; // Ecliptic longitude of perigee
static final double SUN_E = 0.016713; // Eccentricity of orbit
//double sunR0 = 1.495585e8; // Semi-major axis in KM
//double sunTheta0 = 0.533128 * PI/180; // Angular diameter at R0
// The following three methods, which compute the sun parameters
// given above for an arbitrary epoch (whatever time the object is
// set to), make only a small difference as compared to using the
// above constants. E.g., Sunset times might differ by ~12
// seconds. Furthermore, the eta-g computation is befuddled by
// Duffet-Smith's incorrect coefficients (p.86). I've corrected
// the first-order coefficient but the others may be off too - no
// way of knowing without consulting another source.
// /**
// * Return the sun's ecliptic longitude at perigee for the current time.
// * See Duffett-Smith, p. 86.
// * @return radians
// */
// private double getSunOmegaG() {
// double T = getJulianCentury();
// return (281.2208444 + (1.719175 + 0.000452778*T)*T) * DEG_RAD;
// }
// /**
// * Return the sun's ecliptic longitude for the current time.
// * See Duffett-Smith, p. 86.
// * @return radians
// */
// private double getSunEtaG() {
// double T = getJulianCentury();
// //return (279.6966778 + (36000.76892 + 0.0003025*T)*T) * DEG_RAD;
// //
// // The above line is from Duffett-Smith, and yields manifestly wrong
// // results. The below constant is derived empirically to match the
// // constant he gives for the 1990 EPOCH.
// //
// return (279.6966778 + (-0.3262541582718024 + 0.0003025*T)*T) * DEG_RAD;
// }
// /**
// * Return the sun's eccentricity of orbit for the current time.
// * See Duffett-Smith, p. 86.
// * @return double
// */
// private double getSunE() {
// double T = getJulianCentury();
// return 0.01675104 - (0.0000418 + 0.000000126*T)*T;
// }
/**
* The longitude of the sun at the time specified by this object.
* The longitude is measured in radians along the ecliptic
* from the "first point of Aries," the point at which the ecliptic
* crosses the earth's equatorial plane at the vernal equinox.
* double in the range
* 0 <= phase < 1, interpreted as follows:
*
*
*
* @see #getMoonAge
* @internal
*/
public double getMoonPhase() {
// See page 147 of "Practial Astronomy with your Calculator",
// by Peter Duffet-Smith, for details on the algorithm.
return 0.5 * (1 - Math.cos(getMoonAge()));
}
private static class MoonAge {
double value;
MoonAge(double val) { value = val; }
}
/**
* Constant representing a new moon.
* For use with {@link #getMoonTime(MoonAge, boolean) getMoonTime}
* @internal
*/
public static final MoonAge NEW_MOON = new MoonAge(0);
/**
* Constant representing the moon's first quarter.
* For use with {@link #getMoonTime(MoonAge, boolean) getMoonTime}
* @internal
*/
public static final MoonAge FIRST_QUARTER = new MoonAge(PI/2);
/**
* Constant representing a full moon.
* For use with {@link #getMoonTime(MoonAge, boolean) getMoonTime}
* @internal
*/
public static final MoonAge FULL_MOON = new MoonAge(PI);
/**
* Constant representing the moon's last quarter.
* For use with {@link #getMoonTime(MoonAge, boolean) getMoonTime}
* @internal
*/
public static final MoonAge LAST_QUARTER = new MoonAge((PI*3)/2);
/**
* Find the next or previous time at which the Moon's ecliptic
* longitude will have the desired value.
*
*
* This is a direct port from the ICU4C version
* @author Syn Wee Quek
*/
public class IntTrieBuilder extends TrieBuilder
{
// public constructor ----------------------------------------------
/**
* Copy constructor
*/
public IntTrieBuilder(IntTrieBuilder table)
{
super(table);
m_data_ = new int[m_dataCapacity_];
System.arraycopy(table.m_data_, 0, m_data_, 0, m_dataLength_);
m_initialValue_ = table.m_initialValue_;
m_leadUnitValue_ = table.m_leadUnitValue_;
}
/**
* Constructs a build table
* @param aliasdata data to be filled into table
* @param maxdatalength maximum data length allowed in table
* @param initialvalue inital data value
* @param latin1linear is latin 1 to be linear
*/
public IntTrieBuilder(int aliasdata[], int maxdatalength,
int initialvalue, int leadunitvalue,
boolean latin1linear)
{
super();
if (maxdatalength < DATA_BLOCK_LENGTH || (latin1linear
&& maxdatalength < 1024)) {
throw new IllegalArgumentException(
"Argument maxdatalength is too small");
}
if (aliasdata != null) {
m_data_ = aliasdata;
}
else {
m_data_ = new int[maxdatalength];
}
// preallocate and reset the first data block (block index 0)
int j = DATA_BLOCK_LENGTH;
if (latin1linear) {
// preallocate and reset the first block (number 0) and Latin-1
// (U+0000..U+00ff) after that made sure above that
// maxDataLength >= 1024
// set indexes to point to consecutive data blocks
int i = 0;
do {
// do this at least for trie->index[0] even if that block is
// only partly used for Latin-1
m_index_[i ++] = j;
j += DATA_BLOCK_LENGTH;
} while (i < (256 >> SHIFT_));
}
m_dataLength_ = j;
// reset the initially allocated blocks to the initial value
Arrays.fill(m_data_, 0, m_dataLength_, initialvalue);
m_initialValue_ = initialvalue;
m_leadUnitValue_ = leadunitvalue;
m_dataCapacity_ = maxdatalength;
m_isLatin1Linear_ = latin1linear;
m_isCompacted_ = false;
}
// public methods -------------------------------------------------------
/*public final void print()
{
int i = 0;
int oldvalue = m_index_[i];
int count = 0;
System.out.println("index length " + m_indexLength_
+ " --------------------------");
while (i < m_indexLength_) {
if (m_index_[i] != oldvalue) {
System.out.println("index has " + count + " counts of "
+ Integer.toHexString(oldvalue));
count = 0;
oldvalue = m_index_[i];
}
count ++;
i ++;
}
System.out.println("index has " + count + " counts of "
+ Integer.toHexString(oldvalue));
i = 0;
oldvalue = m_data_[i];
count = 0;
System.out.println("data length " + m_dataLength_
+ " --------------------------");
while (i < m_dataLength_) {
if (m_data_[i] != oldvalue) {
if ((oldvalue & 0xf1000000) == 0xf1000000) {
int temp = oldvalue & 0xffffff;
temp += 0x320;
oldvalue = 0xf1000000 | temp;
}
if ((oldvalue & 0xf2000000) == 0xf2000000) {
int temp = oldvalue & 0xffffff;
temp += 0x14a;
oldvalue = 0xf2000000 | temp;
}
System.out.println("data has " + count + " counts of "
+ Integer.toHexString(oldvalue));
count = 0;
oldvalue = m_data_[i];
}
count ++;
i ++;
}
if ((oldvalue & 0xf1000000) == 0xf1000000) {
int temp = oldvalue & 0xffffff;
temp += 0x320;
oldvalue = 0xf1000000 | temp;
}
if ((oldvalue & 0xf2000000) == 0xf2000000) {
int temp = oldvalue & 0xffffff;
temp += 0x14a;
oldvalue = 0xf2000000 | temp;
}
System.out.println("data has " + count + " counts of "
+ Integer.toHexString(oldvalue));
}
*/
/**
* Gets a 32 bit data from the table data
* @param ch codepoint which data is to be retrieved
* @return the 32 bit data
*/
public int getValue(int ch)
{
// valid, uncompacted trie and valid c?
if (m_isCompacted_ || ch > UCharacter.MAX_VALUE || ch < 0) {
return 0;
}
int block = m_index_[ch >> SHIFT_];
return m_data_[Math.abs(block) + (ch & MASK_)];
}
/**
* Get a 32 bit data from the table data
* @param ch code point for which data is to be retrieved.
* @param inBlockZero Output parameter, inBlockZero[0] returns true if the
* char maps into block zero, otherwise false.
* @return the 32 bit data value.
*/
public int getValue(int ch, boolean [] inBlockZero)
{
// valid, uncompacted trie and valid c?
if (m_isCompacted_ || ch > UCharacter.MAX_VALUE || ch < 0) {
if (inBlockZero != null) {
inBlockZero[0] = true;
}
return 0;
}
int block = m_index_[ch >> SHIFT_];
if (inBlockZero != null) {
inBlockZero[0] = (block == 0);
}
return m_data_[Math.abs(block) + (ch & MASK_)];
}
/**
* Sets a 32 bit data in the table data
* @param ch codepoint which data is to be set
* @param value to set
* @return true if the set is successful, otherwise
* if the table has been compacted return false
*/
public boolean setValue(int ch, int value)
{
// valid, uncompacted trie and valid c?
if (m_isCompacted_ || ch > UCharacter.MAX_VALUE || ch < 0) {
return false;
}
int block = getDataBlock(ch);
if (block < 0) {
return false;
}
m_data_[block + (ch & MASK_)] = value;
return true;
}
/**
* Serializes the build table with 32 bit data
* @param datamanipulate builder raw fold method implementation
* @param triedatamanipulate result trie fold method
* @return a new trie
*/
public IntTrie serialize(TrieBuilder.DataManipulate datamanipulate,
Trie.DataManipulate triedatamanipulate)
{
if (datamanipulate == null) {
throw new IllegalArgumentException("Parameters can not be null");
}
// fold and compact if necessary, also checks that indexLength is
// within limits
if (!m_isCompacted_) {
// compact once without overlap to improve folding
compact(false);
// fold the supplementary part of the index array
fold(datamanipulate);
// compact again with overlap for minimum data array length
compact(true);
m_isCompacted_ = true;
}
// is dataLength within limits?
if (m_dataLength_ >= MAX_DATA_LENGTH_) {
throw new ArrayIndexOutOfBoundsException("Data length too small");
}
char index[] = new char[m_indexLength_];
int data[] = new int[m_dataLength_];
// write the index (stage 1) array and the 32-bit data (stage 2) array
// write 16-bit index values shifted right by INDEX_SHIFT_
for (int i = 0; i < m_indexLength_; i ++) {
index[i] = (char)(m_index_[i] >>> INDEX_SHIFT_);
}
// write 32-bit data values
System.arraycopy(m_data_, 0, data, 0, m_dataLength_);
int options = SHIFT_ | (INDEX_SHIFT_ << OPTIONS_INDEX_SHIFT_);
options |= OPTIONS_DATA_IS_32_BIT_;
if (m_isLatin1Linear_) {
options |= OPTIONS_LATIN1_IS_LINEAR_;
}
return new IntTrie(index, data, m_initialValue_, options,
triedatamanipulate);
}
/**
* Serializes the build table to an output stream.
*
* Compacts the build-time trie after all values are set, and then
* writes the serialized form onto an output stream.
*
* After this, this build-time Trie can only be serialized again and/or closed;
* no further values can be added.
*
* This function is the rough equivalent of utrie_seriaize() in ICU4C.
*
* @param os the output stream to which the seriaized trie will be written.
* If nul, the function still returns the size of the serialized Trie.
* @param reduceTo16Bits If true, reduce the data size to 16 bits. The resulting
* serialized form can then be used to create a CharTrie.
* @param datamanipulate builder raw fold method implementation
* @return the number of bytes written to the output stream.
*/
public int serialize(OutputStream os, boolean reduceTo16Bits,
TrieBuilder.DataManipulate datamanipulate) throws IOException {
if (datamanipulate == null) {
throw new IllegalArgumentException("Parameters can not be null");
}
// fold and compact if necessary, also checks that indexLength is
// within limits
if (!m_isCompacted_) {
// compact once without overlap to improve folding
compact(false);
// fold the supplementary part of the index array
fold(datamanipulate);
// compact again with overlap for minimum data array length
compact(true);
m_isCompacted_ = true;
}
// is dataLength within limits?
int length;
if (reduceTo16Bits) {
length = m_dataLength_ + m_indexLength_;
} else {
length = m_dataLength_;
}
if (length >= MAX_DATA_LENGTH_) {
throw new ArrayIndexOutOfBoundsException("Data length too small");
}
// struct UTrieHeader {
// int32_t signature;
// int32_t options (a bit field)
// int32_t indexLength
// int32_t dataLength
length = Trie.HEADER_LENGTH_ + 2*m_indexLength_;
if(reduceTo16Bits) {
length+=2*m_dataLength_;
} else {
length+=4*m_dataLength_;
}
if (os == null) {
// No output stream. Just return the length of the serialized Trie, in bytes.
return length;
}
DataOutputStream dos = new DataOutputStream(os);
dos.writeInt(Trie.HEADER_SIGNATURE_);
int options = Trie.INDEX_STAGE_1_SHIFT_ | (Trie.INDEX_STAGE_2_SHIFT_<
* "With loose matching of property names, the case distinctions,
* whitespace, and '_' are ignored."
*
* StringBuffer in the given radix. This is
* done recursively since it is easiest to generate the low-
* order digit first, but it must be appended last.
*
* @param result is the StringBuffer to append to
* @param n is the positive integer
* @param radix is the radix, from 2 to 36 inclusive
* @param minDigits is the minimum number of digits to append.
*/
private static void recursiveAppendNumber(StringBuffer result, int n,
int radix, int minDigits)
{
int digit = n % radix;
if (n >= radix || minDigits > 1) {
recursiveAppendNumber(result, n / radix, radix, minDigits - 1);
}
result.append(DIGITS[digit]);
}
/**
* Append a number to the given StringBuffer in the given radix.
* Standard digits '0'-'9' are used and letters 'A'-'Z' for
* radices 11 through 36.
* @param result the digits of the number are appended here
* @param n the number to be converted to digits; may be negative.
* If negative, a '-' is prepended to the digits.
* @param radix a radix from 2 to 36 inclusive.
* @param minDigits the minimum number of digits, not including
* any '-', to produce. Values less than 2 have no effect. One
* digit is always emitted regardless of this parameter.
* @return a reference to result
*/
public static StringBuffer appendNumber(StringBuffer result, int n,
int radix, int minDigits)
throws IllegalArgumentException
{
if (radix < 2 || radix > 36) {
throw new IllegalArgumentException("Illegal radix " + radix);
}
int abs = n;
if (n < 0) {
abs = -n;
result.append("-");
}
recursiveAppendNumber(result, abs, radix, minDigits);
return result;
}
/**
* Parse an unsigned 31-bit integer at the given offset. Use
* UCharacter.digit() to parse individual characters into digits.
* @param text the text to be parsed
* @param pos INPUT-OUTPUT parameter. On entry, pos[0] is the
* offset within text at which to start parsing; it should point
* to a valid digit. On exit, pos[0] is the offset after the last
* parsed character. If the parse failed, it will be unchanged on
* exit. Must be >= 0 on entry.
* @param radix the radix in which to parse; must be >= 2 and <=
* 36.
* @return a non-negative parsed number, or -1 upon parse failure.
* Parse fails if there are no digits, that is, if pos[0] does not
* point to a valid digit on entry, or if the number to be parsed
* does not fit into a 31-bit unsigned integer.
*/
public static int parseNumber(String text, int[] pos, int radix) {
// assert(pos[0] >= 0);
// assert(radix >= 2);
// assert(radix <= 36);
int n = 0;
int p = pos[0];
while (p < text.length()) {
int ch = UTF16.charAt(text, p);
int d = UCharacter.digit(ch, radix);
if (d < 0) {
break;
}
n = radix*n + d;
// ASSUME that when a 32-bit integer overflows it becomes
// negative. E.g., 214748364 * 10 + 8 => negative value.
if (n < 0) {
return -1;
}
++p;
}
if (p == pos[0]) {
return -1;
}
pos[0] = p;
return n;
}
/**
* Return true if the character is NOT printable ASCII. The tab,
* newline and linefeed characters are considered unprintable.
*/
public static boolean isUnprintable(int c) {
return !(c >= 0x20 && c <= 0x7E);
}
/**
* Escape unprintable characters using setOfChars.
* @param text text to be searched
* @param start the beginning index, inclusive; 0 <= start
* <= limit.
* @param limit the ending index, exclusive; start <= limit
* <= text.length().
* @param setOfChars string with one or more distinct characters
* @return Offset of the first character in setOfChars
* found, or -1 if not found.
* @see String#indexOf
*/
public static int quotedIndexOf(String text, int start, int limit,
String setOfChars) {
for (int i=start; in is not positive
*/
public static final byte highBit(int n)
{
if (n <= 0) {
return -1;
}
byte bit = 0;
if (n >= 1 << 16) {
n >>= 16;
bit += 16;
}
if (n >= 1 << 8) {
n >>= 8;
bit += 8;
}
if (n >= 1 << 4) {
n >>= 4;
bit += 4;
}
if (n >= 1 << 2) {
n >>= 2;
bit += 2;
}
if (n >= 1 << 1) {
n >>= 1;
bit += 1;
}
return bit;
}
/**
* Utility method to take a int[] containing codepoints and return
* a string representation with code units.
*/
public static String valueOf(int[]source){
// TODO: Investigate why this method is not on UTF16 class
StringBuffer result = new StringBuffer(source.length);
for(int i=0; i
* try {
* lock.acquireRead();
* // use service protected by the lock
* }
* finally {
* lock.releaseRead();
* }
*
The lock provides utility methods getStats and clearStats * to return statistics on the use of the lock.
*/ public class ICURWLock { private Object writeLock = new Object(); private Object readLock = new Object(); private int wwc; // waiting writers private int rc; // active readers, -1 if there's an active writer private int wrc; // waiting readers private Stats stats = new Stats(); // maybe don't init to start... /** * Internal class used to gather statistics on the RWLock. */ public final static class Stats { /** * Number of times read access granted (read count). */ public int _rc; /** * Number of times concurrent read access granted (multiple read count). */ public int _mrc; /** * Number of times blocked for read (waiting reader count). */ public int _wrc; // wait for read /** * Number of times write access granted (writer count). */ public int _wc; /** * Number of times blocked for write (waiting writer count). */ public int _wwc; private Stats() { } private Stats(int rc, int mrc, int wrc, int wc, int wwc) { this._rc = rc; this._mrc = mrc; this._wrc = wrc; this._wc = wc; this._wwc = wwc; } private Stats(Stats rhs) { this(rhs._rc, rhs._mrc, rhs._wrc, rhs._wc, rhs._wwc); } /** * Return a string listing all the stats. */ public String toString() { return " rc: " + _rc + " mrc: " + _mrc + " wrc: " + _wrc + " wc: " + _wc + " wwc: " + _wwc; } } /** * Reset the stats. Returns existing stats, if any. */ public synchronized Stats resetStats() { Stats result = stats; stats = new Stats(); return result; } /** * Clear the stats (stop collecting stats). Returns existing stats, if any. */ public synchronized Stats clearStats() { Stats result = stats; stats = null; return result; } /** * Return a snapshot of the current stats. This does not reset the stats. */ public synchronized Stats getStats() { return stats == null ? null : new Stats(stats); } // utilities private synchronized boolean gotRead() { ++rc; if (stats != null) { ++stats._rc; if (rc > 1) ++stats._mrc; } return true; } private synchronized boolean getRead() { if (rc >= 0 && wwc == 0) { return gotRead(); } ++wrc; return false; } private synchronized boolean retryRead() { if (stats != null) ++stats._wrc; if (rc >= 0 && wwc == 0) { --wrc; return gotRead(); } return false; } private synchronized boolean finishRead() { if (rc > 0) { return (0 == --rc && wwc > 0); } throw new IllegalStateException("no current reader to release"); } private synchronized boolean gotWrite() { rc = -1; if (stats != null) { ++stats._wc; } return true; } private synchronized boolean getWrite() { if (rc == 0) { return gotWrite(); } ++wwc; return false; } private synchronized boolean retryWrite() { if (stats != null) ++stats._wwc; if (rc == 0) { --wwc; return gotWrite(); } return false; } private static final int NOTIFY_NONE = 0; private static final int NOTIFY_WRITERS = 1; private static final int NOTIFY_READERS = 2; private synchronized int finishWrite() { if (rc < 0) { rc = 0; if (wwc > 0) { return NOTIFY_WRITERS; } else if (wrc > 0) { return NOTIFY_READERS; } else { return NOTIFY_NONE; } } throw new IllegalStateException("no current writer to release"); } /** *Acquire a read lock, blocking until a read lock is * available. Multiple readers can concurrently hold the read * lock.
* *If there's a writer, or a waiting writer, increment the * waiting reader count and block on this. Otherwise * increment the active reader count and return. Caller must call * releaseRead when done (for example, in a finally block).
*/ public void acquireRead() { if (!getRead()) { for (;;) { try { synchronized (readLock) { readLock.wait(); } if (retryRead()) { return; } } catch (InterruptedException e) { } } } } /** *Release a read lock and return. An error will be thrown * if a read lock is not currently held.
* *If this is the last active reader, notify the oldest * waiting writer. Call when finished with work * controlled by acquireRead.
*/ public void releaseRead() { if (finishRead()) { synchronized (writeLock) { writeLock.notify(); } } } /** *Acquire the write lock, blocking until the write lock is * available. Only one writer can acquire the write lock, and * when held, no readers can acquire the read lock.
* *If there are no readers and no waiting writers, mark as * having an active writer and return. Otherwise, add a lock to the * end of the waiting writer list, and block on it. Caller * must call releaseWrite when done (for example, in a finally * block).
*/ public void acquireWrite() { if (!getWrite()) { for (;;) { try { synchronized (writeLock) { writeLock.wait(); } if (retryWrite()) { return; } } catch (InterruptedException e) { } } } } /** *
Release the write lock and return. An error will be thrown * if the write lock is not currently held.
* *If there are waiting readers, make them all active and * notify all of them. Otherwise, notify the oldest waiting * writer, if any. Call when finished with work controlled by * acquireWrite.
*/ public void releaseWrite() { switch (finishWrite()) { case NOTIFY_WRITERS: synchronized (writeLock) { writeLock.notify(); } break; case NOTIFY_READERS: synchronized (readLock) { readLock.notifyAll(); } break; case NOTIFY_NONE: break; } } } icu4j-4.2.1.1/src/com/ibm/icu/impl/USerializedSet.java 0000644 0001750 0001750 00000013351 11015072544 022227 0 ustar twerner twerner /* ******************************************************************************* * Copyright (C) 2002-2008, International Business Machines * Corporation and others. All Rights Reserved. ******************************************************************************* */ package com.ibm.icu.impl; /** * @version 1.1 * @author Markus W. Scherer * Ram: Add documentation, remove unwanted methods, improve coverage. */ /** * Simple class for handling serialized USet/UnicodeSet structures * without object creation. See ICU4C icu/source/common/uset.c. * * @internal */ public final class USerializedSet { /** * Fill in the given serialized set object. * @param src pointer to start of array * @param srcStart pointer to start of serialized data (length value) * @return true if the given array is valid, otherwise false */ public final boolean getSet(char src[], int srcStart) { // leave most argument checking up to Java exceptions array=null; arrayOffset=bmpLength=length=0; length=src[srcStart++]; if((length&0x8000) >0) { /* there are supplementary values */ length&=0x7fff; if(src.length<(srcStart+1+length)) { length=0; throw new IndexOutOfBoundsException(); } bmpLength=src[srcStart++]; } else { /* only BMP values */ if(src.length<(srcStart+length)) { length=0; throw new IndexOutOfBoundsException(); } bmpLength=length; } array = new char[length]; System.arraycopy(src,srcStart,array,0,length); //arrayOffset=srcStart; return true; } /** * Set the USerializedSet to contain the given character (and nothing * else). */ public final void setToOne(int c) { if( 0x10ffff0..
* getSerializedRangeCount()-1
* @param range variable to receive the data in the range
* @return true if rangeIndex is valid, otherwise false
*/
public final boolean getRange(int rangeIndex, int[] range) {
if( rangeIndex<0) {
return false;
}
if(array==null){
array = new char[8];
}
if(range==null || range.length <2){
throw new IllegalArgumentException();
}
rangeIndex*=2; /* address start/limit pairs */
if(rangeIndexNot thread-safe; create a separate copy for different threads. *
In the future, we may extend this to support other regex packages. * * @regex A modified Java regex pattern, as in the input to * Pattern.compile(), except that all "character classes" are * processed as if they were UnicodeSet patterns. Example: * "abc[:bc=N:]. See UnicodeSet for the differences in syntax. * @return A processed Java regex pattern, suitable for input to * Pattern.compile(). */ public String transform(String regex) { StringBuffer result = new StringBuffer(); UnicodeSet temp = new UnicodeSet(); ParsePosition pos = new ParsePosition(0); int state = 0; // 1 = after \ // We add each character unmodified to the output, unless we have a // UnicodeSet. Note that we don't worry about supplementary characters, // since none of the syntax uses them. for (int i = 0; i < regex.length(); ++i) { // look for UnicodeSets, allowing for quoting with \ and \Q char ch = regex.charAt(i); switch (state) { case 0: // we only care about \, and '['. if (ch == '\\') { if (UnicodeSet.resemblesPattern(regex, i)) { // should only happen with \p i = processSet(regex, i, result, temp, pos); continue; } state = 1; } else if (ch == '[') { // if we have what looks like a UnicodeSet if (UnicodeSet.resemblesPattern(regex, i)) { i = processSet(regex, i, result, temp, pos); continue; } } break; case 1: // we are after a \ if (ch == 'Q') { state = 1; } else { state = 0; } break; case 2: // we are in a \Q... if (ch == '\\') { state = 3; } break; case 3: // we are in at \Q...\ if (ch == 'E') { state = 0; } state = 2; break; } result.append(ch); } return result.toString(); } /** * Convenience static function, using standard parameters. * @param regex as in process() * @return processed regex pattern, as in process() */ public static String fix(String regex) { return STANDARD.transform(regex); } /** * Compile a regex string, after processing by fix(...). * * @param regex * Raw regex pattern, as in fix(...). * @return Pattern */ public static Pattern compile(String regex) { return Pattern.compile(STANDARD.transform(regex)); } /** * Compile a regex string, after processing by fix(...). * * @param regex * Raw regex pattern, as in fix(...). * @return Pattern */ public static Pattern compile(String regex, int options) { return Pattern.compile(STANDARD.transform(regex), options); } /** * Compile a composed string from a set of BNF lines; see the List version for more information. * * @param bnfLines Series of BNF lines. * @return Pattern */ public String compileBnf(String bnfLines) { return compileBnf(Arrays.asList(bnfLines.split("\\r\\n?|\\n"))); } /** * Compile a composed string from a set of BNF lines, such as for composing a regex * expression. The lines can be in any order, but there must not be any * cycles. The result can be used as input for fix(). *
* Example: *
* uri = (?: (scheme) \\:)? (host) (?: \\? (query))? (?: \\u0023 (fragment))?;
* scheme = reserved+;
* host = // reserved+;
* query = [\\=reserved]+;
* fragment = reserved+;
* reserved = [[:ascii:][:alphabetic:]];
*
* * Caveats: at this point the parsing is simple; for example, # cannot be * quoted (use \\u0023); you can set it to null to disable. * The equality sign and a few others can be reset with * setBnfX(). * * @param bnfLines * Series of lines that represent a BNF expression. The lines contain * a series of statements that of the form x=y;. A statement can take * multiple lines, but there can't be multiple statements on a line. * A hash quotes to the end of the line. * @return Pattern */ public String compileBnf(List lines) { Map variables = getVariables(lines); Set unused = new LinkedHashSet(variables.keySet()); // brute force replacement; do twice to allow for different order // later on can optimize for (int i = 0; i < 2; ++i) { for (Iterator it = variables.keySet().iterator(); it.hasNext();) { String variable = (String) it.next(); String definition = (String) variables.get(variable); for (Iterator it2 = variables.keySet().iterator(); it2.hasNext();) { String variable2 = (String) it2.next(); if (variable.equals(variable2)) continue; String definition2 = (String) variables.get(variable2); String altered2 = definition2.replace(variable, definition); if (!altered2.equals(definition2)) { unused.remove(variable); variables.put(variable2, altered2); if (log != null) { try { log.append(variable2 + "=" + altered2 + ";"); } catch (IOException e) { throw (IllegalArgumentException) new IllegalArgumentException().initCause(e); } } } } } } if (unused.size() != 1) { throw new IllegalArgumentException("Not a single root: " + unused); } return (String) variables.get(unused.iterator().next()); } public String getBnfCommentString() { return bnfCommentString; } public void setBnfCommentString(String bnfCommentString) { this.bnfCommentString = bnfCommentString; } public String getBnfVariableInfix() { return bnfVariableInfix; } public void setBnfVariableInfix(String bnfVariableInfix) { this.bnfVariableInfix = bnfVariableInfix; } public String getBnfLineSeparator() { return bnfLineSeparator; } public void setBnfLineSeparator(String bnfLineSeparator) { this.bnfLineSeparator = bnfLineSeparator; } /** * Utility for loading lines from a file. * @param result * @param file * @param encoding if null, then UTF-8 * @return filled list * @throws IOException */ public static List appendLines(List result, String file, String encoding) throws IOException { return appendLines(result, new FileInputStream(file), encoding); } /** * Utility for loading lines from a UTF8 file. * @param result * @param inputStream * @param encoding if null, then UTF-8 * @return filled list * @throws IOException */ public static List appendLines(List result, InputStream inputStream, String encoding) throws UnsupportedEncodingException, IOException { BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, encoding == null ? "UTF-8" : encoding)); while (true) { String line = in.readLine(); if (line == null) break; result.add(line); } return result; } /* (non-Javadoc) * @see com.ibm.icu.util.Freezable#cloneAsThawed() */ public Object cloneAsThawed() { // TODO Auto-generated method stub try { return this.clone(); } catch (CloneNotSupportedException e) { throw new IllegalArgumentException(); // should never happen } } /* (non-Javadoc) * @see com.ibm.icu.util.Freezable#freeze() */ public Object freeze() { // no action needed now. return this; } /* (non-Javadoc) * @see com.ibm.icu.util.Freezable#isFrozen() */ public boolean isFrozen() { // at this point, always true return true; } // ===== PRIVATES ===== private int processSet(String regex, int i, StringBuffer result, UnicodeSet temp, ParsePosition pos) { try { pos.setIndex(i); UnicodeSet x = temp.clear().applyPattern(regex, pos, null, 0); x.complement().complement(); // hack to fix toPattern result.append(x.toPattern(false)); i = pos.getIndex() - 1; // allow for the loop increment return i; } catch (Exception e) { throw (IllegalArgumentException) new IllegalArgumentException("Error in " + regex).initCause(e); } } private static UnicodeRegex STANDARD = new UnicodeRegex(); private String bnfCommentString = "#"; private String bnfVariableInfix = "="; private String bnfLineSeparator = "\n"; private Appendable log = null; private Comparator LongestFirst = new Comparator () { public int compare(Object obj0, Object obj1) { String arg0 = obj0.toString(); String arg1 = obj1.toString(); int len0 = arg0.length(); int len1 = arg1.length(); if (len0 != len1) return len1 - len0; return arg0.compareTo(arg1); } }; private Map getVariables(List lines) { Map variables = new TreeMap(LongestFirst); String variable = null; StringBuffer definition = new StringBuffer(); int count = 0; for (Iterator it = lines.iterator(); it.hasNext();) { String line = (String)it.next(); ++count; // remove initial bom, comments if (line.length() == 0) continue; if (line.charAt(0) == '\uFEFF') line = line.substring(1); if (bnfCommentString != null) { int hashPos = line.indexOf(bnfCommentString); if (hashPos >= 0) line = line.substring(0, hashPos); } String trimline = line.trim(); if (trimline.length() == 0) continue; // String[] lineParts = line.split(";"); String linePart = line; // lineParts[i]; // .trim().replace("\\s+", " "); if (linePart.trim().length() == 0) continue; boolean terminated = trimline.endsWith(";"); if (terminated) { linePart = linePart.substring(0,linePart.lastIndexOf(';')); } int equalsPos = linePart.indexOf(bnfVariableInfix); if (equalsPos >= 0) { if (variable != null) { throw new IllegalArgumentException("Missing ';' before " + count + ") " + line); } variable = linePart.substring(0,equalsPos).trim(); if (variables.containsKey(variable)) { throw new IllegalArgumentException("Duplicate variable definition in " + line); } definition.append(linePart.substring(equalsPos+1).trim()); } else { // no equals, so if (variable == null) { throw new IllegalArgumentException("Missing '=' at " + count + ") " + line); } definition.append(bnfLineSeparator).append(linePart); } // we are terminated if i is not at the end, or the line ends with a ; if (terminated) { variables.put(variable, definition.toString()); variable = null; // signal we have no variable definition.setLength(0); } } if (variable != null) { throw new IllegalArgumentException("Missing ';' at end"); } return variables; } } //#endif icu4j-4.2.1.1/src/com/ibm/icu/impl/ICUService.java 0000644 0001750 0001750 00000106743 10775324256 021320 0 ustar twerner twerner /** ******************************************************************************* * Copyright (C) 2001-2008, International Business Machines Corporation and * * others. All Rights Reserved. * ******************************************************************************* */ package com.ibm.icu.impl; import java.lang.ref.SoftReference; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.EventListener; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.ListIterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.SortedMap; import java.util.TreeMap; import com.ibm.icu.util.ULocale; /** *
A Service provides access to service objects that implement a * particular service, e.g. transliterators. Users provide a String * id (for example, a locale string) to the service, and get back an * object for that id. Service objects can be any kind of object. * The service object is cached and returned for later queries, so * generally it should not be mutable, or the caller should clone the * object before modifying it.
* *Services 'canonicalize' the query id and use the canonical id to * query for the service. The service also defines a mechanism to * 'fallback' the id multiple times. Clients can optionally request * the actual id that was matched by a query when they use an id to * retrieve a service object.
* *Service objects are instantiated by Factory objects registered with * the service. The service queries each Factory in turn, from most recently * registered to earliest registered, until one returns a service object. * If none responds with a service object, a fallback id is generated, * and the process repeats until a service object is returned or until * the id has no further fallbacks.
* *Factories can be dynamically registered and unregistered with the * service. When registered, a Factory is installed at the head of * the factory list, and so gets 'first crack' at any keys or fallback * keys. When unregistered, it is removed from the service and can no * longer be located through it. Service objects generated by this * factory and held by the client are unaffected.
* *ICUService uses Keys to query factories and perform * fallback. The Key defines the canonical form of the id, and * implements the fallback strategy. Custom Keys can be defined that * parse complex IDs into components that Factories can more easily * use. The Key can cache the results of this parsing to save * repeated effort. ICUService provides convenience APIs that * take Strings and generate default Keys for use in querying.
* *ICUService provides API to get the list of ids publicly * supported by the service (although queries aren't restricted to * this list). This list contains only 'simple' IDs, and not fully * unique ids. Factories are associated with each simple ID and * the responsible factory can also return a human-readable localized * version of the simple ID, for use in user interfaces. ICUService * can also provide a sorted collection of the all the localized visible * ids.
* *ICUService implements ICUNotifier, so that clients can register * to receive notification when factories are added or removed from * the service. ICUService provides a default EventListener subinterface, * ServiceListener, which can be registered with the service. When * the service changes, the ServiceListener's serviceChanged method * is called, with the service as the only argument.
* *The ICUService API is both rich and generic, and it is expected * that most implementations will statically 'wrap' ICUService to * present a more appropriate API-- for example, to declare the type * of the objects returned from get, to limit the factories that can * be registered with the service, or to define their own listener * interface with a custom callback method. They might also customize * ICUService by overriding it, for example, to customize the Key and * fallback strategy. ICULocaleService is a customized service that * uses Locale names as ids and uses Keys that implement the standard * resource bundle fallback strategy.
*/ public class ICUService extends ICUNotifier { /** * Name used for debugging. */ protected final String name; /** * Constructor. */ public ICUService() { name = ""; } private static final boolean DEBUG = ICUDebug.enabled("service"); /** * Construct with a name (useful for debugging). */ public ICUService(String name) { this.name = name; } /** * Access to factories is protected by a read-write lock. This is * to allow multiple threads to read concurrently, but keep * changes to the factory list atomic with respect to all readers. */ private final ICURWLock factoryLock = new ICURWLock(); /** * All the factories registered with this service. */ private final List factories = new ArrayList(); /** * Record the default number of factories for this service. * Can be set by markDefault. */ private int defaultSize = 0; /** * Keys are used to communicate with factories to generate an * instance of the service. Keys define how ids are * canonicalized, provide both a current id and a current * descriptor to use in querying the cache and factories, and * determine the fallback strategy.
* *Keys provide both a currentDescriptor and a currentID. * The descriptor contains an optional prefix, followed by '/' * and the currentID. Factories that handle complex keys, * for example number format factories that generate multiple * kinds of formatters for the same locale, use the descriptor * to provide a fully unique identifier for the service object, * while using the currentID (in this case, the locale string), * as the visible IDs that can be localized. * *
The default implementation of Key has no fallbacks and * has no custom descriptors.
*/ public static class Key { private final String id; /** * Construct a key from an id. */ public Key(String id) { this.id = id; } /** * Return the original ID used to construct this key. */ public final String id() { return id; } /** * Return the canonical version of the original ID. This implementation * returns the original ID unchanged. */ public String canonicalID() { return id; } /** * Return the (canonical) current ID. This implementation * returns the canonical ID. */ public String currentID() { return canonicalID(); } /** * Return the current descriptor. This implementation returns * the current ID. The current descriptor is used to fully * identify an instance of the service in the cache. A * factory may handle all descriptors for an ID, or just a * particular descriptor. The factory can either parse the * descriptor or use custom API on the key in order to * instantiate the service. */ public String currentDescriptor() { return "/" + currentID(); } /** * If the key has a fallback, modify the key and return true, * otherwise return false. The current ID will change if there * is a fallback. No currentIDs should be repeated, and fallback * must eventually return false. This implmentation has no fallbacks * and always returns false. */ public boolean fallback() { return false; } /** * If a key created from id would eventually fallback to match the * canonical ID of this key, return true. */ public boolean isFallbackOf(String idToCheck) { return canonicalID().equals(idToCheck); } } /** * Factories generate the service objects maintained by the * service. A factory generates a service object from a key, * updates id->factory mappings, and returns the display name for * a supported id. */ public static interface Factory { /** * Create a service object from the key, if this factory * supports the key. Otherwise, return null. * *If the factory supports the key, then it can call * the service's getKey(Key, String[], Factory) method * passing itself as the factory to get the object that * the service would have created prior to the factory's * registration with the service. This can change the * key, so any information required from the key should * be extracted before making such a callback. */ public Object create(Key key, ICUService service); /** * Update the result IDs (not descriptors) to reflect the IDs * this factory handles. This function and getDisplayName are * used to support ICUService.getDisplayNames. Basically, the * factory has to determine which IDs it will permit to be * available, and of those, which it will provide localized * display names for. In most cases this reflects the IDs that * the factory directly supports. */ public void updateVisibleIDs(Map result); /** * Return the display name for this id in the provided locale. * This is an localized id, not a descriptor. If the id is * not visible or not defined by the factory, return null. * If locale is null, return id unchanged. */ public String getDisplayName(String id, ULocale locale); } /** * A default implementation of factory. This provides default * implementations for subclasses, and implements a singleton * factory that matches a single id and returns a single * (possibly deferred-initialized) instance. This implements * updateVisibleIDs to add a mapping from its ID to itself * if visible is true, or to remove any existing mapping * for its ID if visible is false. */ public static class SimpleFactory implements Factory { protected Object instance; protected String id; protected boolean visible; /** * Convenience constructor that calls SimpleFactory(Object, String, boolean) * with visible true. */ public SimpleFactory(Object instance, String id) { this(instance, id, true); } /** * Construct a simple factory that maps a single id to a single * service instance. If visible is true, the id will be visible. * Neither the instance nor the id can be null. */ public SimpleFactory(Object instance, String id, boolean visible) { if (instance == null || id == null) { throw new IllegalArgumentException("Instance or id is null"); } this.instance = instance; this.id = id; this.visible = visible; } /** * Return the service instance if the factory's id is equal to * the key's currentID. Service is ignored. */ public Object create(Key key, ICUService service) { if (id.equals(key.currentID())) { return instance; } return null; } /** * If visible, adds a mapping from id -> this to the result, * otherwise removes id from result. */ public void updateVisibleIDs(Map result) { if (visible) { result.put(id, this); } else { result.remove(id); } } /** * If this.id equals id, returns id regardless of locale, * otherwise returns null. (This default implementation has * no localized id information.) */ public String getDisplayName(String identifier, ULocale locale) { return (visible && id.equals(identifier)) ? identifier : null; } /** * For debugging. */ public String toString() { StringBuffer buf = new StringBuffer(super.toString()); buf.append(", id: "); buf.append(id); buf.append(", visible: "); buf.append(visible); return buf.toString(); } } /** * Convenience override for get(String, String[]). This uses * createKey to create a key for the provided descriptor. */ public Object get(String descriptor) { return getKey(createKey(descriptor), null); } /** * Convenience override for get(Key, String[]). This uses * createKey to create a key from the provided descriptor. */ public Object get(String descriptor, String[] actualReturn) { if (descriptor == null) { throw new NullPointerException("descriptor must not be null"); } return getKey(createKey(descriptor), actualReturn); } /** * Convenience override for get(Key, String[]). */ public Object getKey(Key key) { return getKey(key, null); } /** *
Given a key, return a service object, and, if actualReturn * is not null, the descriptor with which it was found in the * first element of actualReturn. If no service object matches * this key, return null, and leave actualReturn unchanged.
* *This queries the cache using the key's descriptor, and if no * object in the cache matches it, tries the key on each * registered factory, in order. If none generates a service * object for the key, repeats the process with each fallback of * the key, until either one returns a service object, or the key * has no fallback.
* *If key is null, just returns null.
*/ public Object getKey(Key key, String[] actualReturn) { return getKey(key, actualReturn, null); } // debugging // Map hardRef; public Object getKey(Key key, String[] actualReturn, Factory factory) { if (factories.size() == 0) { return handleDefault(key, actualReturn); } if (DEBUG) System.out.println("Service: " + name + " key: " + key.canonicalID()); CacheEntry result = null; if (key != null) { try { // The factory list can't be modified until we're done, // otherwise we might update the cache with an invalid result. // The cache has to stay in synch with the factory list. factoryLock.acquireRead(); Map cache = null; SoftReference cref = cacheref; // copy so we don't need to sync on this if (cref != null) { if (DEBUG) System.out.println("Service " + name + " ref exists"); cache = (Map)cref.get(); } if (cache == null) { if (DEBUG) System.out.println("Service " + name + " cache was empty"); // synchronized since additions and queries on the cache must be atomic // they can be interleaved, though cache = Collections.synchronizedMap(new HashMap()); // hardRef = cache; // debug cref = new SoftReference(cache); } String currentDescriptor = null; ArrayList cacheDescriptorList = null; boolean putInCache = false; int NDebug = 0; int startIndex = 0; int limit = factories.size(); boolean cacheResult = true; if (factory != null) { for (int i = 0; i < limit; ++i) { if (factory == factories.get(i)) { startIndex = i + 1; break; } } if (startIndex == 0) { throw new IllegalStateException("Factory " + factory + "not registered with service: " + this); } cacheResult = false; } outer: do { currentDescriptor = key.currentDescriptor(); if (DEBUG) System.out.println(name + "[" + NDebug++ + "] looking for: " + currentDescriptor); result = (CacheEntry)cache.get(currentDescriptor); if (result != null) { if (DEBUG) System.out.println(name + " found with descriptor: " + currentDescriptor); break outer; } else { if (DEBUG) System.out.println("did not find: " + currentDescriptor + " in cache"); } // first test of cache failed, so we'll have to update // the cache if we eventually succeed-- that is, if we're // going to update the cache at all. putInCache = cacheResult; // int n = 0; int index = startIndex; while (index < limit) { Factory f = (Factory)factories.get(index++); if (DEBUG) System.out.println("trying factory[" + (index-1) + "] " + f.toString()); Object service = f.create(key, this); if (service != null) { result = new CacheEntry(currentDescriptor, service); if (DEBUG) System.out.println(name + " factory supported: " + currentDescriptor + ", caching"); break outer; } else { if (DEBUG) System.out.println("factory did not support: " + currentDescriptor); } } // prepare to load the cache with all additional ids that // will resolve to result, assuming we'll succeed. We // don't want to keep querying on an id that's going to // fallback to the one that succeeded, we want to hit the // cache the first time next goaround. if (cacheDescriptorList == null) { cacheDescriptorList = new ArrayList(5); } cacheDescriptorList.add(currentDescriptor); } while (key.fallback()); if (result != null) { if (putInCache) { if (DEBUG) System.out.println("caching '" + result.actualDescriptor + "'"); cache.put(result.actualDescriptor, result); if (cacheDescriptorList != null) { Iterator iter = cacheDescriptorList.iterator(); while (iter.hasNext()) { String desc = (String)iter.next(); if (DEBUG) System.out.println(name + " adding descriptor: '" + desc + "' for actual: '" + result.actualDescriptor + "'"); cache.put(desc, result); } } // Atomic update. We held the read lock all this time // so we know our cache is consistent with the factory list. // We might stomp over a cache that some other thread // rebuilt, but that's the breaks. They're both good. cacheref = cref; } if (actualReturn != null) { // strip null prefix if (result.actualDescriptor.indexOf("/") == 0) { actualReturn[0] = result.actualDescriptor.substring(1); } else { actualReturn[0] = result.actualDescriptor; } } if (DEBUG) System.out.println("found in service: " + name); return result.service; } } finally { factoryLock.releaseRead(); } } if (DEBUG) System.out.println("not found in service: " + name); return handleDefault(key, actualReturn); } private SoftReference cacheref; // Record the actual id for this service in the cache, so we can return it // even if we succeed later with a different id. private static final class CacheEntry { final String actualDescriptor; final Object service; CacheEntry(String actualDescriptor, Object service) { this.actualDescriptor = actualDescriptor; this.service = service; } } /** * Default handler for this service if no factory in the list * handled the key. */ protected Object handleDefault(Key key, String[] actualIDReturn) { return null; } /** * Convenience override for getVisibleIDs(String) that passes null * as the fallback, thus returning all visible IDs. */ public Set getVisibleIDs() { return getVisibleIDs(null); } /** *Return a snapshot of the visible IDs for this service. This * set will not change as Factories are added or removed, but the * supported ids will, so there is no guarantee that all and only * the ids in the returned set are visible and supported by the * service in subsequent calls.
* *matchID is passed to createKey to create a key. If the
* key is not null, it is used to filter out ids that don't have
* the key as a fallback.
*/
public Set getVisibleIDs(String matchID) {
Set result = getVisibleIDMap().keySet();
Key fallbackKey = createKey(matchID);
if (fallbackKey != null) {
Set temp = new HashSet(result.size());
Iterator iter = result.iterator();
while (iter.hasNext()) {
String id = (String)iter.next();
if (fallbackKey.isFallbackOf(id)) {
temp.add(id);
}
}
result = temp;
}
return result;
}
/**
* Return a map from visible ids to factories.
*/
private Map getVisibleIDMap() {
Map idcache = null;
SoftReference ref = idref;
if (ref != null) {
idcache = (Map)ref.get();
}
while (idcache == null) {
synchronized (this) { // or idref-only lock?
if (ref == idref || idref == null) {
// no other thread updated idref before we got the lock, so
// grab the factory list and update it ourselves
try {
factoryLock.acquireRead();
idcache = new HashMap();
ListIterator lIter = factories.listIterator(factories.size());
while (lIter.hasPrevious()) {
Factory f = (Factory)lIter.previous();
f.updateVisibleIDs(idcache);
}
idcache = Collections.unmodifiableMap(idcache);
idref = new SoftReference(idcache);
}
finally {
factoryLock.releaseRead();
}
} else {
// another thread updated idref, but gc may have stepped
// in and undone its work, leaving idcache null. If so,
// retry.
ref = idref;
idcache = (Map)ref.get();
}
}
}
return idcache;
}
private SoftReference idref;
/**
* Convenience override for getDisplayName(String, ULocale) that
* uses the current default locale.
*/
public String getDisplayName(String id) {
return getDisplayName(id, ULocale.getDefault());
}
/**
* Given a visible id, return the display name in the requested locale.
* If there is no directly supported id corresponding to this id, return
* null.
*/
public String getDisplayName(String id, ULocale locale) {
Map m = getVisibleIDMap();
Factory f = (Factory)m.get(id);
if (f != null) {
return f.getDisplayName(id, locale);
}
Key key = createKey(id);
while (key.fallback()) {
f = (Factory)m.get(key.currentID());
if (f != null) {
return f.getDisplayName(id, locale);
}
}
return null;
}
/**
* Convenience override of getDisplayNames(ULocale, Comparator, String) that
* uses the current default Locale as the locale, null as
* the comparator, and null for the matchID.
*/
public SortedMap getDisplayNames() {
ULocale locale = ULocale.getDefault();
return getDisplayNames(locale, null, null);
}
/**
* Convenience override of getDisplayNames(ULocale, Comparator, String) that
* uses null for the comparator, and null for the matchID.
*/
public SortedMap getDisplayNames(ULocale locale) {
return getDisplayNames(locale, null, null);
}
/**
* Convenience override of getDisplayNames(ULocale, Comparator, String) that
* uses null for the matchID, thus returning all display names.
*/
public SortedMap getDisplayNames(ULocale locale, Comparator com) {
return getDisplayNames(locale, com, null);
}
/**
* Convenience override of getDisplayNames(ULocale, Comparator, String) that
* uses null for the comparator.
*/
public SortedMap getDisplayNames(ULocale locale, String matchID) {
return getDisplayNames(locale, null, matchID);
}
/**
* Return a snapshot of the mapping from display names to visible
* IDs for this service. This set will not change as factories
* are added or removed, but the supported ids will, so there is
* no guarantee that all and only the ids in the returned map will
* be visible and supported by the service in subsequent calls,
* nor is there any guarantee that the current display names match
* those in the set. The display names are sorted based on the
* comparator provided.
*/
public SortedMap getDisplayNames(ULocale locale, Comparator com, String matchID) {
SortedMap dncache = null;
LocaleRef ref = dnref;
if (ref != null) {
dncache = ref.get(locale, com);
}
while (dncache == null) {
synchronized (this) {
if (ref == dnref || dnref == null) {
dncache = new TreeMap(com); // sorted
Map m = getVisibleIDMap();
Iterator ei = m.entrySet().iterator();
while (ei.hasNext()) {
Entry e = (Entry)ei.next();
String id = (String)e.getKey();
Factory f = (Factory)e.getValue();
dncache.put(f.getDisplayName(id, locale), id);
}
dncache = Collections.unmodifiableSortedMap(dncache);
dnref = new LocaleRef(dncache, locale, com);
} else {
ref = dnref;
dncache = ref.get(locale, com);
}
}
}
Key matchKey = createKey(matchID);
if (matchKey == null) {
return dncache;
}
SortedMap result = new TreeMap(dncache);
Iterator iter = result.entrySet().iterator();
while (iter.hasNext()) {
Entry e = (Entry)iter.next();
if (!matchKey.isFallbackOf((String)e.getValue())) {
iter.remove();
}
}
return result;
}
// we define a class so we get atomic simultaneous access to the
// locale, comparator, and corresponding map.
private static class LocaleRef {
private final ULocale locale;
private SoftReference ref;
private Comparator com;
LocaleRef(Map dnCache, ULocale locale, Comparator com) {
this.locale = locale;
this.com = com;
this.ref = new SoftReference(dnCache);
}
SortedMap get(ULocale loc, Comparator comp) {
SortedMap m = (SortedMap)ref.get();
if (m != null &&
this.locale.equals(loc) &&
(this.com == comp || (this.com != null && this.com.equals(comp)))) {
return m;
}
return null;
}
}
private LocaleRef dnref;
/**
* Return a snapshot of the currently registered factories. There
* is no guarantee that the list will still match the current
* factory list of the service subsequent to this call.
*/
public final List factories() {
try {
factoryLock.acquireRead();
return new ArrayList(factories);
}
finally{
factoryLock.releaseRead();
}
}
/**
* A convenience override of registerObject(Object, String, boolean)
* that defaults visible to true.
*/
public Factory registerObject(Object obj, String id) {
return registerObject(obj, id, true);
}
/**
* Register an object with the provided id. The id will be
* canonicalized. The canonicalized ID will be returned by
* getVisibleIDs if visible is true.
*/
public Factory registerObject(Object obj, String id, boolean visible) {
String canonicalID = createKey(id).canonicalID();
return registerFactory(new SimpleFactory(obj, canonicalID, visible));
}
/**
* Register a Factory. Returns the factory if the service accepts
* the factory, otherwise returns null. The default implementation
* accepts all factories.
*/
public final Factory registerFactory(Factory factory) {
if (factory == null) {
throw new NullPointerException();
}
try {
factoryLock.acquireWrite();
factories.add(0, factory);
clearCaches();
}
finally {
factoryLock.releaseWrite();
}
notifyChanged();
return factory;
}
/**
* Unregister a factory. The first matching registered factory will
* be removed from the list. Returns true if a matching factory was
* removed.
*/
public final boolean unregisterFactory(Factory factory) {
if (factory == null) {
throw new NullPointerException();
}
boolean result = false;
try {
factoryLock.acquireWrite();
if (factories.remove(factory)) {
result = true;
clearCaches();
}
}
finally {
factoryLock.releaseWrite();
}
if (result) {
notifyChanged();
}
return result;
}
/**
* Reset the service to the default factories. The factory
* lock is acquired and then reInitializeFactories is called.
*/
public final void reset() {
try {
factoryLock.acquireWrite();
reInitializeFactories();
clearCaches();
}
finally {
factoryLock.releaseWrite();
}
notifyChanged();
}
/**
* Reinitialize the factory list to its default state. By default
* this clears the list. Subclasses can override to provide other
* default initialization of the factory list. Subclasses must
* not call this method directly, as it must only be called while
* holding write access to the factory list.
*/
protected void reInitializeFactories() {
factories.clear();
}
/**
* Return true if the service is in its default state. The default
* implementation returns true if there are no factories registered.
*/
public boolean isDefault() {
return factories.size() == defaultSize;
}
/**
* Set the default size to the current number of registered factories.
* Used by subclasses to customize the behavior of isDefault.
*/
protected void markDefault() {
defaultSize = factories.size();
}
/**
* Create a key from an id. This creates a Key instance.
* Subclasses can override to define more useful keys appropriate
* to the factories they accept. If id is null, returns null.
*/
public Key createKey(String id) {
return id == null ? null : new Key(id);
}
/**
* Clear caches maintained by this service. Subclasses can
* override if they implement additional that need to be cleared
* when the service changes. Subclasses should generally not call
* this method directly, as it must only be called while
* synchronized on this.
*/
protected void clearCaches() {
// we don't synchronize on these because methods that use them
// copy before use, and check for changes if they modify the
// caches.
cacheref = null;
idref = null;
dnref = null;
}
/**
* Clears only the service cache.
* This can be called by subclasses when a change affects the service
* cache but not the id caches, e.g., when the default locale changes
* the resolution of ids changes, but not the visible ids themselves.
*/
protected void clearServiceCache() {
cacheref = null;
}
/**
* ServiceListener is the listener that ICUService provides by default.
* ICUService will notifiy this listener when factories are added to
* or removed from the service. Subclasses can provide
* different listener interfaces that extend EventListener, and modify
* acceptsListener and notifyListener as appropriate.
*/
public static interface ServiceListener extends EventListener {
public void serviceChanged(ICUService service);
}
/**
* Return true if the listener is accepted; by default this
* requires a ServiceListener. Subclasses can override to accept
* different listeners.
*/
protected boolean acceptsListener(EventListener l) {
return l instanceof ServiceListener;
}
/**
* Notify the listener, which by default is a ServiceListener.
* Subclasses can override to use a different listener.
*/
protected void notifyListener(EventListener l) {
((ServiceListener)l).serviceChanged(this);
}
/**
* Return a string describing the statistics for this service.
* This also resets the statistics. Used for debugging purposes.
*/
public String stats() {
ICURWLock.Stats stats = factoryLock.resetStats();
if (stats != null) {
return stats.toString();
}
return "no stats";
}
/**
* Return the name of this service. This will be the empty string if none was assigned.
*/
public String getName() {
return name;
}
/**
* Returns the result of super.toString, appending the name in curly braces.
*/
public String toString() {
return super.toString() + "{" + name + "}";
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/ICUData.java 0000644 0001750 0001750 00000010076 10647446760 020565 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2004-2007, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*
* Created on Feb 4, 2004
*
*/
package com.ibm.icu.impl;
import java.io.InputStream;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.MissingResourceException;
/**
* Provides access to ICU data files as InputStreams. Implements security checking.
*/
public final class ICUData {
/*
* Return a URL to the ICU resource names resourceName. The
* resource name should either be an absolute path, or a path relative to
* com.ibm.icu.impl (e.g., most likely it is 'data/foo'). If required
* is true, throw an MissingResourceException instead of returning a null result.
*/
public static boolean exists(final String resourceName) {
URL i = null;
if (System.getSecurityManager() != null) {
i = (URL)AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return ICUData.class.getResource(resourceName);
}
});
} else {
i = ICUData.class.getResource(resourceName);
}
return i != null;
}
private static InputStream getStream(final Class root, final String resourceName, boolean required) {
InputStream i = null;
if (System.getSecurityManager() != null) {
i = (InputStream)AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return root.getResourceAsStream(resourceName);
}
});
} else {
i = root.getResourceAsStream(resourceName);
}
if (i == null && required) {
throw new MissingResourceException("could not locate data " +resourceName, root.getPackage().getName(), resourceName);
}
return i;
}
private static InputStream getStream(final ClassLoader loader, final String resourceName, boolean required) {
InputStream i = null;
if (System.getSecurityManager() != null) {
i = (InputStream)AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return loader.getResourceAsStream(resourceName);
}
});
} else {
i = loader.getResourceAsStream(resourceName);
}
if (i == null && required) {
throw new MissingResourceException("could not locate data", loader.toString(), resourceName);
}
return i;
}
public static InputStream getStream(ClassLoader loader, String resourceName){
return getStream(loader,resourceName, false);
}
public static InputStream getRequiredStream(ClassLoader loader, String resourceName){
return getStream(loader, resourceName, true);
}
/*
* Convenience override that calls getStream(ICUData.class, resourceName, false);
*/
public static InputStream getStream(String resourceName) {
return getStream(ICUData.class, resourceName, false);
}
/*
* Convenience method that calls getStream(ICUData.class, resourceName, true).
*/
public static InputStream getRequiredStream(String resourceName) {
return getStream(ICUData.class, resourceName, true);
}
/*
* Convenience override that calls getStream(root, resourceName, false);
*/
public static InputStream getStream(Class root, String resourceName) {
return getStream(root, resourceName, false);
}
/*
* Convenience method that calls getStream(root, resourceName, true).
*/
public static InputStream getRequiredStream(Class root, String resourceName) {
return getStream(root, resourceName, true);
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/URLHandler.java 0000644 0001750 0001750 00000017726 10314625402 021303 0 ustar twerner twerner /*
******************************************************************************
* Copyright (C) 2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
package com.ibm.icu.impl;
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public abstract class URLHandler {
public static final String PROPNAME = "urlhandler.props";
private static final Map handlers;
private static final boolean DEBUG = ICUDebug.enabled("URLHandler");
static {
Map h = null;
try {
InputStream is = URLHandler.class.getResourceAsStream(PROPNAME);
if (is == null) {
is = ClassLoader.getSystemClassLoader().getResourceAsStream(PROPNAME);
}
if (is != null) {
Class[] params = { URL.class };
BufferedReader br = new BufferedReader(new InputStreamReader(is));
for (String line = br.readLine(); line != null; line = br.readLine()) {
line = line.trim();
if (line.length() == 0 || line.charAt(0) == '#') {
continue;
}
int ix = line.indexOf('=');
if (ix == -1) {
if (DEBUG) System.err.println("bad urlhandler line: '" + line + "'");
break;
}
String key = line.substring(0, ix).trim();
String value = line.substring(ix+1).trim();
try {
Class cl = Class.forName(value);
Method m = cl.getDeclaredMethod("get", params);
if (h == null) {
h = new HashMap();
}
h.put(key, m);
}
catch (ClassNotFoundException e) {
if (DEBUG) System.err.println(e);
}
catch(NoSuchMethodException e) {
if (DEBUG) System.err.println(e);
}
catch(SecurityException e) {
if (DEBUG) System.err.println(e);
}
}
}
} catch (Throwable t) {
if (DEBUG) System.err.println(t);
}
handlers = h;
}
public static URLHandler get(URL url) {
if (url == null) {
return null;
}
String protocol = url.getProtocol();
if (handlers != null) {
Method m = (Method)handlers.get(protocol);
if (m != null) {
try {
URLHandler handler = (URLHandler)m.invoke(null, new Object[] { url });
if (handler != null) {
return handler;
}
}
catch(IllegalAccessException e) {
if (DEBUG) System.err.println(e);
}
catch(IllegalArgumentException e) {
if (DEBUG) System.err.println(e);
}
catch(InvocationTargetException e) {
if (DEBUG) System.err.println(e);
}
}
}
return getDefault(url);
}
protected static URLHandler getDefault(URL url) {
String protocol = url.getProtocol();
if (protocol.equals("file")) {
return new FileURLHandler(url);
} else if (protocol.equals("jar")) {
return new JarURLHandler(url);
} else {
return null;
}
}
private static class FileURLHandler extends URLHandler {
File file;
String root;
FileURLHandler(URL url) {
root = url.getPath();
file = new File(root);
if (!file.exists()) {
if (DEBUG) System.err.println("file does not exist");
throw new IllegalArgumentException();
}
}
public void guide(URLVisitor v, boolean recurse, boolean strip) {
if (file.isDirectory()) {
process(v, recurse, strip, "/", file.listFiles());
} else {
v.visit(file.getName());
}
}
private void process(URLVisitor v, boolean recurse, boolean strip, String path, File[] files) {
for (int i = 0; i < files.length; i++) {
File f = files[i];
if (f.isDirectory()) {
if (recurse) {
process(v, recurse, strip, path + f.getName()+ '/', f.listFiles());
}
} else {
v.visit(strip? f.getName() : path + f.getName());
}
}
}
}
private static class JarURLHandler extends URLHandler {
JarFile jarFile;
String prefix;
JarURLHandler(URL url) {
try {
prefix = url.getPath();
int ix = prefix.indexOf("!/");
if (ix >= 0) {
prefix = prefix.substring(ix + 2); // truncate after "!/"
}
JarURLConnection conn = (JarURLConnection)url.openConnection();
jarFile = conn.getJarFile();
}
catch (Exception e) {
if (DEBUG) System.err.println("icurb jar error: " + e);
throw new IllegalArgumentException("jar error: " + e.getMessage());
}
}
public void guide(URLVisitor v, boolean recurse, boolean strip) {
try {
Enumeration entries = jarFile.entries();
while (entries.hasMoreElements()) {
JarEntry entry = (JarEntry)entries.nextElement();
if (!entry.isDirectory()) { // skip just directory paths
String name = entry.getName();
if (name.startsWith(prefix)) {
name = name.substring(prefix.length());
int ix = name.lastIndexOf('/');
if (ix != -1) {
if (!recurse) {
continue;
}
if (strip) {
name = name.substring(ix+1);
}
}
v.visit(name);
}
}
}
}
catch (Exception e) {
if (DEBUG) System.err.println("icurb jar error: " + e);
}
}
}
public void guide(URLVisitor visitor, boolean recurse)
{
guide(visitor, recurse, true);
}
public abstract void guide(URLVisitor visitor, boolean recurse, boolean strip);
public interface URLVisitor {
void visit(String str);
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/UCharArrayIterator.java 0000644 0001750 0001750 00000004416 10053252401 023041 0 ustar twerner twerner /**
*******************************************************************************
* Copyright (C) 1996-2004, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
import com.ibm.icu.text.*;
/**
* @author Doug Felt
*
*/
public final class UCharArrayIterator extends UCharacterIterator {
private final char[] text;
private final int start;
private final int limit;
private int pos;
public UCharArrayIterator(char[] text, int start, int limit) {
if (start < 0 || limit > text.length || start > limit) {
throw new IllegalArgumentException("start: " + start + " or limit: "
+ limit + " out of range [0, "
+ text.length + ")");
}
this.text = text;
this.start = start;
this.limit = limit;
this.pos = start;
}
public int current() {
return pos < limit ? text[pos] : DONE;
}
public int getLength() {
return limit - start;
}
public int getIndex() {
return pos - start;
}
public int next() {
return pos < limit ? text[pos++] : DONE;
}
public int previous() {
return pos > start ? text[--pos] : DONE;
}
public void setIndex(int index) {
if (index < 0 || index > limit - start) {
throw new IndexOutOfBoundsException("index: " + index +
" out of range [0, "
+ (limit - start) + ")");
}
pos = start + index;
}
public int getText(char[] fillIn, int offset) {
int len = limit - start;
System.arraycopy(text, start, fillIn, offset, len);
return len;
}
/**
* Creates a copy of this iterator, does not clone the underlying
* Replaceableobject
* @return copy of this iterator
*/
public Object clone(){
try {
return super.clone();
} catch (CloneNotSupportedException e) {
return null; // never invoked
}
}
} icu4j-4.2.1.1/src/com/ibm/icu/impl/ZoneStringFormat.java 0000644 0001750 0001750 00000134013 11174533127 022612 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 2007-2009, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Set;
import com.ibm.icu.text.MessageFormat;
import com.ibm.icu.util.BasicTimeZone;
import com.ibm.icu.util.Calendar;
import com.ibm.icu.util.TimeZone;
import com.ibm.icu.util.TimeZoneTransition;
import com.ibm.icu.util.ULocale;
import com.ibm.icu.util.UResourceBundle;
/**
* @author yoshito
*
*/
public class ZoneStringFormat {
/**
* Constructs a ZoneStringFormat by zone strings array.
* The internal structure of zoneStrings is compatible with
* the one used by getZoneStrings/setZoneStrings in DateFormatSymbols.
*
* @param zoneStrings zone strings
*/
public ZoneStringFormat(String[][] zoneStrings) {
tzidToStrings = new HashMap();
zoneStringsTrie = new TextTrieMap(true);
for (int i = 0; i < zoneStrings.length; i++) {
String tzid = zoneStrings[i][0];
String[] names = new String[ZSIDX_MAX];
for (int j = 1; j < zoneStrings[i].length; j++) {
if (zoneStrings[i][j] != null) {
int typeIdx = getNameTypeIndex(j);
if (typeIdx != -1) {
names[typeIdx] = zoneStrings[i][j];
// Put the name into the trie
int type = getNameType(typeIdx);
ZoneStringInfo zsinfo = new ZoneStringInfo(tzid, zoneStrings[i][j], type);
zoneStringsTrie.put(zoneStrings[i][j], zsinfo);
}
}
}
ZoneStrings zstrings = new ZoneStrings(names, true, null);
tzidToStrings.put(tzid, zstrings);
}
isFullyLoaded = true;
}
/**
* Gets an instance of ZoneStringFormat for the specified locale
* @param locale the locale
* @return An instance of ZoneStringFormat for the locale
*/
public static ZoneStringFormat getInstance(ULocale locale) {
ZoneStringFormat tzf = (ZoneStringFormat)TZFORMAT_CACHE.get(locale);
if (tzf == null) {
tzf = new ZoneStringFormat(locale);
TZFORMAT_CACHE.put(locale, tzf);
}
return tzf;
}
public String[][] getZoneStrings() {
return getZoneStrings(System.currentTimeMillis());
}
// APIs used by SimpleDateFormat to get a zone string
public String getSpecificLongString(Calendar cal) {
if (cal.get(Calendar.DST_OFFSET) == 0) {
return getString(cal.getTimeZone().getID(), ZSIDX_LONG_STANDARD, cal.getTimeInMillis(), false /* not used */);
}
return getString(cal.getTimeZone().getID(), ZSIDX_LONG_DAYLIGHT, cal.getTimeInMillis(), false /* not used */);
}
public String getSpecificShortString(Calendar cal, boolean commonlyUsedOnly) {
if (cal.get(Calendar.DST_OFFSET) == 0) {
return getString(cal.getTimeZone().getID(), ZSIDX_SHORT_STANDARD, cal.getTimeInMillis(), commonlyUsedOnly);
}
return getString(cal.getTimeZone().getID(), ZSIDX_SHORT_DAYLIGHT, cal.getTimeInMillis(), commonlyUsedOnly);
}
public String getGenericLongString(Calendar cal) {
return getGenericString(cal, false /* long */, false /* not used */);
}
public String getGenericShortString(Calendar cal, boolean commonlyUsedOnly) {
return getGenericString(cal, true /* long */, commonlyUsedOnly);
}
public String getGenericLocationString(Calendar cal) {
return getString(cal.getTimeZone().getID(), ZSIDX_LOCATION, cal.getTimeInMillis(), false /* not used */);
}
// APIs used by SimpleDateFormat to lookup a zone string
public static class ZoneStringInfo {
private String id;
private String str;
private int type;
private ZoneStringInfo(String id, String str, int type) {
this.id = id;
this.str = str;
this.type = type;
}
public String getID() {
return id;
}
public String getString() {
return str;
}
public boolean isStandard() {
if ((type & STANDARD_LONG) != 0 || (type & STANDARD_SHORT) != 0) {
return true;
}
return false;
}
public boolean isDaylight() {
if ((type & DAYLIGHT_LONG) != 0 || (type & DAYLIGHT_SHORT) != 0) {
return true;
}
return false;
}
public boolean isGeneric() {
return !isStandard() && !isDaylight();
}
private int getType() {
return type;
}
}
public ZoneStringInfo findSpecificLong(String text, int start) {
return find(text, start, STANDARD_LONG | DAYLIGHT_LONG);
}
public ZoneStringInfo findSpecificShort(String text, int start) {
return find(text, start, STANDARD_SHORT | DAYLIGHT_SHORT);
}
public ZoneStringInfo findGenericLong(String text, int start) {
return find(text, start, GENERIC_LONG | STANDARD_LONG | LOCATION);
}
public ZoneStringInfo findGenericShort(String text, int start) {
return find(text, start, GENERIC_SHORT | STANDARD_SHORT | LOCATION);
}
public ZoneStringInfo findGenericLocation(String text, int start) {
return find(text, start, LOCATION);
}
// Following APIs are not used by SimpleDateFormat, but public for testing purpose
public String getLongStandard(String tzid, long date) {
return getString(tzid, ZSIDX_LONG_STANDARD, date, false /* not used */);
}
public String getLongDaylight(String tzid, long date) {
return getString(tzid, ZSIDX_LONG_DAYLIGHT, date, false /* not used */);
}
public String getLongGenericNonLocation(String tzid, long date) {
return getString(tzid, ZSIDX_LONG_GENERIC, date, false /* not used */);
}
public String getLongGenericPartialLocation(String tzid, long date) {
return getGenericPartialLocationString(tzid, false, date, false /* not used */);
}
public String getShortStandard(String tzid, long date, boolean commonlyUsedOnly) {
return getString(tzid, ZSIDX_SHORT_STANDARD, date, commonlyUsedOnly);
}
public String getShortDaylight(String tzid, long date, boolean commonlyUsedOnly) {
return getString(tzid, ZSIDX_SHORT_DAYLIGHT, date, commonlyUsedOnly);
}
public String getShortGenericNonLocation(String tzid, long date, boolean commonlyUsedOnly) {
return getString(tzid, ZSIDX_SHORT_GENERIC, date, commonlyUsedOnly);
}
public String getShortGenericPartialLocation(String tzid, long date, boolean commonlyUsedOnly) {
return getGenericPartialLocationString(tzid, true, date, commonlyUsedOnly);
}
public String getGenericLocation(String tzid) {
return getString(tzid, ZSIDX_LOCATION, 0L /* not used */, false /* not used */);
}
/**
* Constructs a ZoneStringFormat by locale. Because an instance of ZoneStringFormat
* is read-only, only one instance for a locale is sufficient. Thus, this
* constructor is protected and only called from getInstance(ULocale) to
* create one for a locale.
* @param locale The locale
*/
protected ZoneStringFormat(ULocale locale) {
this.locale = locale;
tzidToStrings = new HashMap();
mzidToStrings = new HashMap();
zoneStringsTrie = new TextTrieMap(true);
}
// Load only a single zone
private synchronized void loadZone(String id) {
if (isFullyLoaded) {
return;
}
String tzid = ZoneMeta.getCanonicalSystemID(id);
if (tzid == null || tzidToStrings.containsKey(tzid)) {
return;
}
ICUResourceBundle zoneStringsBundle = null;
try {
ICUResourceBundle bundle = (ICUResourceBundle)UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, locale);
zoneStringsBundle = bundle.getWithFallback("zoneStrings");
} catch (MissingResourceException e) {
// If no locale bundles are available, zoneStringsBundle will be null.
// We still want to go through the rest of zone strings initialization,
// because generic location format is generated from tzid for the case.
// The rest of code should work even zoneStrings is null.
}
String[] zstrarray = new String[ZSIDX_MAX];
String[] mzstrarray = new String[ZSIDX_MAX];
String[][] mzPartialLoc = new String[10][4]; // maximum 10 metazones per zone
addSingleZone(tzid, zoneStringsBundle,
getFallbackFormat(locale), getRegionFormat(locale),
zstrarray, mzstrarray, mzPartialLoc);
}
// Loading all zone strings
private synchronized void loadFull() {
if (isFullyLoaded) {
return;
}
ICUResourceBundle zoneStringsBundle = null;
try {
ICUResourceBundle bundle = (ICUResourceBundle)UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, locale);
zoneStringsBundle = bundle.getWithFallback("zoneStrings");
} catch (MissingResourceException e) {
// If no locale bundles are available, zoneStringsBundle will be null.
// We still want to go through the rest of zone strings initialization,
// because generic location format is generated from tzid for the case.
// The rest of code should work even zoneStrings is null.
}
String[] zoneIDs = TimeZone.getAvailableIDs();
String[] zstrarray = new String[ZSIDX_MAX];
String[] mzstrarray = new String[ZSIDX_MAX];
String[][] mzPartialLoc = new String[10][4]; // maximum 10 metazones per zone
for (int i = 0; i < zoneIDs.length; i++) {
// Skip aliases
String tzid = ZoneMeta.getCanonicalSystemID(zoneIDs[i]);
if (tzid == null || !zoneIDs[i].equals(tzid)) {
continue;
}
if (tzidToStrings.containsKey(tzid)) {
continue;
}
addSingleZone(tzid, zoneStringsBundle,
getFallbackFormat(locale), getRegionFormat(locale),
zstrarray, mzstrarray, mzPartialLoc);
}
isFullyLoaded = true;
}
// This internal initialization code must be called in a synchronized block
private void addSingleZone(String tzid, ICUResourceBundle zoneStringsBundle,
MessageFormat fallbackFmt, MessageFormat regionFmt,
String[] zstrarray, String[] mzstrarray, String[][] mzPartialLoc) {
if (tzidToStrings.containsKey(tzid)) {
return;
}
String zoneKey = tzid.replace('/', ':');
zstrarray[ZSIDX_LONG_STANDARD] = getZoneStringFromBundle(zoneStringsBundle, zoneKey, RESKEY_LONG_STANDARD);
zstrarray[ZSIDX_SHORT_STANDARD] = getZoneStringFromBundle(zoneStringsBundle, zoneKey, RESKEY_SHORT_STANDARD);
zstrarray[ZSIDX_LONG_DAYLIGHT] = getZoneStringFromBundle(zoneStringsBundle, zoneKey, RESKEY_LONG_DAYLIGHT);
zstrarray[ZSIDX_SHORT_DAYLIGHT] = getZoneStringFromBundle(zoneStringsBundle, zoneKey, RESKEY_SHORT_DAYLIGHT);
zstrarray[ZSIDX_LONG_GENERIC] = getZoneStringFromBundle(zoneStringsBundle, zoneKey, RESKEY_LONG_GENERIC);
zstrarray[ZSIDX_SHORT_GENERIC] = getZoneStringFromBundle(zoneStringsBundle, zoneKey, RESKEY_SHORT_GENERIC);
// Compose location format string
String countryCode = ZoneMeta.getCanonicalCountry(tzid);
String country = null;
String city = null;
if (countryCode != null) {
city = getZoneStringFromBundle(zoneStringsBundle, zoneKey, RESKEY_EXEMPLAR_CITY);
if (city == null) {
city = tzid.substring(tzid.lastIndexOf('/') + 1).replace('_', ' ');
}
country = getLocalizedCountry(countryCode, locale);
if (ZoneMeta.getSingleCountry(tzid) != null) {
// If the zone is only one zone in the country, do not add city
zstrarray[ZSIDX_LOCATION] = regionFmt.format(new Object[] {country});
} else {
zstrarray[ZSIDX_LOCATION] = fallbackFmt.format(new Object[] {city, country});
}
} else {
if (tzid.startsWith("Etc/")) {
// "Etc/xxx" is not associated with a specific location, so localized
// GMT format is always used as generic location format.
zstrarray[ZSIDX_LOCATION] = null;
} else {
// When a new time zone ID, which is actually associated with a specific
// location, is added in tzdata, but the current CLDR data does not have
// the information yet, ICU creates a generic location string based on
// the ID. This implementation supports canonical time zone round trip
// with format pattern "VVVV". See #6602 for the details.
String location = tzid;
int slashIdx = location.lastIndexOf('/');
if (slashIdx == -1) {
// A time zone ID without slash in the tz database is not
// associated with a specific location. For instances,
// MET, CET, EET and WET fall into this catetory.
zstrarray[ZSIDX_LOCATION] = null;
} else {
location = tzid.substring(slashIdx + 1);
zstrarray[ZSIDX_LOCATION] = regionFmt.format(new Object[] {location});
}
}
}
boolean commonlyUsed = isCommonlyUsed(zoneStringsBundle, zoneKey);
// Resolve metazones used by this zone
int mzPartialLocIdx = 0;
Map olsonToMeta = ZoneMeta.getOlsonToMetaMap();
List metazoneMappings = (List)olsonToMeta.get(tzid);
if (metazoneMappings != null) {
Iterator it = metazoneMappings.iterator();
while (it.hasNext()) {
ZoneMeta.OlsonToMetaMappingEntry mzmap = (ZoneMeta.OlsonToMetaMappingEntry)it.next();
ZoneStrings mzStrings = (ZoneStrings)mzidToStrings.get(mzmap.mzid);
if (mzStrings == null) {
// If the metazone strings are not yet processed, do it now.
String mzkey = "meta:" + mzmap.mzid;
boolean mzCommonlyUsed = isCommonlyUsed(zoneStringsBundle, mzkey);
mzstrarray[ZSIDX_LONG_STANDARD] = getZoneStringFromBundle(zoneStringsBundle, mzkey, RESKEY_LONG_STANDARD);
mzstrarray[ZSIDX_SHORT_STANDARD] = getZoneStringFromBundle(zoneStringsBundle, mzkey, RESKEY_SHORT_STANDARD);
mzstrarray[ZSIDX_LONG_DAYLIGHT] = getZoneStringFromBundle(zoneStringsBundle, mzkey, RESKEY_LONG_DAYLIGHT);
mzstrarray[ZSIDX_SHORT_DAYLIGHT] = getZoneStringFromBundle(zoneStringsBundle, mzkey, RESKEY_SHORT_DAYLIGHT);
mzstrarray[ZSIDX_LONG_GENERIC] = getZoneStringFromBundle(zoneStringsBundle, mzkey, RESKEY_LONG_GENERIC);
mzstrarray[ZSIDX_SHORT_GENERIC] = getZoneStringFromBundle(zoneStringsBundle, mzkey, RESKEY_SHORT_GENERIC);
mzstrarray[ZSIDX_LOCATION] = null;
mzStrings = new ZoneStrings(mzstrarray, mzCommonlyUsed, null);
mzidToStrings.put(mzmap.mzid, mzStrings);
// Add metazone strings to the zone string trie
String preferredIdForLocale = ZoneMeta.getZoneIdByMetazone(mzmap.mzid, getRegion());
for (int j = 0; j < mzstrarray.length; j++) {
if (mzstrarray[j] != null) {
int type = getNameType(j);
ZoneStringInfo zsinfo = new ZoneStringInfo(preferredIdForLocale, mzstrarray[j], type);
zoneStringsTrie.put(mzstrarray[j], zsinfo);
}
}
}
// Compose generic partial location format
String lg = mzStrings.getString(ZSIDX_LONG_GENERIC);
String sg = mzStrings.getString(ZSIDX_SHORT_GENERIC);
if (lg != null || sg != null) {
boolean addMzPartialLocationNames = true;
for (int j = 0; j < mzPartialLocIdx; j++) {
if (mzPartialLoc[j][0].equals(mzmap.mzid)) {
// already added
addMzPartialLocationNames = false;
break;
}
}
if (addMzPartialLocationNames) {
String locationPart = null;
// Check if the zone is the preferred zone for the territory associated with the zone
String preferredID = ZoneMeta.getZoneIdByMetazone(mzmap.mzid, countryCode);
if (tzid.equals(preferredID)) {
// Use country for the location
locationPart = country;
} else {
// Use city for the location
locationPart = city;
}
mzPartialLoc[mzPartialLocIdx][0] = mzmap.mzid;
mzPartialLoc[mzPartialLocIdx][1] = null;
mzPartialLoc[mzPartialLocIdx][2] = null;
mzPartialLoc[mzPartialLocIdx][3] = null;
if (locationPart != null) {
if (lg != null) {
mzPartialLoc[mzPartialLocIdx][1] = fallbackFmt.format(new Object[] {locationPart, lg});
}
if (sg != null) {
mzPartialLoc[mzPartialLocIdx][2] = fallbackFmt.format(new Object[] {locationPart, sg});
boolean shortMzCommonlyUsed = mzStrings.isShortFormatCommonlyUsed();
if (shortMzCommonlyUsed) {
mzPartialLoc[mzPartialLocIdx][3] = "1";
}
}
}
mzPartialLocIdx++;
}
}
}
}
String[][] genericPartialLocationNames = null;
if (mzPartialLocIdx != 0) {
// metazone generic partial location names are collected
genericPartialLocationNames = new String[mzPartialLocIdx][];
for (int mzi = 0; mzi < mzPartialLocIdx; mzi++) {
genericPartialLocationNames[mzi] = (String[])mzPartialLoc[mzi].clone();
}
}
// Finally, create ZoneStrings instance and put it into the tzidToStinrgs map
ZoneStrings zstrings = new ZoneStrings(zstrarray, commonlyUsed, genericPartialLocationNames);
tzidToStrings.put(tzid, zstrings);
// Also add all available names to the zone string trie
if (zstrarray != null) {
for (int j = 0; j < zstrarray.length; j++) {
if (zstrarray[j] != null) {
int type = getNameType(j);
ZoneStringInfo zsinfo = new ZoneStringInfo(tzid, zstrarray[j], type);
zoneStringsTrie.put(zstrarray[j], zsinfo);
}
}
}
if (genericPartialLocationNames != null) {
for (int j = 0; j < genericPartialLocationNames.length; j++) {
ZoneStringInfo zsinfo;
if (genericPartialLocationNames[j][1] != null) {
zsinfo = new ZoneStringInfo(tzid, genericPartialLocationNames[j][1], GENERIC_LONG);
zoneStringsTrie.put(genericPartialLocationNames[j][1], zsinfo);
}
if (genericPartialLocationNames[j][2] != null) {
zsinfo = new ZoneStringInfo(tzid, genericPartialLocationNames[j][1], GENERIC_SHORT);
zoneStringsTrie.put(genericPartialLocationNames[j][2], zsinfo);
}
}
}
}
// Name types, these bit flag are used for zone string lookup
private static final int LOCATION = 0x0001;
private static final int GENERIC_LONG = 0x0002;
private static final int GENERIC_SHORT = 0x0004;
private static final int STANDARD_LONG = 0x0008;
private static final int STANDARD_SHORT = 0x0010;
private static final int DAYLIGHT_LONG = 0x0020;
private static final int DAYLIGHT_SHORT = 0x0040;
// Name type index, these constants are used for index in ZoneStrings.strings
private static final int ZSIDX_LOCATION = 0;
private static final int ZSIDX_LONG_STANDARD = 1;
private static final int ZSIDX_SHORT_STANDARD = 2;
private static final int ZSIDX_LONG_DAYLIGHT = 3;
private static final int ZSIDX_SHORT_DAYLIGHT = 4;
private static final int ZSIDX_LONG_GENERIC = 5;
private static final int ZSIDX_SHORT_GENERIC = 6;
private static final int ZSIDX_MAX = ZSIDX_SHORT_GENERIC + 1;
// ZoneStringFormat cache
private static ICUCache TZFORMAT_CACHE = new SimpleCache();
/*
* The translation type of the translated zone strings
*/
private static final String
RESKEY_SHORT_GENERIC = "sg",
RESKEY_SHORT_STANDARD = "ss",
RESKEY_SHORT_DAYLIGHT = "sd",
RESKEY_LONG_GENERIC = "lg",
RESKEY_LONG_STANDARD = "ls",
RESKEY_LONG_DAYLIGHT = "ld",
RESKEY_EXEMPLAR_CITY = "ec",
RESKEY_COMMONLY_USED = "cu";
// Window size used for DST check for a zone in a metazone
private static final long DST_CHECK_RANGE = 184L*(24*60*60*1000);
// Map from zone id to ZoneStrings
private Map tzidToStrings;
// Map from metazone id to ZoneStrings
private Map mzidToStrings;
// Zone string dictionary, used for look up
private TextTrieMap zoneStringsTrie;
// Locale used for initializing zone strings
private ULocale locale;
// Region used for resolving a zone in a metazone, initialized by locale
private transient String region;
// Loading status
private boolean isFullyLoaded = false;
/*
* Private method to get a zone string except generic partial location types.
*/
private String getString(String tzid, int typeIdx, long date, boolean commonlyUsedOnly) {
if (!isFullyLoaded) {
// Lazy loading
loadZone(tzid);
}
String result = null;
ZoneStrings zstrings = (ZoneStrings)tzidToStrings.get(tzid);
if (zstrings == null) {
// ICU's own array does not have entries for aliases
String canonicalID = ZoneMeta.getCanonicalSystemID(tzid);
if (canonicalID != null && !canonicalID.equals(tzid)) {
// Canonicalize tzid here. The rest of operations
// require tzid to be canonicalized.
tzid = canonicalID;
zstrings = (ZoneStrings)tzidToStrings.get(tzid);
}
}
if (zstrings != null) {
switch (typeIdx) {
case ZSIDX_LONG_STANDARD:
case ZSIDX_LONG_DAYLIGHT:
case ZSIDX_LONG_GENERIC:
case ZSIDX_LOCATION:
result = zstrings.getString(typeIdx);
break;
case ZSIDX_SHORT_STANDARD:
case ZSIDX_SHORT_DAYLIGHT:
case ZSIDX_SHORT_GENERIC:
if (!commonlyUsedOnly || zstrings.isShortFormatCommonlyUsed()) {
result = zstrings.getString(typeIdx);
}
break;
}
}
if (result == null && mzidToStrings != null && typeIdx != ZSIDX_LOCATION) {
// Try metazone
String mzid = ZoneMeta.getMetazoneID(tzid, date);
if (mzid != null) {
ZoneStrings mzstrings = (ZoneStrings)mzidToStrings.get(mzid);
if (mzstrings != null) {
switch (typeIdx) {
case ZSIDX_LONG_STANDARD:
case ZSIDX_LONG_DAYLIGHT:
case ZSIDX_LONG_GENERIC:
result = mzstrings.getString(typeIdx);
break;
case ZSIDX_SHORT_STANDARD:
case ZSIDX_SHORT_DAYLIGHT:
case ZSIDX_SHORT_GENERIC:
if (!commonlyUsedOnly || mzstrings.isShortFormatCommonlyUsed()) {
result = mzstrings.getString(typeIdx);
}
break;
}
}
}
}
return result;
}
/*
* Private method to get a generic string, with fallback logic involved,
* that is,
*
* 1. If a generic non-location string is avaiable for the zone, return it.
* 2. If a generic non-location string is associated with a metazone and
* the zone never use daylight time around the given date, use the standard
* string (if available).
*
* Note: In CLDR1.5.1, the same localization is used for generic and standard.
* In this case, we do not use the standard string and do the rest.
*
* 3. If a generic non-location string is associated with a metazone and
* the offset at the given time is different from the preferred zone for the
* current locale, then return the generic partial location string (if avaiable)
* 4. If a generic non-location string is not available, use generic location
* string.
*/
private String getGenericString(Calendar cal, boolean isShort, boolean commonlyUsedOnly) {
String result = null;
TimeZone tz = cal.getTimeZone();
String tzid = tz.getID();
if (!isFullyLoaded) {
// Lazy loading
loadZone(tzid);
}
ZoneStrings zstrings = (ZoneStrings)tzidToStrings.get(tzid);
if (zstrings == null) {
// ICU's own array does not have entries for aliases
String canonicalID = ZoneMeta.getCanonicalSystemID(tzid);
if (canonicalID != null && !canonicalID.equals(tzid)) {
// Canonicalize tzid here. The rest of operations
// require tzid to be canonicalized.
tzid = canonicalID;
zstrings = (ZoneStrings)tzidToStrings.get(tzid);
}
}
if (zstrings != null) {
if (isShort) {
if (!commonlyUsedOnly || zstrings.isShortFormatCommonlyUsed()) {
result = zstrings.getString(ZSIDX_SHORT_GENERIC);
}
} else {
result = zstrings.getString(ZSIDX_LONG_GENERIC);
}
}
if (result == null && mzidToStrings != null) {
// try metazone
long time = cal.getTimeInMillis();
String mzid = ZoneMeta.getMetazoneID(tzid, time);
if (mzid != null) {
boolean useStandard = false;
if (cal.get(Calendar.DST_OFFSET) == 0) {
useStandard = true;
// Check if the zone actually uses daylight saving time around the time
if (tz instanceof BasicTimeZone) {
BasicTimeZone btz = (BasicTimeZone)tz;
TimeZoneTransition before = btz.getPreviousTransition(time, true);
if (before != null
&& (time - before.getTime() < DST_CHECK_RANGE)
&& before.getFrom().getDSTSavings() != 0) {
useStandard = false;
} else {
TimeZoneTransition after = btz.getNextTransition(time, false);
if (after != null
&& (after.getTime() - time < DST_CHECK_RANGE)
&& after.getTo().getDSTSavings() != 0) {
useStandard = false;
}
}
} else {
// If not BasicTimeZone... only if the instance is not an ICU's implementation.
// We may get a wrong answer in edge case, but it should practically work OK.
int[] offsets = new int[2];
tz.getOffset(time - DST_CHECK_RANGE, false, offsets);
if (offsets[1] != 0) {
useStandard = false;
} else {
tz.getOffset(time + DST_CHECK_RANGE, false, offsets);
if (offsets[1] != 0){
useStandard = false;
}
}
}
}
if (useStandard) {
result = getString(tzid, (isShort ? ZSIDX_SHORT_STANDARD : ZSIDX_LONG_STANDARD),
time, commonlyUsedOnly);
// Note:
// In CLDR 1.5.1, a same localization is used for both generic and standard
// for some metazones in some locales. This is actually data bugs and should
// be resolved in later versions of CLDR. For now, we check if the standard
// name is different from its generic name below.
if (result != null) {
String genericNonLocation = getString(tzid, (isShort ? ZSIDX_SHORT_GENERIC : ZSIDX_LONG_GENERIC),
time, commonlyUsedOnly);
if (genericNonLocation != null && result.equalsIgnoreCase(genericNonLocation)) {
result = null;
}
}
}
if (result == null){
ZoneStrings mzstrings = (ZoneStrings)mzidToStrings.get(mzid);
if (mzstrings != null) {
if (isShort) {
if (!commonlyUsedOnly || mzstrings.isShortFormatCommonlyUsed()) {
result = mzstrings.getString(ZSIDX_SHORT_GENERIC);
}
} else {
result = mzstrings.getString(ZSIDX_LONG_GENERIC);
}
}
if (result != null) {
// Check if the offsets at the given time matches the preferred zone's offsets
String preferredId = ZoneMeta.getZoneIdByMetazone(mzid, getRegion());
if (!tzid.equals(preferredId)) {
// Check if the offsets at the given time are identical with the preferred zone
int raw = cal.get(Calendar.ZONE_OFFSET);
int sav = cal.get(Calendar.DST_OFFSET);
TimeZone preferredZone = TimeZone.getTimeZone(preferredId);
int[] preferredOffsets = new int[2];
// Check offset in preferred time zone with wall time.
// With getOffset(time, false, preferredOffsets),
// you may get incorrect results because of time overlap at DST->STD
// transition.
preferredZone.getOffset(time + raw + sav, true, preferredOffsets);
if (raw != preferredOffsets[0] || sav != preferredOffsets[1]) {
// Use generic partial location string as fallback
result = zstrings.getGenericPartialLocationString(mzid, isShort, commonlyUsedOnly);
}
}
}
}
}
}
if (result == null) {
// Use location format as the final fallback
result = getString(tzid, ZSIDX_LOCATION, cal.getTimeInMillis(), false /* not used */);
}
return result;
}
/*
* Private method to get a generic partial location string
*/
private String getGenericPartialLocationString(String tzid, boolean isShort, long date, boolean commonlyUsedOnly) {
if (!isFullyLoaded) {
// Lazy loading
loadZone(tzid);
}
String result = null;
String mzid = ZoneMeta.getMetazoneID(tzid, date);
if (mzid != null) {
ZoneStrings zstrings = (ZoneStrings)tzidToStrings.get(tzid);
if (zstrings != null) {
result = zstrings.getGenericPartialLocationString(mzid, isShort, commonlyUsedOnly);
}
}
return result;
}
/*
* Gets zoneStrings compatible with DateFormatSymbols for the
* specified date. In CLDR 1.5, zone names can be changed
* time to time. This method generates flat 2-dimensional
* String array including zone ids and its localized strings
* at the moment. Thus, even you construct a new ZoneStringFormat
* by the zone strings array returned by this method, you will
* loose historic name changes. Also, commonly used flag for
* short types is not reflected in the result.
*/
private String[][] getZoneStrings(long date) {
loadFull();
Set tzids = tzidToStrings.keySet();
String[][] zoneStrings = new String[tzids.size()][8];
int idx = 0;
Iterator it = tzids.iterator();
while (it.hasNext()) {
String tzid = (String)it.next();
zoneStrings[idx][0] = tzid;
zoneStrings[idx][1] = getLongStandard(tzid, date);
zoneStrings[idx][2] = getShortStandard(tzid, date, false);
zoneStrings[idx][3] = getLongDaylight(tzid, date);
zoneStrings[idx][4] = getShortDaylight(tzid, date, false);
zoneStrings[idx][5] = getGenericLocation(tzid);
zoneStrings[idx][6] = getLongGenericNonLocation(tzid, date);
zoneStrings[idx][7] = getShortGenericNonLocation(tzid, date, false);
idx++;
}
return zoneStrings;
}
/*
* ZoneStrings is an internal implementation class for
* holding localized name information for a zone/metazone
*/
private static class ZoneStrings {
private String[] strings;
private String[][] genericPartialLocationStrings;
private boolean commonlyUsed;
private ZoneStrings(String[] zstrarray, boolean commonlyUsed, String[][] genericPartialLocationStrings) {
if (zstrarray != null) {
int lastIdx = -1;
for (int i = 0; i < zstrarray.length; i++) {
if (zstrarray[i] != null) {
lastIdx = i;
}
}
if (lastIdx != -1) {
strings = new String[lastIdx + 1];
System.arraycopy(zstrarray, 0, strings, 0, lastIdx + 1);
}
}
this.commonlyUsed = commonlyUsed;
this.genericPartialLocationStrings = genericPartialLocationStrings;
}
private String getString(int typeIdx) {
if (strings != null && typeIdx >= 0 && typeIdx < strings.length) {
return strings[typeIdx];
}
return null;
}
private boolean isShortFormatCommonlyUsed() {
return commonlyUsed;
}
private String getGenericPartialLocationString(String mzid, boolean isShort, boolean commonlyUsedOnly) {
String result = null;
if (genericPartialLocationStrings != null) {
for (int i = 0; i < genericPartialLocationStrings.length; i++) {
if (genericPartialLocationStrings[i][0].equals(mzid)) {
if (isShort) {
if (!commonlyUsedOnly || genericPartialLocationStrings[i][3] != null) {
result = genericPartialLocationStrings[i][2];
}
} else {
result = genericPartialLocationStrings[i][1];
}
break;
}
}
}
return result;
}
}
/*
* Returns a localized zone string from bundle.
*/
private static String getZoneStringFromBundle(ICUResourceBundle bundle, String key, String type) {
String zstring = null;
if (bundle != null) {
try {
zstring = bundle.getStringWithFallback(key + "/" + type);
} catch (MissingResourceException ex) {
// throw away the exception
}
}
return zstring;
}
/*
* Returns if the short strings of the zone/metazone is commonly used.
*/
private static boolean isCommonlyUsed(ICUResourceBundle bundle, String key) {
boolean commonlyUsed = false;
if (bundle != null) {
try {
UResourceBundle cuRes = bundle.getWithFallback(key + "/" + RESKEY_COMMONLY_USED);
int cuValue = cuRes.getInt();
commonlyUsed = (cuValue != 0);
} catch (MissingResourceException ex) {
// throw away the exception
}
}
return commonlyUsed;
}
/*
* Returns a localized country string for the country code. If no actual
* localized string is found, countryCode itself is returned.
*/
private static String getLocalizedCountry(String countryCode, ULocale locale) {
String countryStr = null;
if (countryCode != null) {
ICUResourceBundle rb =
(ICUResourceBundle)UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, locale);
//
// TODO: There is a design bug in UResourceBundle and getLoadingStatus() does not work well.
//
// if (rb.getLoadingStatus() != ICUResourceBundle.FROM_ROOT && rb.getLoadingStatus() != ICUResourceBundle.FROM_DEFAULT) {
// country = ULocale.getDisplayCountry("xx_" + country_code, locale);
// }
// START WORKAROUND
ULocale rbloc = rb.getULocale();
if (!rbloc.equals(ULocale.ROOT) && rbloc.getLanguage().equals(locale.getLanguage())) {
countryStr = ULocale.getDisplayCountry("xx_" + countryCode, locale);
}
// END WORKAROUND
if (countryStr == null || countryStr.length() == 0) {
countryStr = countryCode;
}
}
return countryStr;
}
/*
* Gets an instance of MessageFormat used for formatting zone fallback string
*/
private static MessageFormat getFallbackFormat(ULocale locale) {
String fallbackPattern = ZoneMeta.getTZLocalizationInfo(locale, ZoneMeta.FALLBACK_FORMAT);
if (fallbackPattern == null) {
fallbackPattern = "{1} ({0})";
}
return new MessageFormat(fallbackPattern, locale);
}
/*
* Gets an instance of MessageFormat used for formatting zone region string
*/
private static MessageFormat getRegionFormat(ULocale locale) {
String regionPattern = ZoneMeta.getTZLocalizationInfo(locale, ZoneMeta.REGION_FORMAT);
if (regionPattern == null) {
regionPattern = "{0}";
}
return new MessageFormat(regionPattern, locale);
}
/*
* Index value mapping between DateFormatSymbols's zoneStrings and
* the string types defined in this class.
*/
private static final int[] INDEXMAP = {
-1, // 0 - zone id
ZSIDX_LONG_STANDARD, // 1 - long standard
ZSIDX_SHORT_STANDARD, // 2 - short standard
ZSIDX_LONG_DAYLIGHT, // 3 - long daylight
ZSIDX_SHORT_DAYLIGHT, // 4 - short daylight
ZSIDX_LOCATION, // 5 - generic location
ZSIDX_LONG_GENERIC, // 6 - long generic non-location
ZSIDX_SHORT_GENERIC // 7 - short generic non-location
};
/*
* Convert from zone string array index for zoneStrings used by DateFormatSymbols#get/setZoneStrings
* to the type constants defined by this class, such as ZSIDX_LONG_STANDARD.
*/
private static int getNameTypeIndex(int i) {
int idx = -1;
if (i >= 1 && i < INDEXMAP.length) {
idx = INDEXMAP[i];
}
return idx;
}
/*
* Mapping from name type index to name type
*/
private static final int[] NAMETYPEMAP = {
LOCATION, // ZSIDX_LOCATION
STANDARD_LONG, // ZSIDX_LONG_STANDARD
STANDARD_SHORT, // ZSIDX_SHORT_STANDARD
DAYLIGHT_LONG, // ZSIDX_LONG_DAYLIGHT
DAYLIGHT_SHORT, // ZSIDX_SHORT_DAYLIGHT
GENERIC_LONG, // ZSIDX_LONG_GENERIC
GENERIC_SHORT, // ZSIDX_SHORT_GENERIC
};
private static int getNameType(int typeIdx) {
int type = -1;
if (typeIdx >= 0 && typeIdx < NAMETYPEMAP.length) {
type = NAMETYPEMAP[typeIdx];
}
return type;
}
/*
* Returns region used for ZoneMeta#getZoneIdByMetazone.
*/
private String getRegion() {
if (region == null) {
if (locale != null) {
region = locale.getCountry();
if (region.length() == 0) {
ULocale tmp = ULocale.addLikelySubtags(locale);
region = tmp.getCountry();
}
} else {
region = "";
}
}
return region;
}
// This method does lazy zone string loading
private ZoneStringInfo find(String text, int start, int types) {
ZoneStringInfo result = subFind(text, start, types);
if (isFullyLoaded) {
return result;
}
// When zone string data is partially loaded,
// this method return the result only when
// the input text is fully consumed.
if (result != null) {
int matchLen = result.getString().length();
if (text.length() - start == matchLen) {
return result;
}
}
// Now load all zone strings
loadFull();
return subFind(text, start, types);
}
/*
* Find a prefix matching time zone for the given zone string types.
* @param text The text contains a time zone string
* @param start The start index within the text
* @param types The bit mask representing a set of requested types
* @return If any zone string matched for the requested types, returns a
* ZoneStringInfo for the longest match. If no matches are found for
* the requested types, returns a ZoneStringInfo for the longest match
* for any other types. If nothing matches at all, returns null.
*/
private ZoneStringInfo subFind(String text, int start, int types) {
ZoneStringInfo result = null;
ZoneStringSearchResultHandler handler = new ZoneStringSearchResultHandler();
zoneStringsTrie.find(text, start, handler);
List list = handler.getMatchedZoneStrings();
ZoneStringInfo fallback = null;
if (list != null && list.size() > 0) {
Iterator it = list.iterator();
while (it.hasNext()) {
ZoneStringInfo tmp = (ZoneStringInfo)it.next();
if ((types & tmp.getType()) != 0) {
if (result == null || result.getString().length() < tmp.getString().length()) {
result = tmp;
} else if (result.getString().length() == tmp.getString().length()) {
// Tie breaker - there are some examples that a
// long standard name is identical with a location
// name - for example, "Uruguay Time". In this case,
// we interpret it as generic, not specific.
if (tmp.isGeneric() && !result.isGeneric()) {
result = tmp;
}
}
} else if (result == null) {
if (fallback == null || fallback.getString().length() < tmp.getString().length()) {
fallback = tmp;
} else if (fallback.getString().length() == tmp.getString().length()) {
if (tmp.isGeneric() && !fallback.isGeneric()) {
fallback = tmp;
}
}
}
}
}
if (result == null && fallback != null) {
result = fallback;
}
return result;
}
private static class ZoneStringSearchResultHandler implements TextTrieMap.ResultHandler {
private ArrayList resultList;
public boolean handlePrefixMatch(int matchLength, Iterator values) {
if (resultList == null) {
resultList = new ArrayList();
}
while (values.hasNext()) {
ZoneStringInfo zsitem = (ZoneStringInfo)values.next();
if (zsitem == null) {
break;
}
int i = 0;
for (; i < resultList.size(); i++) {
ZoneStringInfo tmp = (ZoneStringInfo)resultList.get(i);
if (zsitem.getType() == tmp.getType()) {
if (matchLength > tmp.getString().length()) {
resultList.set(i, zsitem);
}
break;
}
}
if (i == resultList.size()) {
// not found in the current list
resultList.add(zsitem);
}
}
return true;
}
List getMatchedZoneStrings() {
if (resultList == null || resultList.size() == 0) {
return null;
}
return resultList;
}
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/ReplaceableUCharacterIterator.java 0000644 0001750 0001750 00000015054 10251426451 025211 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
import com.ibm.icu.text.*;
import com.ibm.icu.text.Replaceable;
import com.ibm.icu.text.ReplaceableString;
import com.ibm.icu.text.UTF16;
/**
* DLF docs must define behavior when Replaceable is mutated underneath
* the iterator.
*
* This and ICUCharacterIterator share some code, maybe they should share
* an implementation, or the common state and implementation should be
* moved up into UCharacterIterator.
*
* What are first, last, and getBeginIndex doing here?!?!?!
*/
public class ReplaceableUCharacterIterator extends UCharacterIterator {
// public constructor ------------------------------------------------------
/**
* Public constructor
* @param replaceable text which the iterator will be based on
*/
public ReplaceableUCharacterIterator(Replaceable replaceable){
if(replaceable==null){
throw new IllegalArgumentException();
}
this.replaceable = replaceable;
this.currentIndex = 0;
}
/**
* Public constructor
* @param str text which the iterator will be based on
*/
public ReplaceableUCharacterIterator(String str){
if(str==null){
throw new IllegalArgumentException();
}
this.replaceable = new ReplaceableString(str);
this.currentIndex = 0;
}
/**
* Public constructor
* @param buf buffer of text on which the iterator will be based
*/
public ReplaceableUCharacterIterator(StringBuffer buf){
if(buf==null){
throw new IllegalArgumentException();
}
this.replaceable = new ReplaceableString(buf);
this.currentIndex = 0;
}
// public methods ----------------------------------------------------------
/**
* Creates a copy of this iterator, does not clone the underlying
* Replaceableobject
* @return copy of this iterator
*/
public Object clone(){
try {
return super.clone();
} catch (CloneNotSupportedException e) {
return null; // never invoked
}
}
/**
* Returns the current UTF16 character.
* @return current UTF16 character
*/
public int current(){
if (currentIndex < replaceable.length()) {
return replaceable.charAt(currentIndex);
}
return DONE;
}
/**
* Returns the current codepoint
* @return current codepoint
*/
public int currentCodePoint(){
// cannot use charAt due to it different
// behaviour when index is pointing at a
// trail surrogate, check for surrogates
int ch = current();
if(UTF16.isLeadSurrogate((char)ch)){
// advance the index to get the next code point
next();
// due to post increment semantics current() after next()
// actually returns the next char which is what we want
int ch2 = current();
// current should never change the current index so back off
previous();
if(UTF16.isTrailSurrogate((char)ch2)){
// we found a surrogate pair
return UCharacterProperty.getRawSupplementary(
(char)ch,(char)ch2
);
}
}
return ch;
}
/**
* Returns the length of the text
* @return length of the text
*/
public int getLength(){
return replaceable.length();
}
/**
* Gets the current currentIndex in text.
* @return current currentIndex in text.
*/
public int getIndex(){
return currentIndex;
}
/**
* Returns next UTF16 character and increments the iterator's currentIndex by 1.
* If the resulting currentIndex is greater or equal to the text length, the
* currentIndex is reset to the text length and a value of DONECODEPOINT is
* returned.
* @return next UTF16 character in text or DONE if the new currentIndex is off the
* end of the text range.
*/
public int next(){
if (currentIndex < replaceable.length()) {
return replaceable.charAt(currentIndex++);
}
return DONE;
}
/**
* Returns previous UTF16 character and decrements the iterator's currentIndex by
* 1.
* If the resulting currentIndex is less than 0, the currentIndex is reset to 0 and a
* value of DONECODEPOINT is returned.
* @return next UTF16 character in text or DONE if the new currentIndex is off the
* start of the text range.
*/
public int previous(){
if (currentIndex > 0) {
return replaceable.charAt(--currentIndex);
}
return DONE;
}
/**
*
Sets the currentIndex to the specified currentIndex in the text and returns that * single UTF16 character at currentIndex. * This assumes the text is stored as 16-bit code units.
* @param currentIndex the currentIndex within the text. * @exception IllegalArgumentException is thrown if an invalid currentIndex is * supplied. i.e. currentIndex is out of bounds. * @returns the character at the specified currentIndex or DONE if the specified * currentIndex is equal to the end of the text. */ public void setIndex(int currentIndex) throws IndexOutOfBoundsException{ if (currentIndex < 0 || currentIndex > replaceable.length()) { throw new IndexOutOfBoundsException(); } this.currentIndex = currentIndex; } public int getText(char[] fillIn, int offset){ int length = replaceable.length(); if(offset < 0 || offset + length > fillIn.length){ throw new IndexOutOfBoundsException(Integer.toString(length)); } replaceable.getChars(0,length,fillIn,offset); return length; } // private data members ---------------------------------------------------- /** * Replacable object */ private Replaceable replaceable; /** * Current currentIndex */ private int currentIndex; } icu4j-4.2.1.1/src/com/ibm/icu/impl/UPropertyAliases.java 0000644 0001750 0001750 00000054107 11171700733 022613 0 ustar twerner twerner /* ********************************************************************** * Copyright (c) 2002-2009, International Business Machines * Corporation and others. All Rights Reserved. ********************************************************************** * Author: Alan Liu * Created: November 5 2002 * Since: ICU 2.4 ********************************************************************** */ package com.ibm.icu.impl; import java.io.*; import com.ibm.icu.lang.*; /** * Wrapper for the pnames.icu binary data file. This data file is * imported from icu4c. It contains property and property value * aliases from the UCD files PropertyAliases.txt and * PropertyValueAliases.txt. The file is built by the icu4c tool * genpname. It must be built on an ASCII big-endian platform to be * usable in icu4j. * * This class performs two functions. * * (1) It can import the flat binary data into a tree of usable * objects. * * (2) It provides an API to access the tree of objects. * * Needless to say, this class is tightly coupled to the binary format * of icu4c's pnames.icu file. * * Each time a UPropertyAliases is constructed, the pnames.icu file is * read, parsed, and a data tree assembled. Clients should create one * singleton instance and cache it. * * @author Alan Liu * @since ICU 2.4 */ public final class UPropertyAliases implements ICUBinary.Authenticate { //---------------------------------------------------------------- // Runtime data. This is an unflattened representation of the // data in pnames.icu. /** * Map from property enum value to nameGroupPool[] index */ private NonContiguousEnumToShort enumToName; /** * Map from property alias to property enum value */ private NameToEnum nameToEnum; /** * Map from property enum value to valueMapArray[] index */ private NonContiguousEnumToShort enumToValue; /** * Each entry represents a binary or enumerated property */ private ValueMap valueMapArray[]; /** * Pool of concatenated integer runs. Each run contains one * or more entries. The last entry of the run is negative. * A zero entry indicates "n/a" in the Property*Aliases.txt. * Each entry is a stringPool[] index. */ private short nameGroupPool[]; /** * Pool of strings. */ private String stringPool[]; //---------------------------------------------------------------- // Constants /** * Debug flag (not really constant) */ private static boolean DEBUG = ICUDebug.enabled("pnames"); /** * File format that this class understands. * See icu4c/src/common/propname.h. */ private static final byte DATA_FORMAT_ID[] = {'p', 'n', 'a', 'm'}; /** * File version that this class understands. * See icu4c/src/common/propname.h. */ private static final byte DATA_FORMAT_VERSION = 1; /** * Name of the datafile */ private static final String DATA_FILE_NAME = ICUResourceBundle.ICU_BUNDLE+"/pnames.icu"; /** * Buffer size of datafile. The whole file is < 16k. */ private static final int DATA_BUFFER_SIZE = 8192; //---------------------------------------------------------------- // Constructor /** * Constructs a UPropertyAliases object. The binary file * DATA_FILE_NAME is read from the jar/classpath and unflattened * into member variables of this object. */ public UPropertyAliases() throws IOException { // Open the .icu file from the jar/classpath InputStream is = ICUData.getRequiredStream(DATA_FILE_NAME); BufferedInputStream b = new BufferedInputStream(is, DATA_BUFFER_SIZE); // Read and discard Unicode version... /* byte unicodeVersion[] = */ICUBinary.readHeader(b, DATA_FORMAT_ID, this); DataInputStream d = new DataInputStream(b); // Record the origin position of the file. Keep enough around // to seek back to the start of the header. d.mark(256); short enumToName_offset = d.readShort(); short nameToEnum_offset = d.readShort(); short enumToValue_offset = d.readShort(); short total_size = d.readShort(); short valueMap_offset = d.readShort(); short valueMap_count = d.readShort(); short nameGroupPool_offset = d.readShort(); short nameGroupPool_count = d.readShort(); short stringPool_offset = d.readShort(); short stringPool_count = d.readShort(); if (DEBUG) { System.out.println( "enumToName_offset=" + enumToName_offset + "\n" + "nameToEnum_offset=" + nameToEnum_offset + "\n" + "enumToValue_offset=" + enumToValue_offset + "\n" + "total_size=" + total_size + "\n" + "valueMap_offset=" + valueMap_offset + "\n" + "valueMap_count=" + valueMap_count + "\n" + "nameGroupPool_offset=" + nameGroupPool_offset + "\n" + "nameGroupPool_count=" + nameGroupPool_count + "\n" + "stringPool_offset=" + stringPool_offset + "\n" + "stringPool_count=" + stringPool_count); } // Read it all (less than 32k). Seeking around (using // mark/reset/skipBytes) doesn't work directly on the file, // but it works fine if we read everything into a byte[] array // first. byte raw[] = new byte[total_size]; d.reset(); d.readFully(raw); d.close(); Builder builder = new Builder(raw); stringPool = builder.readStringPool(stringPool_offset, stringPool_count); nameGroupPool = builder.readNameGroupPool(nameGroupPool_offset, nameGroupPool_count); builder.setupValueMap_map(valueMap_offset, valueMap_count); // Some of the following data structures have to be set up // here, _not_ in Builder. That's because they are instances // of non-static inner classes, and they contain implicit // references to this. builder.seek(enumToName_offset); enumToName = new NonContiguousEnumToShort(builder); builder.nameGroupOffsetToIndex(enumToName.offsetArray); builder.seek(nameToEnum_offset); nameToEnum = new NameToEnum(builder); builder.seek(enumToValue_offset); enumToValue = new NonContiguousEnumToShort(builder); builder.valueMapOffsetToIndex(enumToValue.offsetArray); valueMapArray = new ValueMap[valueMap_count]; for (int i=0; iInternal reader class for ICU data file uprops.icu containing * Unicode codepoint data.
*This class simply reads uprops.icu, authenticates that it is a valid * ICU data file and split its contents up into blocks of data for use in * com.ibm.icu.impl.UCharacterProperty. *
*uprops.icu which is in big-endian format is jared together with this * package.
* * Unicode character properties file format see * (ICU4C)/source/tools/genprops/store.c * * @author Syn Wee Quek * @since release 2.1, February 1st 2002 */ final class UCharacterPropertyReader implements ICUBinary.Authenticate { // public methods ---------------------------------------------------- public boolean isDataVersionAcceptable(byte version[]) { return version[0] == DATA_FORMAT_VERSION_[0] && version[2] == DATA_FORMAT_VERSION_[2] && version[3] == DATA_FORMAT_VERSION_[3]; } // protected constructor --------------------------------------------- /** *Protected constructor.
* @param inputStream ICU uprop.dat file input stream * @exception IOException throw if data file fails authentication */ protected UCharacterPropertyReader(InputStream inputStream) throws IOException { m_unicodeVersion_ = ICUBinary.readHeader(inputStream, DATA_FORMAT_ID_, this); m_dataInputStream_ = new DataInputStream(inputStream); } // protected methods ------------------------------------------------- /** *Reads uprops.icu, parse it into blocks of data to be stored in * UCharacterProperty.
0) { // reads the additional property block ucharppty.m_additionalTrie_ = new CharTrie(m_dataInputStream_, null); // additional properties size = m_reservedOffset_ - m_additionalVectorsOffset_; ucharppty.m_additionalVectors_ = new int[size]; for (int i = 0; i < size; i ++) { ucharppty.m_additionalVectors_[i] = m_dataInputStream_.readInt(); } } m_dataInputStream_.close(); ucharppty.m_additionalColumnsCount_ = m_additionalColumnsCount_; ucharppty.m_unicodeVersion_ = VersionInfo.getInstance( (int)m_unicodeVersion_[0], (int)m_unicodeVersion_[1], (int)m_unicodeVersion_[2], (int)m_unicodeVersion_[3]); } // private variables ------------------------------------------------- /** * Index size */ private static final int INDEX_SIZE_ = 16; /** * ICU data file input stream */ private DataInputStream m_dataInputStream_; /** * Offset information in the indexes. */ private int m_propertyOffset_; private int m_exceptionOffset_; private int m_caseOffset_; private int m_additionalOffset_; private int m_additionalVectorsOffset_; private int m_additionalColumnsCount_; private int m_reservedOffset_; private byte m_unicodeVersion_[]; /** * Data format "UPro". */ private static final byte DATA_FORMAT_ID_[] = {(byte)0x55, (byte)0x50, (byte)0x72, (byte)0x6F}; /** * Format version; this code works with all versions with the same major * version number and the same Trie bit distribution. */ private static final byte DATA_FORMAT_VERSION_[] = {(byte)0x5, (byte)0, (byte)Trie.INDEX_STAGE_1_SHIFT_, (byte)Trie.INDEX_STAGE_2_SHIFT_}; } icu4j-4.2.1.1/src/com/ibm/icu/impl/CollectionUtilities.java 0000644 0001750 0001750 00000002473 11043306014 023316 0 ustar twerner twerner /* ******************************************************************************* * Copyright (C) 2008, Google Inc, International Business Machines Corporation and * * others. All Rights Reserved. * ******************************************************************************* */ package com.ibm.icu.impl; import java.util.Comparator; /** * @author markdavis * */ public class CollectionUtilities { public static class MultiComparator implements Comparator { private Comparator[] comparators; public MultiComparator (Comparator[] comparators) { this.comparators = comparators; } /* Lexigraphic compare. Returns the first difference * @return zero if equal. Otherwise +/- (i+1) * where i is the index of the first comparator finding a difference * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(Object arg0, Object arg1) { for (int i = 0; i < comparators.length; ++i) { int result = comparators[i].compare(arg0, arg1); if (result == 0) continue; if (result > 0) return i+1; return -(i+1); } return 0; } } } icu4j-4.2.1.1/src/com/ibm/icu/impl/ICUBinary.java 0000644 0001750 0001750 00000013745 11015072544 021127 0 ustar twerner twerner /* ******************************************************************************* * Copyright (C) 1996-2008, International Business Machines Corporation and * * others. All Rights Reserved. * ******************************************************************************* */ package com.ibm.icu.impl; import java.io.InputStream; import java.io.DataInputStream; import java.io.IOException; import java.util.Arrays; public final class ICUBinary { // public inner interface ------------------------------------------------ /** * Special interface for data authentication */ public static interface Authenticate { /** * Method used in ICUBinary.readHeader() to provide data format * authentication. * @param version version of the current data * @return true if dataformat is an acceptable version, false otherwise */ public boolean isDataVersionAcceptable(byte version[]); } // public methods -------------------------------------------------------- /** *ICU data header reader method. * Takes a ICU generated big-endian input stream, parse the ICU standard * file header and authenticates them.
*Header format: *
* Example of use:
*
* try {
* FileInputStream input = new FileInputStream(filename);
* If (Utility.readICUDataHeader(input, dataformat, dataversion,
* unicode) {
* System.out.println("Verified file header, this is a ICU data file");
* }
* } catch (IOException e) {
* System.out.println("This is not a ICU data file");
* }
*
*
* @param inputStream input stream that contains the ICU data header
* @param dataFormatIDExpected Data format expected. An array of 4 bytes
* information about the data format.
* E.g. data format ID 1.2.3.4. will became an array of
* {1, 2, 3, 4}
* @param authenticate user defined extra data authentication. This value
* can be null, if no extra authentication is needed.
* @exception IOException thrown if there is a read error or
* when header authentication fails.
*/
public static final byte[] readHeader(InputStream inputStream,
byte dataFormatIDExpected[],
Authenticate authenticate)
throws IOException
{
DataInputStream input = new DataInputStream(inputStream);
char headersize = input.readChar();
int readcount = 2;
//reading the header format
byte magic1 = input.readByte();
readcount ++;
byte magic2 = input.readByte();
readcount ++;
if (magic1 != MAGIC1 || magic2 != MAGIC2) {
throw new IOException(MAGIC_NUMBER_AUTHENTICATION_FAILED_);
}
input.readChar(); // reading size
readcount += 2;
input.readChar(); // reading reserved word
readcount += 2;
byte bigendian = input.readByte();
readcount ++;
byte charset = input.readByte();
readcount ++;
byte charsize = input.readByte();
readcount ++;
input.readByte(); // reading reserved byte
readcount ++;
byte dataFormatID[] = new byte[4];
input.readFully(dataFormatID);
readcount += 4;
byte dataVersion[] = new byte[4];
input.readFully(dataVersion);
readcount += 4;
byte unicodeVersion[] = new byte[4];
input.readFully(unicodeVersion);
readcount += 4;
if (headersize < readcount) {
throw new IOException("Internal Error: Header size error");
}
input.skipBytes(headersize - readcount);
if (bigendian != BIG_ENDIAN_ || charset != CHAR_SET_
|| charsize != CHAR_SIZE_
|| !Arrays.equals(dataFormatIDExpected, dataFormatID)
|| (authenticate != null
&& !authenticate.isDataVersionAcceptable(dataVersion))) {
throw new IOException(HEADER_AUTHENTICATION_FAILED_);
}
return unicodeVersion;
}
// private variables -------------------------------------------------
/**
* Magic numbers to authenticate the data file
*/
private static final byte MAGIC1 = (byte)0xda;
private static final byte MAGIC2 = (byte)0x27;
/**
* File format authentication values
*/
private static final byte BIG_ENDIAN_ = 1;
private static final byte CHAR_SET_ = 0;
private static final byte CHAR_SIZE_ = 2;
/**
* Error messages
*/
private static final String MAGIC_NUMBER_AUTHENTICATION_FAILED_ =
"ICU data file error: Not an ICU data file";
private static final String HEADER_AUTHENTICATION_FAILED_ =
"ICU data file error: Header authentication failed, please check if you have a valid ICU data file";
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/ICUCache.java 0000644 0001750 0001750 00000001311 10764066720 020701 0 ustar twerner twerner /*
***************************************************************************
* Copyright (c) 2007-2008 International Business Machines Corporation and *
* others. All rights reserved. *
***************************************************************************
*/
package com.ibm.icu.impl;
public interface ICUCache {
// Type of reference holding the Map instance
public static final int SOFT = 0;
public static final int WEAK = 1;
// NULL object, which may be used for a cache key
public static final Object NULL = new Object();
public void clear();
public void put(Object key, Object value);
public Object get(Object key);
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/ 0000755 0001750 0001750 00000000000 11627232336 017404 5 ustar twerner twerner icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_en_CA.java 0000644 0001750 0001750 00000003153 10666355147 024031 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import com.ibm.icu.util.*;
import java.util.Calendar;
import java.util.ListResourceBundle;
public class HolidayBundle_en_CA extends ListResourceBundle {
static private final Holiday[] fHolidays = {
SimpleHoliday.NEW_YEARS_DAY,
new SimpleHoliday(Calendar.MAY, 19, 0, "Victoria Day"),
new SimpleHoliday(Calendar.JULY, 1, 0, "Canada Day"),
new SimpleHoliday(Calendar.AUGUST, 1, Calendar.MONDAY, "Civic Holiday"),
new SimpleHoliday(Calendar.SEPTEMBER, 1, Calendar.MONDAY, "Labor Day"),
new SimpleHoliday(Calendar.OCTOBER, 8, Calendar.MONDAY, "Thanksgiving"),
new SimpleHoliday(Calendar.NOVEMBER, 11, 0, "Remembrance Day"),
SimpleHoliday.CHRISTMAS,
SimpleHoliday.BOXING_DAY,
SimpleHoliday.NEW_YEARS_EVE,
// Easter and related holidays
//hey {jf} - where are these from?
// EasterHoliday.GOOD_FRIDAY,
// EasterHoliday.EASTER_SUNDAY,
// EasterHoliday.EASTER_MONDAY,
};
static private final Object[][] fContents = {
{ "holidays", fHolidays },
{ "Labor Day", "Labour Day" },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_it.java 0000644 0001750 0001750 00000003020 10666355147 023471 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import java.util.ListResourceBundle;
public class HolidayBundle_it extends ListResourceBundle {
static private final Object[][] fContents =
{
{ "All Saints' Day", "Ognissanti" },
{ "Armistice Day", "armistizio" },
{ "Ascension", "ascensione" },
{ "Ash Wednesday", "mercoled\u00ec delle ceneri" },
{ "Boxing Day", "Santo Stefano" },
{ "Christmas", "natale" },
{ "Easter Sunday", "pasqua" },
{ "Epiphany", "Epifania" },
{ "Good Friday", "venerd\u00ec santo" },
{ "Halloween", "vigilia di Ognissanti" },
{ "Maundy Thursday", "gioved\u00ec santo" },
{ "New Year's Day", "anno nuovo" },
{ "Palm Sunday", "domenica delle palme" },
{ "Pentecost", "di Pentecoste" },
{ "Shrove Tuesday", "martedi grasso" },
{ "St. Stephen's Day", "Santo Stefano" },
{ "Thanksgiving", "Giorno del Ringraziamento" },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/TokenIterator.java 0000644 0001750 0001750 00000012154 10775324256 023052 0 ustar twerner twerner /*
**********************************************************************
* Copyright (c) 2004-2008, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Author: Alan Liu
* Created: March 16 2004
* Since: ICU 3.0
**********************************************************************
*/
package com.ibm.icu.impl.data;
import java.io.IOException;
import com.ibm.icu.impl.UCharacterProperty;
import com.ibm.icu.impl.Utility;
import com.ibm.icu.text.UTF16;
/**
* An iterator class that returns successive string tokens from some
* source. String tokens are, in general, separated by rule white
* space in the source test. Furthermore, they may be delimited by
* either single or double quotes (opening and closing quotes must
* match). Escapes are processed using standard ICU unescaping.
*/
public class TokenIterator {
private ResourceReader reader;
private String line;
private StringBuffer buf;
private boolean done;
private int pos;
private int lastpos;
/**
* Construct an iterator over the tokens returned by the given
* ResourceReader, ignoring blank lines and comment lines (first
* non-blank character is '#'). Note that trailing comments on a
* line, beginning with the first unquoted '#', are recognized.
*/
public TokenIterator(ResourceReader r) {
reader = r;
line = null;
done = false;
buf = new StringBuffer();
pos = lastpos = -1;
}
/**
* Return the next token from this iterator, or null if the last
* token has been returned.
*/
public String next() throws IOException {
if (done) {
return null;
}
for (;;) {
if (line == null) {
line = reader.readLineSkippingComments();
if (line == null) {
done = true;
return null;
}
pos = 0;
}
buf.setLength(0);
lastpos = pos;
pos = nextToken(pos);
if (pos < 0) {
line = null;
continue;
}
return buf.toString();
}
}
/**
* Return the one-based line number of the line of the last token returned by
* next(). Should only be called
* after a call to next(); otherwise the return
* value is undefined.
*/
public int getLineNumber() {
return reader.getLineNumber();
}
/**
* Return a string description of the position of the last line
* returned by readLine() or readLineSkippingComments().
*/
public String describePosition() {
return reader.describePosition() + ':' + (lastpos+1);
}
/**
* Read the next token from 'this.line' and append it to
* 'this.buf'. Tokens are separated by rule white space. Tokens
* may also be delimited by double or single quotes. The closing
* quote must match the opening quote. If a '#' is encountered,
* the rest of the line is ignored, unless it is backslash-escaped
* or within quotes.
* @param position the offset into the string
* @return offset to the next character to read from line, or if
* the end of the line is reached without scanning a valid token,
* -1
*/
private int nextToken(int position) {
position = Utility.skipWhitespace(line, position);
if (position == line.length()) {
return -1;
}
int startpos = position;
char c = line.charAt(position++);
char quote = 0;
switch (c) {
case '"':
case '\'':
quote = c;
break;
case '#':
return -1;
default:
buf.append(c);
break;
}
int[] posref = null;
while (position < line.length()) {
c = line.charAt(position); // 16-bit ok
if (c == '\\') {
if (posref == null) {
posref = new int[1];
}
posref[0] = position+1;
int c32 = Utility.unescapeAt(line, posref);
if (c32 < 0) {
throw new RuntimeException("Invalid escape at " +
reader.describePosition() + ':' +
position);
}
UTF16.append(buf, c32);
position = posref[0];
} else if ((quote != 0 && c == quote) ||
(quote == 0 && UCharacterProperty.isRuleWhiteSpace(c))) {
return ++position;
} else if (quote == 0 && c == '#') {
return position; // do NOT increment
} else {
buf.append(c);
++position;
}
}
if (quote != 0) {
throw new RuntimeException("Unterminated quote at " +
reader.describePosition() + ':' +
startpos);
}
return position;
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_iw.java 0000644 0001750 0001750 00000001201 10666355147 023473 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import java.util.ListResourceBundle;
public class HolidayBundle_iw extends ListResourceBundle {
static private final Object[][] fContents = {
{ "", "" }, // Can't be empty!
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/ResourceReader.java 0000644 0001750 0001750 00000020417 10732050763 023163 0 ustar twerner twerner /**
*******************************************************************************
* Copyright (C) 2001-2007, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import java.io.*;
import com.ibm.icu.impl.ICUData;
import com.ibm.icu.impl.Utility;
/**
* A reader for text resource data in the current package or the package
* of a given class object. The
* resource data is loaded through the class loader, so it will
* typically be a file in the same directory as the *.class files, or
* a file within a JAR file in the corresponding subdirectory. The
* file must be a text file in one of the supported encodings; when the
* resource is opened by constructing a ResourceReader
* object the encoding is specified.
*
* @author Alan Liu
*/
public class ResourceReader {
private BufferedReader reader;
private String resourceName;
private String encoding; // null for default encoding
private Class root;
/**
* The one-based line number. Has the special value -1 before the
* object is initialized. Has the special value 0 after initialization
* but before the first line is read.
*/
private int lineNo;
/**
* Construct a reader object for the text file of the given name
* in this package, using the given encoding.
* @param resourceName the name of the text file located in this
* package's ".data" subpackage.
* @param encoding the encoding of the text file; if unsupported
* an exception is thrown
* @exception UnsupportedEncodingException if
* encoding is not supported by the JDK.
*/
public ResourceReader(String resourceName, String encoding)
throws UnsupportedEncodingException {
this(ICUData.class, "data/" + resourceName, encoding);
}
/**
* Construct a reader object for the text file of the given name
* in this package, using the default encoding.
* @param resourceName the name of the text file located in this
* package's ".data" subpackage.
*/
public ResourceReader(String resourceName) {
this(ICUData.class, "data/" + resourceName);
}
/**
* Construct a reader object for the text file of the given name
* in the given class's package, using the given encoding.
* @param resourceName the name of the text file located in the
* given class's package.
* @param encoding the encoding of the text file; if unsupported
* an exception is thrown
* @exception UnsupportedEncodingException if
* encoding is not supported by the JDK.
*/
public ResourceReader(Class rootClass, String resourceName, String encoding)
throws UnsupportedEncodingException {
this.root = rootClass;
this.resourceName = resourceName;
this.encoding = encoding;
lineNo = -1;
_reset();
}
/**
* Construct a reader object for the input stream associated with
* the given resource name.
* @param is the input stream of the resource
* @param resourceName the name of the resource
*/
public ResourceReader(InputStream is, String resourceName, String encoding) {
this.root = null;
this.resourceName = resourceName;
this.encoding = encoding;
this.lineNo = -1;
try {
InputStreamReader isr = (encoding == null)
? new InputStreamReader(is)
: new InputStreamReader(is, encoding);
this.reader = new BufferedReader(isr);
this.lineNo= 0;
}
catch (UnsupportedEncodingException e) {
}
}
/**
* Construct a reader object for the input stream associated with
* the given resource name.
* @param is the input stream of the resource
* @param resourceName the name of the resource
*/
public ResourceReader(InputStream is, String resourceName) {
this(is, resourceName, null);
}
/**
* Construct a reader object for the text file of the given name
* in the given class's package, using the default encoding.
* @param resourceName the name of the text file located in the
* given class's package.
*/
public ResourceReader(Class rootClass, String resourceName) {
this.root = rootClass;
this.resourceName = resourceName;
this.encoding = null;
lineNo = -1;
try {
_reset();
} catch (UnsupportedEncodingException e) {}
}
/**
* Read and return the next line of the file or null
* if the end of the file has been reached.
*/
public String readLine() throws IOException {
if (lineNo == 0) {
// Remove BOMs
++lineNo;
String line = reader.readLine();
if (line.charAt(0) == '\uFFEF' ||
line.charAt(0) == '\uFEFF') {
line = line.substring(1);
}
return line;
}
++lineNo;
return reader.readLine();
}
/**
* Read a line, ignoring blank lines and lines that start with
* '#'.
* @param trim if true then trim leading rule white space.
*/
public String readLineSkippingComments(boolean trim) throws IOException {
for (;;) {
String line = readLine();
if (line == null) {
return line;
}
// Skip over white space
int pos = Utility.skipWhitespace(line, 0);
// Ignore blank lines and comment lines
if (pos == line.length() || line.charAt(pos) == '#') {
continue;
}
// Process line
if (trim) line = line.substring(pos);
return line;
}
}
/**
* Read a line, ignoring blank lines and lines that start with
* '#'. Do not trim leading rule white space.
*/
public String readLineSkippingComments() throws IOException {
return readLineSkippingComments(false);
}
/**
* Return the one-based line number of the last line returned by
* readLine() or readLineSkippingComments(). Should only be called
* after a call to one of these methods; otherwise the return
* value is undefined.
*/
public int getLineNumber() {
return lineNo;
}
/**
* Return a string description of the position of the last line
* returned by readLine() or readLineSkippingComments().
*/
public String describePosition() {
return resourceName + ':' + lineNo;
}
/**
* Reset this reader so that the next call to
* readLine() returns the first line of the file
* again. This is a somewhat expensive call, however, calling
* reset() after calling it the first time does
* nothing if readLine() has not been called in
* between.
*/
public void reset() {
try {
_reset();
} catch (UnsupportedEncodingException e) {}
// We swallow this exception, if there is one. If the encoding is
// invalid, the constructor will have thrown this exception already and
// the caller shouldn't use the object afterwards.
}
/**
* Reset to the start by reconstructing the stream and readers.
* We could also use mark() and reset() on the stream or reader,
* but that would cause them to keep the stream data around in
* memory. We don't want that because some of the resource files
* are large, e.g., 400k.
*/
private void _reset() throws UnsupportedEncodingException {
if (lineNo == 0) {
return;
}
InputStream is = ICUData.getStream(root, resourceName);
if (is == null) {
throw new IllegalArgumentException("Can't open " + resourceName);
}
InputStreamReader isr =
(encoding == null) ? new InputStreamReader(is) :
new InputStreamReader(is, encoding);
reader = new BufferedReader(isr);
lineNo = 0;
}
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_de_DE.java 0000644 0001750 0001750 00000002647 10666355147 024033 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import com.ibm.icu.util.*;
import java.util.Calendar;
import java.util.ListResourceBundle;
public class HolidayBundle_de_DE extends ListResourceBundle {
static private final Holiday[] fHolidays = {
SimpleHoliday.NEW_YEARS_DAY,
SimpleHoliday.MAY_DAY,
new SimpleHoliday(Calendar.JUNE, 15, Calendar.WEDNESDAY, "Memorial Day"),
new SimpleHoliday(Calendar.OCTOBER, 3, 0, "Unity Day"),
SimpleHoliday.ALL_SAINTS_DAY,
new SimpleHoliday(Calendar.NOVEMBER, 18, 0, "Day of Prayer and Repentance"),
SimpleHoliday.CHRISTMAS,
SimpleHoliday.BOXING_DAY,
// Easter and related holidays
EasterHoliday.GOOD_FRIDAY,
EasterHoliday.EASTER_SUNDAY,
EasterHoliday.EASTER_MONDAY,
EasterHoliday.ASCENSION,
EasterHoliday.WHIT_SUNDAY,
EasterHoliday.WHIT_MONDAY,
};
static private final Object[][] fContents = {
{ "holidays", fHolidays },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_de_AT.java 0000644 0001750 0001750 00000003112 10666355147 024033 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import com.ibm.icu.util.*;
import java.util.Calendar;
import java.util.ListResourceBundle;
public class HolidayBundle_de_AT extends ListResourceBundle {
static private final Holiday[] fHolidays = {
SimpleHoliday.NEW_YEARS_DAY,
SimpleHoliday.EPIPHANY,
EasterHoliday.GOOD_FRIDAY,
EasterHoliday.EASTER_SUNDAY,
EasterHoliday.EASTER_MONDAY,
EasterHoliday.ASCENSION,
EasterHoliday.WHIT_SUNDAY,
EasterHoliday.WHIT_MONDAY,
EasterHoliday.CORPUS_CHRISTI,
SimpleHoliday.ASSUMPTION,
SimpleHoliday.ALL_SAINTS_DAY,
SimpleHoliday.IMMACULATE_CONCEPTION,
SimpleHoliday.CHRISTMAS,
SimpleHoliday.ST_STEPHENS_DAY,
new SimpleHoliday(Calendar.MAY, 1, 0, "National Holiday"),
new SimpleHoliday(Calendar.OCTOBER, 31, -Calendar.MONDAY, "National Holiday"),
};
static private final Object[][] fContents = {
{ "holidays", fHolidays },
// Only holidays names different from those used in Germany are listed here
{ "Christmas", "Christtag" },
{ "New Year's Day", "Neujahrstag" },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/package.html 0000644 0001750 0001750 00000000426 10666355147 021677 0 ustar twerner twerner
Resource data used by classes in com.ibm.text.
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_de.java 0000644 0001750 0001750 00000007427 10666355147 023464 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import java.util.ListResourceBundle;
public class HolidayBundle_de extends ListResourceBundle {
static private final Object[][] fContents = {
{ "All Saints' Day", "Allerheiligen" },
{ "All Souls' Day", "Allerseelen" },
{ "Armistice Day", "Waffenstillstandstag" },
{ "Ascension", "Christi Himmelfahrt" },
{ "Ash Wednesday", "Aschermittwoch" },
{ "Assumption", "Mari\u00e4 Himmelfahrt" },
{ "Boxing Day", "2. Weihnachtstag" },
{ "Carnival", "Karneval" },
{ "Christmas", "Weihnachtstag" },
{ "Civic Holiday", "B\u00fcrgerfeiertag" },
{ "Constitution Day", "Verfassungstag" },
{ "Corpus Christi", "Fronleichnam" },
{ "Day of Prayer and Repentance", "Bu\u00df- und Bettag" },
{ "Easter Monday", "Ostermonntag" },
{ "Easter Sunday", "Ostersonntag" },
{ "Epiphany", "Heilige 3 K\u00f6nige" },
{ "Father's Day", "Vatertag" },
{ "Flag Day", "Jahrestag der Nationalflagge" },
{ "German Unity Day", "Tag der deutschen Einheit" },
{ "Good Friday", "Karfreitag" },
{ "Halloween", "Abend vor Allerheiligen" },
{ "Immaculate Conception", "Mari\u00e4 Empf\u00e4ngnis" },
{ "Independence Day", "Unabh\u00e4ngigkeitstag" },
{ "Labor Day", "Tag der Arbeit" },
{ "Liberation Day", "Befreiungstag" },
{ "Mardi Gras", "Faschingsdienstag" },
{ "Maundy Thursday", "Gr\u00fcndonnerstag" },
{ "May Day", "Maifeiertag" },
{ "Memorial Day", "Tag des Gedenkens" },
{ "Mother's Day", "Muttertag" },
{ "National Holiday", "Nationalfeiertag" },
{ "New Year's Day", "Neujahr" },
{ "New Year's Eve", "Silvesterabend" },
{ "Palm Sunday", "Palmsonntag" },
{ "Pentecost", "Pfingsten" },
{ "Presidents' Day", "Pr\u00e4sidentstag" },
{ "Remembrance Day", "Volkstrauertag" },
{ "Revolution Day", "Jahrestag der Revolution" },
{ "Rose Monday", "Rosenmontag" },
{ "St. Stephen's Day", "Stephanitag" },
{ "Shrove Tuesday", "Faschingsdienstag" },
{ "Spring Holiday", "Tag des Fr\u00fchlings" },
{ "Summer Bank Holiday", "Bankfeiertag" },
{ "Thanksgiving", "Dankfest" },
{ "Unity Day", "Einheitstag" },
{ "Veterans' Day", "Veteranstag" },
{ "Victory Day", "Tag der Befreiung" },
{ "Washington's Birthday", "Washingtons Geburtstag" },
{ "Whit Monday", "Pfingstmontag" },
{ "Whit Sunday", "Pfingstsonntag" },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_en_GB.java 0000644 0001750 0001750 00000002503 10666355147 024034 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import com.ibm.icu.util.*;
import java.util.Calendar;
import java.util.ListResourceBundle;
public class HolidayBundle_en_GB extends ListResourceBundle
{
static private final Holiday[] fHolidays = {
SimpleHoliday.NEW_YEARS_DAY,
SimpleHoliday.MAY_DAY,
new SimpleHoliday(Calendar.MAY, 31, -Calendar.MONDAY, "Spring Holiday"),
new SimpleHoliday(Calendar.AUGUST, 31, -Calendar.MONDAY, "Summer Bank Holiday"),
SimpleHoliday.CHRISTMAS,
SimpleHoliday.BOXING_DAY,
new SimpleHoliday(Calendar.DECEMBER, 31, -Calendar.MONDAY, "Christmas Holiday"),
// Easter and related holidays
EasterHoliday.GOOD_FRIDAY,
EasterHoliday.EASTER_SUNDAY,
EasterHoliday.EASTER_MONDAY,
};
static private final Object[][] fContents = {
{ "holidays", fHolidays },
{ "Labor Day", "Labour Day" },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_iw_IL.java 0000644 0001750 0001750 00000001655 10666355147 024074 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import com.ibm.icu.util.*;
import java.util.ListResourceBundle;
public class HolidayBundle_iw_IL extends ListResourceBundle {
static private final Holiday[] fHolidays = {
HebrewHoliday.ROSH_HASHANAH,
HebrewHoliday.YOM_KIPPUR,
HebrewHoliday.HANUKKAH,
HebrewHoliday.PURIM,
HebrewHoliday.PASSOVER,
HebrewHoliday.SHAVUOT,
HebrewHoliday.SELIHOT,
};
static private final Object[][] fContents = {
{ "holidays", fHolidays },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_da_DK.java 0000644 0001750 0001750 00000002524 10666355147 024027 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import com.ibm.icu.util.*;
import java.util.Calendar;
import java.util.ListResourceBundle;
public class HolidayBundle_da_DK extends ListResourceBundle
{
static private final Holiday[] fHolidays = {
SimpleHoliday.NEW_YEARS_DAY,
new SimpleHoliday(Calendar.APRIL, 30, -Calendar.FRIDAY, "General Prayer Day"),
new SimpleHoliday(Calendar.JUNE, 5, "Constitution Day"),
SimpleHoliday.CHRISTMAS_EVE,
SimpleHoliday.CHRISTMAS,
SimpleHoliday.BOXING_DAY,
SimpleHoliday.NEW_YEARS_EVE,
// Easter and related holidays
EasterHoliday.MAUNDY_THURSDAY,
EasterHoliday.GOOD_FRIDAY,
EasterHoliday.EASTER_SUNDAY,
EasterHoliday.EASTER_MONDAY,
EasterHoliday.ASCENSION,
EasterHoliday.WHIT_MONDAY,
};
static private final Object[][] fContents = {
{ "holidays", fHolidays },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_el_GR.java 0000644 0001750 0001750 00000002555 10666355147 024061 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import com.ibm.icu.util.*;
import java.util.Calendar;
import java.util.ListResourceBundle;
public class HolidayBundle_el_GR extends ListResourceBundle {
static private final Holiday[] fHolidays = {
SimpleHoliday.NEW_YEARS_DAY,
SimpleHoliday.EPIPHANY,
new SimpleHoliday(Calendar.MARCH, 25, 0, "Independence Day"),
SimpleHoliday.MAY_DAY,
SimpleHoliday.ASSUMPTION,
new SimpleHoliday(Calendar.OCTOBER, 28, 0, "Ochi Day"),
SimpleHoliday.CHRISTMAS,
SimpleHoliday.BOXING_DAY,
// Easter and related holidays in the Orthodox calendar
new EasterHoliday(-2, true, "Good Friday"),
new EasterHoliday( 0, true, "Easter Sunday"),
new EasterHoliday( 1, true, "Easter Monday"),
new EasterHoliday(50, true, "Whit Monday"),
};
static private final Object[][] fContents = {
{ "holidays", fHolidays },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_en.java 0000644 0001750 0001750 00000002002 10666355147 023456 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import java.util.ListResourceBundle;
public class HolidayBundle_en extends ListResourceBundle {
// Normally, each HolidayBundle uses the holiday's US English name
// as the string key for looking up the localized name. This means
// that the key itself can be used if no name is found for the requested
// locale.
//
// For holidays where the key is _not_ the English name, e.g. in the
// case of conflicts, the English name must be given here.
//
static private final Object[][] fContents = {
{ "", "" }, // Can't be empty!
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_it_IT.java 0000644 0001750 0001750 00000002500 10666355147 024067 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import com.ibm.icu.util.*;
import java.util.Calendar;
import java.util.ListResourceBundle;
public class HolidayBundle_it_IT extends ListResourceBundle {
static private final Holiday[] fHolidays = {
SimpleHoliday.NEW_YEARS_DAY,
SimpleHoliday.EPIPHANY,
new SimpleHoliday(Calendar.APRIL, 1, 0, "Liberation Day"),
new SimpleHoliday(Calendar.MAY, 1, 0, "Labor Day"),
SimpleHoliday.ASSUMPTION,
SimpleHoliday.ALL_SAINTS_DAY,
SimpleHoliday.IMMACULATE_CONCEPTION,
SimpleHoliday.CHRISTMAS,
new SimpleHoliday(Calendar.DECEMBER, 26, 0, "St. Stephens Day"),
SimpleHoliday.NEW_YEARS_EVE,
// Easter and related holidays
EasterHoliday.EASTER_SUNDAY,
EasterHoliday.EASTER_MONDAY,
};
static private final Object[][] fContents = {
{ "holidays", fHolidays },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/HolidayBundle_ja_JP.java 0000644 0001750 0001750 00000001504 10666355147 024045 0 ustar twerner twerner /*
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl.data;
import com.ibm.icu.util.*;
import java.util.Calendar;
import java.util.ListResourceBundle;
public class HolidayBundle_ja_JP extends ListResourceBundle {
static private final Holiday[] fHolidays = {
new SimpleHoliday(Calendar.FEBRUARY, 11, 0, "National Foundation Day"),
};
static private final Object[][] fContents = {
{ "holidays", fHolidays },
};
public synchronized Object[][] getContents() { return fContents; }
}
icu4j-4.2.1.1/src/com/ibm/icu/impl/data/icudata.jar 0000755 0001750 0001750 00033327306 11357502026 021534 0 ustar twerner twerner PK
.eŽ; META-INF/PK
Œc,< com/PK
Œc,< com/ibm/PK
Œc,< com/ibm/icu/PK
Œc,< com/ibm/icu/impl/PK
Œc,< com/ibm/icu/impl/data/PK
Xtˆ< com/ibm/icu/impl/data/icudt42b/PK
Xtˆ< & com/ibm/icu/impl/data/icudt42b/brkitr/PK
Xtˆ< $ com/ibm/icu/impl/data/icudt42b/coll/PK
Xtˆ< $ com/ibm/icu/impl/data/icudt42b/rbnf/PK
Wtˆ< ( com/ibm/icu/impl/data/icudt42b/translit/PK
.eŽ;?®<‡G G META-INF/MANIFEST.MFóMÌËLK-.Ñ
K-*ÎÌϳR0Ô3àår.JM,IMÑuª ˜éÄš)h—æ)øf&åW—¤æ+xæ%ëiòrñr PK
eŽ;$ # % com/ibm/icu/impl/data/icudt42b/af.resY}dÕUÿÝ×ÓýzvHv‚HÆ@
fܸ$HÍWÌÐÝ3;;È›í·=½3ÝoÒ 3Ì„¬†`a%&âG4Á ›˜JI“B%j¢–TES~P¢Ñš¯P"(†JôwÏ»ï£gW+8=¿é÷ν÷ÜsÎ=çÜsï óÌU8 P°Psû9eñy áOéGù•"žÒŸ÷“º-ï
»ƒ^Ûí#[DvÙ)dËÈV!Û@vÙeä²È+"7‰ÜrÓÈU‘›C®†\¹#Èg‘ŸD~
ùiäg/#_A¾Šüò‹È³Ã2
EfQ(¡0‡Â2ŠE§PœF±Žb“³˜¬`²†©,¦r˜*bª‚©*¦nʼn‡1]ÃtÓ ˜)`¦ˆ™*fnÅL 3
ÌV0;‡Ùy”Š(M¡4R¥*J¤ÔP:ŒÒ2Ê9”k(7P^@yå#¨dQ™Be•*UTj¨,¢²„
›–QÍ¢ZFuժ˘ŸÂü4æ˸5‹Ú j ¨gQÏ¡žG½€zõ)ÔgP/¡>‡zõEÔ Q@c
U4æШ¡Ñ@c Y,Ô±°ŒÅ,óX¬âHËY,ÓhÃ^Ïí Õ ’ŸžDqÊçæ©e™
¡XNž#«2q„l
XZZâàŠwºu§—_uzÎÑÛë£ìt[C§EfÎ1þ:p:pzü=Š•ŽöÑtÐtᶶá®Ãí‚=Ýþ 7\ÿcp8ÖƱ ZÞ -XuÑ à¸ƒ5kCt×ù{}¢ÛE·‡ï Cô<ô†è÷Ñ `°†Mw®â‡({Gu·~´×fïê°³âöŠënÇíúæuÞPîn ‹”¾íu¡t›¹Õs[^¯ít‘íÌw*NoMëWpn£ÝqÃqMg»êt¨Å1¯×qpVVzîf›ÝšØjkU{N„ÚñºƒÕÿ{ÌQ¯Í°nLŠ¾¯©½öÀëm£ã:ýaOô©o÷nÇçÊ•î¸ ±£:Ü^‡E¸è]´ÑB“OdIq°B
Ù
¥ˆß4uÀwœ:ű»ØïÇ82¶Ïýä·íe[—ÍsHzFfÈ Çç 99“cúÚì»NšÏç´¤[dè¹|Ú.¡µ„¦9›á1Ž9x"ƒníak2fœc†Bײ¯‡¼v“ÞÍWø·MiŽûÒóçJ©yùüɧ¥÷ þm±uKæwŒ\9Û"G,Ø'7_®Û\Ò[1YÏþšÛšá’Á$ÿÒEI÷û¤Ùg(ã ÑÆ
m¥çZ•ky5' »B
hžè»êœ–~zžv`‰çªŒ „6ØÃì1Àjb¿uiiJ[
%ysbkx)êf]ô ÚÒâ =rYJ×xR7ÈsEdpÍ:%ÉÓzfþºØx`V)>3ÔÊãG[PKçËDžzøºùý´œ ï['èWçúDë7Æ~Cñ¿À¯K"ñ¥õ££Ú?Å9ÚléÅæ݇ùi¿hÅ"æìzŽ£@š¯×¨N‘iŬC;ôë‚Y׎xš–„?’îILv Çâ¬%EqV”è]ߢh²1ë‡E³ ÚNûŸ#ë ؤξzüñ°š<² Û"_KÒÓýhk›Ø©ˆü=Y}W|ótÈcRféJûv¨G
S’âkz i=ñ í³9Ñp`üù¸±™Í>®xM+ÔßçÕ‘\w:Æ(–uC}öRŸ5z¤Îžp¼ü̾»DßòndYi;g¤¿–´-qïêËX=œÀb³i¾¿à{…ØeÚÄÊhng\è™F,)zn@ÓAدƒ é h:š‚žƒÐºƒ çà1 cèƒÓ ÆÑ øsð… Úé h8ø&iï{‡š6'e °Ý§Ë G¬…jû ìq’Âê´þ›¼„o~Ñ8ýF“§Úv]ÞEðgcöiöÇž—â³ü*«OUÏU/U_¨¾¾ú¹Õ7réqàJ ,Ož Ðgïyš÷VÕùQ2
Ï›è%92+Ÿæ×Òóý×¢?x4ù‹QÈ» ¹·“ÒFÚþXé[-ê bb?O@‹§RMóqW¿»úöêUß]
¹2{é€ ô÷}ÄY}¬úï~w=¹ôÕ ôYœ ˆ±ÖÚ¯ØìÒ³&¥ã´G—6!¬²ù³KE=ø<Ë~OûõnÛ>ˆKŒòcqûÛBzsbÖE–Õ,¤Þ<©ÑmÛ/JëØ |«˜ÁŸclú´Aëd•–>"÷Õ43‰§-v‰‘ÐtÂâ]L<û–E»Ø5ó,V”åiÝëÅ_ý`õCÕ¿¬þcõ?jÜ5ÁšÚšm5»kpíÒ_ 'ä€í9´ÀçP'ð £ùC(ÿ}rƒÒ×Âfû:Ñ6-h>Ÿ÷hlŒy,GÍÑëÈ¡5|דC×°>˜öÈ11Vàçú¥/Â%9%Ç´¥ú嘥#*Ñ›‹ø{Äž«6É*ýœ³Â‡ŠŠÙ¿VÅ— {øûä ¬¿÷üyf¼Ü=L–¢2~’y§ò7çõ~³}QWôS‡ž ï<ô<àॠúÏC7o o‡Þ ÜüÇÿżø$ði }ß!Ø•C_¾ÀG8„þùЇ Èâ!ø ‡þ@œ5çjžöîwCVÞüòR¨'‡ÝøœÁ§—ðsÊænü¤,;Æv-Æäï~í|¬›é¿? ýs*óÌŽ)¼IÊ“:jíYÚ•ñfÛ•q\ÊžÁ
>•gí+Ä8Måm„ Å9BSÔ øH‡á †Ÿtx €2cTréÃ* î ÷1/FI þàá'ð¿Ã'< ìð"PÎð{?¸ róæš÷R¹9Ü <òräåeø|1>o¤v>=aŸòyœ‡¡‡_Gí¹ þëÉ é&‹øï&Ëø¯'³__ï*³åÃ
nå&IþOOÚ‘ ÍÿÙï5‘_ùð Âgê䕆³Ï5ñ/ÆæÕ2×*ÅýéëÅýêÉÿ‚0Úv ¾¸ €ÿ{ø£Àg€/ ð}Ã÷=ü}àÇ üßÿ¡2AR‚OfŸÁŸKCŸ3?,¾W’¤Æ/úç±…™Ï‰6Ê„¹mi
•—¦l"¬aiIÇ ‹ëVÚ–ÉhJ;§öËs£ïj · Ãl×`y‰×
=DÔṈ̃ž •uä¿è?Ó=|Ö+2àYGn*KdmcÍ/j~]óÛš?Öü½ÖQ[Y¨®«ÝX»¥v[íÎÚ=µÑÚÖÚƒµ‡k [ÛS›¢ytAŸº Àø* ¶¬k° À8« }GlDW ¢ Ù;ÖÕ À_èÂø¦ þF× à ÀifK¨ÏÅçdÜÆ>£‘ŸÉà|Á/¾þÂfá„}ÚÃ<À.%¬BÌ]w(ö*Éï& íUTô¿•(÷¹ Æt]kva¬Ùõ 㪮7sžÄ¢‰ÏµètyÄ|6s®ÓN ŸßÑi4ÒižóPi}€1p×ðß»Ðçv}øqÖfj©Mìzð%fûš…
ìŸâ³M|¶ˆÏ&ñÙ!Ëù€>» ºÛõ €ñk×O€ŸGíS‘ÿÏQÞTm‘Žº¾ üžñµ—´˜k×–Ýíú+@ŸïëgëŠ û˜R´méié2|w%Êz^í+YÝþy é°²ø󉙤 ÝÜÛœ’g¹»‘ã2GHÛÂôÇ»ÅÞÞŠÚÛk?P{Gí‡hœnÈq7üãî Àn”ýöÚw±ðÚzÒ aå $,G-üîvYnÝ—ÍÂaÿºIy¡ýo—ðû µ°‹Ý•×ZÙÝÃ÷Ó»õáxÞùuÒ'>°pøMÝC2M£2?ì¨ý ® %Ö zóɻص¿áÚ‰¾8ê*~J‘1î÷9êÀÛî,±æSlôÅ讫õyâ¯}síµŸ«½·ö¾Ú Ôþ¼öµÿ¨«¬ ƒ7-ÀAà2 Ž Ç€'Ó@ Ï®¶ÙL>þÕÃè_Mi<|–ÄDû8ëëšY;= x!ÒÖ–ØX½µ+¡åã8ëÖ bù¿x¡ýö°øo–ß(Ÿ`ãºé“E]HßÌúG Z·û#,l
ak, ZÙý |Ûa–V¦7ר)×Ûão·¤¶¼· ×h âÿ7 ®ºtÝ‘:Èáÿ×Ý™ÇÉUT{¼:Éô@[ÒÓݳ÷2팓 a2L73=·—Û5 ˆ‡ì@ û""‡` ‚ˆ€ì JTDd‘í±ˆ€‘E…Ç*O1(‚(»ß[˽u{?ú—~äóùÑ™:÷Ö=uêœS§êÖ=µˆñÑà%áÇ0¶ä#£ŽŽì²u\…ÜwM,‘rOˆ1ÿ àä?Ö¯‘ç$£ýßa=WÛãdûz®ù»OCû&öO,…Wâû1Ʊ¡ ™Ì¦™9ê¤7ÏÔÒóOt €Èf €ÅÀ@ šüïÊðʺñƒGþ^
€ ?èñ ~Ðá?< <
€7þoO? ~Èÿ÷ øâ-þ oÃÚ zàS`0 Ÿ— 'p- ZÕ@Ð
€G6 €¬nn>@^ŸPÔ_ >[ õ Ô_àëÀ ê.ð?ÀO€_ 1ðgt—ÀŸ è Nfó м €ÌASrD½!OÁu ê.øA 4·q ì>ìPÁOàç èO¶8ˆ)º‚П෠èO< ‚¦ ä)ˆú ¾@¾C´‰ò ¸A¾CàUh! ^…@[èj uú ´…jð,ž… S!ÐB †P‡!Ôaèv 4…À«è AŸC©Ð× ´8!ÐB=†@S¼
ýø% šB¨Ëê2¹ÊÏò@W èÊC ægyàY hÉC½åÕ€-À õ•~äÝ
Žò cyÈ72”÷€üó Ëyå¼g¨¿KJÑV5°vnJ®µ+bîï<ó\ŽÊvú7ú<õ“"J¤BÿÍzWk\¨gA¯ÏH¿¦ý›zH¤·à4)ë`H¹\ûöGí·Ú«ð°«½Œÿ¿%Kš ‹S‡Ùu)Ù&ý]5
ãY”eê¸È¯ÿ¹Á×Ã( :ãÀ›‘5â><-â†EÙC¬¬CYq™O«ó74þŸR߆Ô3JWˆ{‹'[W3ɪ#—lÆÖÓ –<ý-ðv]KvK 9Ç –Æ€áÿSÇ w…C”w Ò"Ì¿}·éèõö*«7zõGíeµÞ¦ÁŽO›!Ó¯gé_2iúƒ¬t±œþ¨ý^JËIä³ X)óiü,O_ýÑT´7ÓÐîKÁ—…ïh¬Y2Æ´¹ i¬32Æ…h°ÁÓ>,hlº9wÒt¸nNHÚ^Ó^´½*UÚ@R¦»D‘Ù‹¥kćÏ0íã"~3ibñór¥b¼;-$ô6É{èÏ´Ï‹ø-"ÿ)“·bi a51¬Ð€6qÚ Óª5ÝRoüʺ,>ÆÈuaÌÐ…iðo¦}Uäß
Õùš½.«@Œx1[%ëü)Q0ñõIà[Œ&ºó<.i
½cÚF°Ó^`´•1‹LÿÍÏZ¦ÏÅN¶6ŒÛÕÁ žAÿ§ýQØ€°ÿI;sýÒ·Ÿ‘ïde/C 'EkUôõQ°“blýP®úÌŸ
̧ú¢ýEØߌõk¬¿˜)ö( >UþrÁ¯JRÎâ.ÌZã6Èú˜\Ãج«Íaíq1ÒÍG b#@tm”´ùðÕòßË®ËÐék4Þ9}=>´6¿IÒÇÛ–Ùï’>®‘ÇØ<†"gù° ùm"Í*‘æTÓú<}„W˧-×)I|”üeõB‡s¥¡×›ãïÉß/øRaªk¹ææÃ|ø$ù÷°¼× vZØŸÌõ‚Y •ñ¡ûùƒ‚ö
a?t9b£gG&³ùð}òGEÜz×—±–0W<øJùçEySrÜó¤yµ¡2þJã ß’ÿ,Ëk ÙJ 3#N.›ÿKAç:²Å
æŒ;„ßT¯FdÝ ¯–ÿºˆÛЗ™×@šR¥?$Æ¥ùÚ$ªñFkòÙb¿ÆžÈ }ŒéDæÅõoÆ»Ìk «§ýzZÓј>G¦UÉÂÿ{t+VúeÙ2¿bÐ; }Ãé+Øu£´QS/’‡Þ–7ø; ò>½JÒÉugοQæ ¦Uœ¿zš-À&™fã¿ÅG½ìzZè Mïi5 *ë]s¶¬"îÍÀ · šÉevŠ±–é%]{™‡ ŠO;ý¿€;Eþ-ÂGô‰qÛ!±&T§á;J¼{/Šx…¿È±¦¶€BŽ¨íÀôÀˆ»YÈü"agÇ4Óº[á9r«Æ}¶š_JÎïrûtÓá3LLæÑ(x3y FÚFè¯Oÿ ‘F«¨\œ³mœþkà7,N9|Ý_+nŽ\ÜWš[0ý¯"~mÅíŸ)k……¥5|ßVGª¼O¬1Dz3,€]¤W-ôtŠ\œ«Ç"æ
šfä3EræiŒNnûg\
,•yodñò/šwÎvyÆ•ÀÕ":Á“yúºc…›|&æá…ðy'Þ6é+cÙúU™.RšQ#Óåu¥ÉõÌŠ¥ÏØ"ž¯'|OËL¹æ£€Q2n’)ž'_{¡€ê•Ò—Ñ t‰ôÖ)²’µ2:w»3ã&à¿EУpAr@Ÿ÷`ëÚ3-¥L¶`µ–>?Ÿ§®Å±ø }ýö ä
lÁŒû-Mž!WI {…rßV¼‘ÖCÀˆL«Vò9ÇÞ¡ ¿i@¬Û TíÍŒÇ'Ezz Æk¬ 7sWÄÞÏxNÄÙ âäñuãÊœ ]9ÎW
°ýFü_/‹ø›Éý,<˜µvœÏ—í×gSE\xÕ3þÆ®k-~¹îh²òç,óL
Þ÷¯ÀÞošjÚ3fZ‹nî)ˆ4¦ÓÙu…ìƒxQJZwµ 9ã€S3/¶¢lgáÓúöIíÅÌbàJAsI²¸~ägìs:-[Ó§
Ù›ù @9‹×¨ø˜ëäsëÐLx3׋2–Jßøvæñ«žußxæ
À‡Y¾•LR¹þëçù´a&÷ãúœ«¿HÈøÜo,Ì2ËvŠµE|.–ÎS •=¤ó¬¤¶ü_oaøU3a7fÞ"òÕùœ—s}¿á» Šu½4þAà^¿JÈv@ß 9f’lYf|Ï