/**@class java.text.RuleBasedCollator @extends java.text.Collator The <code>RuleBasedCollator</code> class is a concrete subclass of <code>Collator</code> that provides a simple, data-driven, table collator. With this class you can create a customized table-based <code>Collator</code>. <code>RuleBasedCollator</code> maps characters to sort keys. <p> <code>RuleBasedCollator</code> has the following restrictions for efficiency (other subclasses may be used for more complex languages) : <ol> <li>If a special collation rule controlled by a <modifier> is specified it applies to the whole collator object. <li>All non-mentioned characters are at the end of the collation order. </ol> <p> The collation table is composed of a list of collation rules, where each rule is of one of three forms: <pre> <modifier> <relation> <text-argument> <reset> <text-argument> </pre> The definitions of the rule elements is as follows: <UL> <LI><strong>Text-Argument</strong>: A text-argument is any sequence of characters, excluding special characters (that is, common whitespace characters [0009-000D, 0020] and rule syntax characters [0021-002F, 003A-0040, 005B-0060, 007B-007E]). If those characters are desired, you can put them in single quotes (e.g. ampersand => '&'). Note that unquoted white space characters are ignored; e.g. <code>b c</code> is treated as <code>bc</code>. <LI><strong>Modifier</strong>: There are currently two modifiers that turn on special collation rules. <UL> <LI>'@' : Turns on backwards sorting of accents (secondary differences), as in French. <LI>'!' : Turns on Thai/Lao vowel-consonant swapping. If this rule is in force when a Thai vowel of the range \U0E40-\U0E44 precedes a Thai consonant of the range \U0E01-\U0E2E OR a Lao vowel of the range \U0EC0-\U0EC4 precedes a Lao consonant of the range \U0E81-\U0EAE then the vowel is placed after the consonant for collation purposes. </UL> <p>'@' : Indicates that accents are sorted backwards, as in French. <LI><strong>Relation</strong>: The relations are the following: <UL> <LI>'<' : Greater, as a letter difference (primary) <LI>';' : Greater, as an accent difference (secondary) <LI>',' : Greater, as a case difference (tertiary) <LI>'=' : Equal </UL> <LI><strong>Reset</strong>: There is a single reset which is used primarily for contractions and expansions, but which can also be used to add a modification at the end of a set of rules. <p>'&' : Indicates that the next rule follows the position to where the reset text-argument would be sorted. </UL> <p> This sounds more complicated than it is in practice. For example, the following are equivalent ways of expressing the same thing: <blockquote> <pre> a < b < c a < b & b < c a < c & a < b </pre> </blockquote> Notice that the order is important, as the subsequent item goes immediately after the text-argument. The following are not equivalent: <blockquote> <pre> a < b & a < c a < c & a < b </pre> </blockquote> Either the text-argument must already be present in the sequence, or some initial substring of the text-argument must be present. (e.g. "a < b & ae < e" is valid since "a" is present in the sequence before "ae" is reset). In this latter case, "ae" is not entered and treated as a single character; instead, "e" is sorted as if it were expanded to two characters: "a" followed by an "e". This difference appears in natural languages: in traditional Spanish "ch" is treated as though it contracts to a single character (expressed as "c < ch < d"), while in traditional German a-umlaut is treated as though it expanded to two characters (expressed as "a,A < b,B ... &ae;\u00e3&AE;\u00c3"). [\u00e3 and \u00c3 are, of course, the escape sequences for a-umlaut.] <p> <strong>Ignorable Characters</strong> <p> For ignorable characters, the first rule must start with a relation (the examples we have used above are really fragments; "a < b" really should be "< a < b"). If, however, the first relation is not "<", then all the all text-arguments up to the first "<" are ignorable. For example, ", - < a < b" makes "-" an ignorable character, as we saw earlier in the word "black-birds". In the samples for different languages, you see that most accents are ignorable. <p><strong>Normalization and Accents</strong> <p> <code>RuleBasedCollator</code> automatically processes its rule table to include both pre-composed and combining-character versions of accented characters. Even if the provided rule string contains only base characters and separate combining accent characters, the pre-composed accented characters matching all canonical combinations of characters from the rule string will be entered in the table. <p> This allows you to use a RuleBasedCollator to compare accented strings even when the collator is set to NO_DECOMPOSITION. There are two caveats, however. First, if the strings to be collated contain combining sequences that may not be in canonical order, you should set the collator to CANONICAL_DECOMPOSITION or FULL_DECOMPOSITION to enable sorting of combining sequences. Second, if the strings contain characters with compatibility decompositions (such as full-width and half-width forms), you must use FULL_DECOMPOSITION, since the rule tables only include canonical mappings. <p><strong>Errors</strong> <p> The following are errors: <UL> <LI>A text-argument contains unquoted punctuation symbols (e.g. "a < b-c < d"). <LI>A relation or reset character not followed by a text-argument (e.g. "a < ,b"). <LI>A reset where the text-argument (or an initial substring of the text-argument) is not already in the sequence. (e.g. "a < b & e < f") </UL> If you produce one of these errors, a <code>RuleBasedCollator</code> throws a <code>ParseException</code>. <p><strong>Examples</strong> <p>Simple: "< a < b < c < d" <p>Norwegian: "< a, A < b, B < c, C < d, D < e, E < f, F < g, G < h, H < i, I < j, J < k, K < l, L < m, M < n, N < o, O < p, P < q, Q < r, R < s, S < t, T < u, U < v, V < w, W < x, X < y, Y < z, Z < \u00E6, \u00C6 < \u00F8, \u00D8 < \u00E5 = a\u030A, \u00C5 = A\u030A; aa, AA" <p> To create a <code>RuleBasedCollator</code> object with specialized rules tailored to your needs, you construct the <code>RuleBasedCollator</code> with the rules contained in a <code>String</code> object. For example: <blockquote> <pre> String simple = "< a< b< c< d"; RuleBasedCollator mySimple = new RuleBasedCollator(simple); </pre> </blockquote> Or: <blockquote> <pre> String Norwegian = "< a, A < b, B < c, C < d, D < e, E < f, F < g, G < h, H < i, I" + "< j, J < k, K < l, L < m, M < n, N < o, O < p, P < q, Q < r, R" + "< s, S < t, T < u, U < v, V < w, W < x, X < y, Y < z, Z" + "< \u00E6, \u00C6" + // Latin letter ae & AE "< \u00F8, \u00D8" + // Latin letter o & O with stroke "< \u00E5 = a\u030A," + // Latin letter a with ring above " \u00C5 = A\u030A;" + // Latin letter A with ring above " aa, AA"; RuleBasedCollator myNorwegian = new RuleBasedCollator(Norwegian); </pre> </blockquote> <p> A new collation rules string can be created by concatenating rules strings. For example, the rules returned by {@link #getRules}() could be concatenated to combine multiple <code>RuleBasedCollator</code>s. <p> The following example demonstrates how to change the order of non-spacing accents, <blockquote> <pre> // old rule String oldRules = "=\u0301;\u0300;\u0302;\u0308" // main accents + ";\u0327;\u0303;\u0304;\u0305" // main accents + ";\u0306;\u0307;\u0309;\u030A" // main accents + ";\u030B;\u030C;\u030D;\u030E" // main accents + ";\u030F;\u0310;\u0311;\u0312" // main accents + "< a , A ; ae, AE ; \u00e6 , \u00c6" + "< b , B < c, C < e, E & C < d, D"; // change the order of accent characters String addOn = "& \u0300 ; \u0308 ; \u0302"; RuleBasedCollator myCollator = new RuleBasedCollator(oldRules + addOn); </pre> </blockquote> @see Collator @see CollationElementIterator @author Helena Shih, Laura Werner, Richard Gillam */ var RuleBasedCollator = { /**Gets the table-based rules for the collation object. <p>On Android, the returned string will be empty unless this instance was constructed using {@link #RuleBasedCollator}(String). @return {String} returns the collation rules that the table collation object was created from. */ getRules : function( ) {}, /**Returns a CollationElementIterator for the given String. @param {String} source the string to be collated @return {Object {java.text.CollationElementIterator}} a {@code CollationElementIterator} object @see java.text.CollationElementIterator */ getCollationElementIterator : function( ) {}, /**Returns a CollationElementIterator for the given CharacterIterator. @param {Object {CharacterIterator}} source the character iterator to be collated @return {Object {java.text.CollationElementIterator}} a {@code CollationElementIterator} object @see java.text.CollationElementIterator @since 1.2 */ getCollationElementIterator : function( ) {}, /**Compares the character data stored in two different strings based on the collation rules. Returns information about whether a string is less than, greater than or equal to another string in a language. This can be overriden in a subclass. @exception NullPointerException if <code>source</code> or <code>target</code> is null. */ compare : function( ) {}, /**Transforms the string into a series of characters that can be compared with CollationKey.compareTo. This overrides java.text.Collator.getCollationKey. It can be overriden in a subclass. */ getCollationKey : function( ) {}, /**Standard override; no change in semantics. */ clone : function( ) {}, /**Compares the equality of two collation objects. @param {Object {Object}} obj the table-based collation object to be compared with this. @return {Boolean} true if the current table-based collation object is the same as the table-based collation object obj; false otherwise. */ equals : function( ) {}, /**Generates the hash code for the table-based collation object */ hashCode : function( ) {}, };