Collator suitable
* for string collation in a wide variety of languages. An instance of
* this class is normally returned by the getInstance method
* of Collator with rules predefined for the requested
* locale. However, an instance of this class can be created manually
* with any desired rules.
*
* Rules take the form of a String with the following syntax
*
* As for the text argument itself, this is any sequence of Unicode * characters not in the following ranges: 0x0009-0x000D, 0x0020-0x002F, * 0x003A-0x0040, 0x005B-0x0060, and 0x007B-0x007E. If these characters are * desired, they must be enclosed in single quotes. If any whitespace is * encountered, it is ignored. (For example, "a b" is equal to "ab"). *
* The reset operation inserts the following rule at the point where the
* text argument to it exists in the previously declared rule string. This
* makes it easy to add new rules to an existing string by simply including
* them in a reset sequence at the end. Note that the text argument, or
* at least the first character of it, must be present somewhere in the
* previously declared rules in order to be inserted properly. If this
* is not satisfied, a ParseException will be thrown.
*
* This system of configuring RuleBasedCollator is needlessly
* complex and the people at Taligent who developed it (along with the folks
* at Sun who accepted it into the Java standard library) deserve a slow
* and agonizing death.
*
* Here are a couple of example of rule strings: *
* "< a < b < c" - This string says that a is greater than b which is * greater than c, with all differences being primary differences. *
* "< a,A < b,B < c,C" - This string says that 'A' is greater than 'a' with * a tertiary strength comparison. Both 'b' and 'B' are greater than 'a' and * 'A' during a primary strength comparison. But 'B' is greater than 'b' * under a tertiary strength comparison. *
* "< a < c & a < b " - This sequence is identical in function to the * "< a < b < c" rule string above. The '&' reset symbol indicates that * the rule "< b" is to be inserted after the text argument "a" in the * previous rule string segment. *
* "< a < b & y < z" - This is an error. The character 'y' does not appear * anywhere in the previous rule string segment so the rule following the * reset rule cannot be inserted. *
* For a description of the various comparison strength types, see the
* documentation for the Collator class.
*
* As an additional complication to this already overly complex rule scheme, * if any characters precede the first rule, these characters are considered * ignorable. They will be treated as if they did not exist during * comparisons. For example, "- < a < b ..." would make '-' an ignorable * character such that the strings "high-tech" and "hightech" would * be considered identical. *
* A ParseException will be thrown for any of the following
* conditions:
*
RuleBasedCollator
* with the specified collation rules. Note that an application normally
* obtains an instance of RuleBasedCollator by calling the
* getInstance method of Collator. That method
* automatically loads the proper set of rules for the desired locale.
*
* @param rules The collation rule string.
*
* @exception ParseException If the rule string contains syntax errors.
*/
public
RuleBasedCollator(String rules) throws ParseException
{
this.rules = rules;
if (rules.equals(""))
throw new IllegalArgumentException("Empty rule set");
Vector v = new Vector();
boolean ignore_chars = true;
int primary_seq = 0;
short secondary_seq = 0;
short tertiary_seq = 0;
StringBuffer sb = new StringBuffer("");
for (int i = 0; i < rules.length(); i++)
{
char c = rules.charAt(i);
// Check if it is a whitespace character
if (((c >= 0x09) && (c <= 0x0D)) || (c == 0x20))
continue;
// Primary difference
if (c == '<')
{
ignore_chars = false;
secondary_seq = 0;
tertiary_seq = 0;
++primary_seq;
CollationElement e = new CollationElement(sb.toString(), primary_seq,
secondary_seq,
tertiary_seq);
v.add(e);
sb.setLength(0);
continue;
}
// Secondary difference
if (c == ';')
{
if (primary_seq == 0)
throw new ParseException(rules, i);
++secondary_seq;
tertiary_seq = 0;
CollationElement e = new CollationElement(sb.toString(), primary_seq,
secondary_seq,
tertiary_seq);
v.add(e);
sb.setLength(0);
continue;
}
// Tertiary difference
if (c == ',')
{
if (primary_seq == 0)
throw new ParseException(rules, i);
++tertiary_seq;
CollationElement e = new CollationElement(sb.toString(), primary_seq,
secondary_seq,
tertiary_seq);
v.add(e);
sb.setLength(0);
continue;
}
// Is equal to
if (c == '=')
{
if (primary_seq == 0)
throw new ParseException(rules, i);
CollationElement e = new CollationElement(sb.toString(), primary_seq,
secondary_seq,
tertiary_seq);
v.add(e);
sb.setLength(0);
continue;
}
// Sort accents backwards
if (c == '@')
{
throw new ParseException("French style accents not implemented yet", 0);
}
// Reset command
if (c == '&')
{
throw new ParseException("Reset not implemented yet", 0);
}
// See if we are still reading characters to skip
if (ignore_chars == true)
{
CollationElement e = new CollationElement(c + "", 0, (short)0,
(short)0);
v.add(e);
continue;
}
sb.append(c);
}
ce_table = v.toArray();
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method returns a String containing the collation rules
* for this object.
*
* @return The collation rules for this object.
*/
public String
getRules()
{
return(rules);
}
/*************************************************************************/
/**
* This method calculates the collation element value for the specified
* character(s).
*/
int
getCollationElementValue(String str)
{
CollationElement e = null;
// The table is sorted. Change to a binary search later.
for (int i = 0; i < ce_table.length; i++)
if (((CollationElement)ce_table[i]).char_seq.equals(str))
{
e = (CollationElement)ce_table[i];
break;
}
if (e == null)
e = new CollationElement(str, 0xFFFF, (short)0xFF, (short)0xFF);
int retval = (e.primary << 16) + (e.secondary << 8) + e.tertiary;
return(retval);
}
/*************************************************************************/
/**
* This method returns an instance for CollationElementIterator
* for the specified String under the collation rules for this
* object.
*
* @param str The String to return the CollationElementIterator instance for.
*
* @return A CollationElementIterator for the specified String.
*/
public CollationElementIterator
getCollationElementIterator(String str)
{
return(new CollationElementIterator(this, str));
}
/*************************************************************************/
/**
* This method returns an instance of CollationElementIterator
* for the String represented by the specified
* CharacterIterator.
*
* @param ci The CharacterIterator with the desired String.
*
* @return A CollationElementIterator for the specified String.
*/
public CollationElementIterator
getCollationElementIterator(CharacterIterator ci)
{
StringBuffer sb = new StringBuffer("");
// Right now we assume that we will read from the beginning of the string.
char c = ci.first();
while (c != CharacterIterator.DONE)
{
sb.append(c);
c = ci.next();
}
return(getCollationElementIterator(sb.toString()));
}
/*************************************************************************/
/**
* This method returns an integer which indicates whether the first
* specified String is less than, greater than, or equal to
* the second. The value depends not only on the collation rules in
* effect, but also the strength and decomposition settings of this object.
*
* @param s1 The first String to compare.
* @param s2 A second String to compare to the first.
*
* @return A negative integer if s1 < s2, a positive integer
* if s1 > s2, or 0 if s1 == s2.
*/
public int
compare(String s1, String s2)
{
CollationElementIterator cei1 = getCollationElementIterator(s1);
CollationElementIterator cei2 = getCollationElementIterator(s2);
for(;;)
{
int ord1 = cei1.next();
int ord2 = cei2.next();
// Check for end of string
if (ord1 == CollationElementIterator.NULLORDER)
if (ord2 == CollationElementIterator.NULLORDER)
return(0);
else
return(-1);
else if (ord2 == CollationElementIterator.NULLORDER)
return(1);
// We know chars are totally equal, so skip
if (ord1 == ord2)
continue;
// Check for primary strength differences
int prim1 = cei1.primaryOrder(ord1);
int prim2 = cei2.primaryOrder(ord2);
if (prim1 < prim2)
return(-1);
else if (prim1 > prim2)
return(1);
else if (getStrength() == PRIMARY)
continue;
// Check for secondary strength differences
int sec1 = cei1.secondaryOrder(ord1);
int sec2 = cei2.secondaryOrder(ord2);
if (sec1 < sec2)
return(-1);
else if (sec1 > sec2)
return(1);
else if (getStrength() == SECONDARY)
continue;
// Check for tertiary differences
int tert1 = cei1.tertiaryOrder(ord1);
int tert2 = cei2.tertiaryOrder(ord1);
if (tert1 < tert2)
return(-1);
else if (tert1 > tert2)
return(1);
}
}
/*************************************************************************/
/**
* This method returns an instance of CollationKey for the
* specified String. The object returned will have a
* more efficient mechanism for its comparison function that could
* provide speed benefits if multiple comparisons are performed, such
* as during a sort.
*
* @param str The String to create a CollationKey for.
*
* @return A CollationKey for the specified String.
*/
public CollationKey
getCollationKey(String str)
{
CollationElementIterator cei = getCollationElementIterator(str);
Vector vect = new Vector(25);
int ord = cei.next();
while (ord != CollationElementIterator.NULLORDER)
{
switch (getStrength())
{
case PRIMARY:
ord = cei.primaryOrder(ord);
break;
case SECONDARY:
ord = cei.secondaryOrder(ord);
default:
break;
}
vect.add(new Integer(ord));
}
Object[] objarr = vect.toArray();
byte[] key = new byte[objarr.length * 4];
for (int i = 0; i < key.length; i++)
{
int j = ((Integer)objarr[i]).intValue();
key[i++] = (byte)((j & 0xFF000000) >> 24);
key[i++] = (byte)((j & 0x00FF0000) >> 16);
key[i++] = (byte)((j & 0x0000FF00) >> 8);
key[i++] = (byte)(j & 0x000000FF);
}
return(new CollationKey(this, str, key));
}
/*************************************************************************/
/**
* This method tests this object for equality against the specified
* object. This will be true if and only if the specified object is
* another reference to this object.
*
* @param obj The Object to compare against this object.
*
* @return true if the specified object is equal to this object, false otherwise.
*/
public boolean
equals(Object obj)
{
if (obj == this)
return(true);
else
return(false);
}
/*************************************************************************/
/**
* This method returns a hash value for this object.
*
* @return A hash value for this object.
*/
public int
hashCode()
{
return(System.identityHashCode(this));
}
/*************************************************************************/
/**
* This method creates a copy of this object.
*
* @return A copy of this object.
*/
public Object
clone()
{
return super.clone();
}
} // class RuleBasedCollator