| /* GENERATED SOURCE. DO NOT MODIFY. */ |
| // ? 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /** |
| ******************************************************************************* |
| * Copyright (C) 1996-2016, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ******************************************************************************* |
| */ |
| |
| package android.icu.text; |
| |
| import java.text.ParseException; |
| import java.text.CharacterIterator; |
| import android.icu.lang.UScript; |
| |
| /** |
| * <p> |
| * RuleBasedCollator is a concrete subclass of Collator. It allows customization of the Collator via user-specified rule |
| * sets. RuleBasedCollator is designed to be fully compliant to the <a |
| * href="http://www.unicode.org/unicode/reports/tr10/">Unicode Collation Algorithm (UCA)</a> and conforms to ISO 14651. |
| * |
| * <p>A Collator is thread-safe only when frozen. See {{@link #isFrozen()} and {@link android.icu.util.Freezable}. |
| * |
| * <p> |
| * Users are strongly encouraged to read the <a href="https://unicode-org.github.io/icu/userguide/collation">User |
| * Guide</a> for more information about the collation service before using this class. |
| * |
| * <p> |
| * Create a RuleBasedCollator from a locale by calling the getInstance(Locale) factory method in the base class |
| * Collator. Collator.getInstance(Locale) creates a RuleBasedCollator object based on the collation rules defined by the |
| * argument locale. If a customized collation ordering or attributes is required, use the RuleBasedCollator(String) |
| * constructor with the appropriate rules. The customized RuleBasedCollator will base its ordering on the CLDR root collation, while |
| * re-adjusting the attributes and orders of the characters in the specified rule accordingly. |
| * |
| * <p> |
| * RuleBasedCollator provides correct collation orders for most locales supported in ICU. If specific data for a locale |
| * is not available, the orders eventually falls back to the |
| * <a href="http://www.unicode.org/reports/tr35/tr35-collation.html#Root_Collation">CLDR root sort order</a>. |
| * |
| * <p> |
| * For information about the collation rule syntax and details about customization, please refer to the <a |
| * href="https://unicode-org.github.io/icu/userguide/collation/customization">Collation customization</a> |
| * section of the User Guide. |
| * |
| * <p> |
| * <strong>Note</strong> that there are some differences between the Collation rule syntax used in Java and ICU4J: |
| * |
| * <ul> |
| * <li>According to the JDK documentation: <br> |
| * <i>Modifier '!' : 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. |
| * <br> |
| * If a rule is without the modifier '!', the Thai/Lao vowel-consonant swapping is not turned on. |
| * </i> |
| * <br> |
| * ICU4J's RuleBasedCollator does not support turning off the Thai/Lao vowel-consonant swapping, since the UCA clearly |
| * states that it has to be supported to ensure a correct sorting order. If a '!' is encountered, it is ignored.</li> |
| * <li>As mentioned in the documentation of the base class Collator, compatibility decomposition mode is not supported.</li> |
| * </ul> |
| * <p> |
| * <strong>Examples</strong> |
| * <p> |
| * Creating Customized RuleBasedCollators: <blockquote> |
| * |
| * <pre> |
| * String simple = "& a < b < c < d"; |
| * RuleBasedCollator simpleCollator = new RuleBasedCollator(simple); |
| * |
| * 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 < \u00E5 = a\u030A " |
| * + ", \u00C5 = A\u030A ; aa , AA < \u00E6 " |
| * + ", \u00C6 < \u00F8 , \u00D8"; |
| * RuleBasedCollator norwegianCollator = new RuleBasedCollator(norwegian); |
| * </pre> |
| * |
| * </blockquote> |
| * |
| * Concatenating rules to combine <code>Collator</code>s: <blockquote> |
| * |
| * <pre> |
| * // Create an en_US Collator object |
| * RuleBasedCollator en_USCollator = (RuleBasedCollator) |
| * Collator.getInstance(new Locale("en", "US", "")); |
| * // Create a da_DK Collator object |
| * RuleBasedCollator da_DKCollator = (RuleBasedCollator) |
| * Collator.getInstance(new Locale("da", "DK", "")); |
| * // Combine the two |
| * // First, get the collation rules from en_USCollator |
| * String en_USRules = en_USCollator.getRules(); |
| * // Second, get the collation rules from da_DKCollator |
| * String da_DKRules = da_DKCollator.getRules(); |
| * RuleBasedCollator newCollator = |
| * new RuleBasedCollator(en_USRules + da_DKRules); |
| * // newCollator has the combined rules |
| * </pre> |
| * |
| * </blockquote> |
| * |
| * Making changes to an existing RuleBasedCollator to create a new <code>Collator</code> object, by appending changes to |
| * the existing rule: <blockquote> |
| * |
| * <pre> |
| * // Create a new Collator object with additional rules |
| * String addRules = "& C < ch, cH, Ch, CH"; |
| * RuleBasedCollator myCollator = |
| * new RuleBasedCollator(en_USCollator.getRules() + addRules); |
| * // myCollator contains the new rules |
| * </pre> |
| * |
| * </blockquote> |
| * |
| * How to change the order of non-spacing accents: <blockquote> |
| * |
| * <pre> |
| * // old rule with main accents |
| * String oldRules = "= \u0301 ; \u0300 ; \u0302 ; \u0308 " |
| * + "; \u0327 ; \u0303 ; \u0304 ; \u0305 " |
| * + "; \u0306 ; \u0307 ; \u0309 ; \u030A " |
| * + "; \u030B ; \u030C ; \u030D ; \u030E " |
| * + "; \u030F ; \u0310 ; \u0311 ; \u0312 " |
| * + "< 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> |
| * |
| * Putting in a new primary ordering before the default setting, e.g. sort English characters before or after Japanese |
| * characters in the Japanese <code>Collator</code>: <blockquote> |
| * |
| * <pre> |
| * // get en_US Collator rules |
| * RuleBasedCollator en_USCollator |
| * = (RuleBasedCollator)Collator.getInstance(Locale.US); |
| * // add a few Japanese characters to sort before English characters |
| * // suppose the last character before the first base letter 'a' in |
| * // the English collation rule is \u2212 |
| * String jaString = "& \u2212 <\u3041, \u3042 <\u3043, " |
| * + "\u3044"; |
| * RuleBasedCollator myJapaneseCollator |
| * = new RuleBasedCollator(en_USCollator.getRules() + jaString); |
| * </pre> |
| * |
| * </blockquote> |
| * <p> |
| * This class is not subclassable |
| * |
| * @author Syn Wee Quek |
| */ |
| |
| @SuppressWarnings({"unchecked", "deprecation", "all"}) |
| public final class RuleBasedCollator extends android.icu.text.Collator { |
| |
| /** |
| * <p> |
| * Constructor that takes the argument rules for customization. |
| * The collator will be based on the CLDR root collation, with the |
| * attributes and re-ordering of the characters specified in the argument rules. |
| * <p> |
| * See the User Guide's section on <a href="https://unicode-org.github.io/icu/userguide/collation/customization"> |
| * Collation Customization</a> for details on the rule syntax. |
| * |
| * @param rules |
| * the collation rules to build the collation table from. |
| * @exception java.text.ParseException |
| * and IOException thrown. ParseException thrown when argument rules have an invalid syntax. |
| * IOException thrown when an error occurred while reading internal data. |
| */ |
| |
| public RuleBasedCollator(java.lang.String rules) throws java.lang.Exception { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Clones the RuleBasedCollator |
| * |
| * @return a new instance of this RuleBasedCollator object |
| */ |
| |
| public java.lang.Object clone() throws java.lang.CloneNotSupportedException { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Return a CollationElementIterator for the given String. |
| * |
| * @see android.icu.text.CollationElementIterator |
| */ |
| |
| public android.icu.text.CollationElementIterator getCollationElementIterator(java.lang.String source) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Return a CollationElementIterator for the given CharacterIterator. The source iterator's integrity will be |
| * preserved since a new copy will be created for use. |
| * |
| * @see android.icu.text.CollationElementIterator |
| */ |
| |
| public android.icu.text.CollationElementIterator getCollationElementIterator(java.text.CharacterIterator source) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Return a CollationElementIterator for the given UCharacterIterator. The source iterator's integrity will be |
| * preserved since a new copy will be created for use. |
| * |
| * @see android.icu.text.CollationElementIterator |
| */ |
| |
| public android.icu.text.CollationElementIterator getCollationElementIterator(android.icu.text.UCharacterIterator source) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Determines whether the object has been frozen or not. |
| * |
| * <p>An unfrozen Collator is mutable and not thread-safe. |
| * A frozen Collator is immutable and thread-safe. |
| */ |
| |
| public boolean isFrozen() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Freezes the collator. |
| * @return the collator itself. |
| */ |
| |
| public android.icu.text.Collator freeze() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Provides for the clone operation. Any clone is initially unfrozen. |
| */ |
| |
| public android.icu.text.RuleBasedCollator cloneAsThawed() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets whether uppercase characters sort before lowercase characters or vice versa, in strength TERTIARY. The |
| * default mode is false, and so lowercase characters sort before uppercase characters. If true, sort upper case |
| * characters first. |
| * |
| * @param upperfirst |
| * true to sort uppercase characters before lowercase characters, false to sort lowercase characters |
| * before uppercase characters |
| * @see #isLowerCaseFirst |
| * @see #isUpperCaseFirst |
| * @see #setLowerCaseFirst |
| * @see #setCaseFirstDefault |
| */ |
| |
| public void setUpperCaseFirst(boolean upperfirst) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets the orders of lower cased characters to sort before upper cased characters, in strength TERTIARY. The |
| * default mode is false. If true is set, the RuleBasedCollator will sort lower cased characters before the upper |
| * cased ones. Otherwise, if false is set, the RuleBasedCollator will ignore case preferences. |
| * |
| * @param lowerfirst |
| * true for sorting lower cased characters before upper cased characters, false to ignore case |
| * preferences. |
| * @see #isLowerCaseFirst |
| * @see #isUpperCaseFirst |
| * @see #setUpperCaseFirst |
| * @see #setCaseFirstDefault |
| */ |
| |
| public void setLowerCaseFirst(boolean lowerfirst) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets the case first mode to the initial mode set during construction of the RuleBasedCollator. See |
| * setUpperCaseFirst(boolean) and setLowerCaseFirst(boolean) for more details. |
| * |
| * @see #isLowerCaseFirst |
| * @see #isUpperCaseFirst |
| * @see #setLowerCaseFirst(boolean) |
| * @see #setUpperCaseFirst(boolean) |
| */ |
| |
| public void setCaseFirstDefault() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets the alternate handling mode to the initial mode set during construction of the RuleBasedCollator. See |
| * setAlternateHandling(boolean) for more details. |
| * |
| * @see #setAlternateHandlingShifted(boolean) |
| * @see #isAlternateHandlingShifted() |
| */ |
| |
| public void setAlternateHandlingDefault() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets the case level mode to the initial mode set during construction of the RuleBasedCollator. See |
| * setCaseLevel(boolean) for more details. |
| * |
| * @see #setCaseLevel(boolean) |
| * @see #isCaseLevel |
| */ |
| |
| public void setCaseLevelDefault() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets the decomposition mode to the initial mode set during construction of the RuleBasedCollator. See |
| * setDecomposition(int) for more details. |
| * |
| * @see #getDecomposition |
| * @see #setDecomposition(int) |
| */ |
| |
| public void setDecompositionDefault() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets the French collation mode to the initial mode set during construction of the RuleBasedCollator. See |
| * setFrenchCollation(boolean) for more details. |
| * |
| * @see #isFrenchCollation |
| * @see #setFrenchCollation(boolean) |
| */ |
| |
| public void setFrenchCollationDefault() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets the collation strength to the initial mode set during the construction of the RuleBasedCollator. See |
| * setStrength(int) for more details. |
| * |
| * @see #setStrength(int) |
| * @see #getStrength |
| */ |
| |
| public void setStrengthDefault() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Method to set numeric collation to its default value. |
| * |
| * @see #getNumericCollation |
| * @see #setNumericCollation |
| */ |
| |
| public void setNumericCollationDefault() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets the mode for the direction of SECONDARY weights to be used in French collation. The default value is false, |
| * which treats SECONDARY weights in the order they appear. If set to true, the SECONDARY weights will be sorted |
| * backwards. See the section on <a href="https://unicode-org.github.io/icu/userguide/collation/architecture"> |
| * French collation</a> for more information. |
| * |
| * @param flag |
| * true to set the French collation on, false to set it off |
| * @see #isFrenchCollation |
| * @see #setFrenchCollationDefault |
| */ |
| |
| public void setFrenchCollation(boolean flag) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets the alternate handling for QUATERNARY strength to be either shifted or non-ignorable. See the UCA definition |
| * on <a href="http://www.unicode.org/unicode/reports/tr10/#Variable_Weighting">Variable Weighting</a>. This |
| * attribute will only be effective when QUATERNARY strength is set. The default value for this mode is false, |
| * corresponding to the NON_IGNORABLE mode in UCA. In the NON_IGNORABLE mode, the RuleBasedCollator treats all |
| * the code points with non-ignorable primary weights in the same way. If the mode is set to true, the behavior |
| * corresponds to SHIFTED defined in UCA, this causes code points with PRIMARY orders that are equal or below the |
| * variable top value to be ignored in PRIMARY order and moved to the QUATERNARY order. |
| * |
| * @param shifted |
| * true if SHIFTED behavior for alternate handling is desired, false for the NON_IGNORABLE behavior. |
| * @see #isAlternateHandlingShifted |
| * @see #setAlternateHandlingDefault |
| */ |
| |
| public void setAlternateHandlingShifted(boolean shifted) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * <p> |
| * When case level is set to true, an additional weight is formed between the SECONDARY and TERTIARY weight, known |
| * as the case level. The case level is used to distinguish large and small Japanese Kana characters. Case level |
| * could also be used in other situations. For example to distinguish certain Pinyin characters. The default value |
| * is false, which means the case level is not generated. The contents of the case level are affected by the case |
| * first mode. A simple way to ignore accent differences in a string is to set the strength to PRIMARY and enable |
| * case level. |
| * <p> |
| * See the section on <a href="https://unicode-org.github.io/icu/userguide/collation/architecture">case |
| * level</a> for more information. |
| * |
| * @param flag |
| * true if case level sorting is required, false otherwise |
| * @see #setCaseLevelDefault |
| * @see #isCaseLevel |
| */ |
| |
| public void setCaseLevel(boolean flag) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets the decomposition mode of this Collator. Setting this |
| * decomposition attribute with CANONICAL_DECOMPOSITION allows the |
| * Collator to handle un-normalized text properly, producing the |
| * same results as if the text were normalized. If |
| * NO_DECOMPOSITION is set, it is the user's responsibility to |
| * insure that all text is already in the appropriate form before |
| * a comparison or before getting a CollationKey. Adjusting |
| * decomposition mode allows the user to select between faster and |
| * more complete collation behavior. |
| * |
| * <p>Since a great many of the world's languages do not require |
| * text normalization, most locales set NO_DECOMPOSITION as the |
| * default decomposition mode. |
| * |
| * The default decompositon mode for the Collator is |
| * NO_DECOMPOSITON, unless specified otherwise by the locale used |
| * to create the Collator. |
| * |
| * <p>See getDecomposition for a description of decomposition |
| * mode. |
| * |
| * @param decomposition the new decomposition mode |
| * @see #getDecomposition |
| * @see #NO_DECOMPOSITION |
| * @see #CANONICAL_DECOMPOSITION |
| * @throws java.lang.IllegalArgumentException If the given value is not a valid |
| * decomposition mode. |
| */ |
| |
| public void setDecomposition(int decomposition) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Sets this Collator's strength attribute. The strength attribute determines the minimum level of difference |
| * considered significant during comparison. |
| * |
| * <p>See the Collator class description for an example of use. |
| * |
| * @param newStrength |
| * the new strength value. |
| * @see #getStrength |
| * @see #setStrengthDefault |
| * @see #PRIMARY |
| * @see #SECONDARY |
| * @see #TERTIARY |
| * @see #QUATERNARY |
| * @see #IDENTICAL |
| * @exception java.lang.IllegalArgumentException |
| * If the new strength value is not one of PRIMARY, SECONDARY, TERTIARY, QUATERNARY or IDENTICAL. |
| */ |
| |
| public void setStrength(int newStrength) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * <strong>[icu]</strong> Sets the variable top to the top of the specified reordering group. |
| * The variable top determines the highest-sorting character |
| * which is affected by the alternate handling behavior. |
| * If that attribute is set to NON_IGNORABLE, then the variable top has no effect. |
| * @param group one of Collator.ReorderCodes.SPACE, Collator.ReorderCodes.PUNCTUATION, |
| * Collator.ReorderCodes.SYMBOL, Collator.ReorderCodes.CURRENCY; |
| * or Collator.ReorderCodes.DEFAULT to restore the default max variable group |
| * @return this |
| * @see #getMaxVariable |
| */ |
| |
| public android.icu.text.RuleBasedCollator setMaxVariable(int group) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * <strong>[icu]</strong> Returns the maximum reordering group whose characters are affected by |
| * the alternate handling behavior. |
| * @return the maximum variable reordering group. |
| * @see #setMaxVariable |
| */ |
| |
| public int getMaxVariable() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * <strong>[icu]</strong> When numeric collation is turned on, this Collator makes |
| * substrings of digits sort according to their numeric values. |
| * |
| * <p>This is a way to get '100' to sort AFTER '2'. Note that the longest |
| * digit substring that can be treated as a single unit is |
| * 254 digits (not counting leading zeros). If a digit substring is |
| * longer than that, the digits beyond the limit will be treated as a |
| * separate digit substring. |
| * |
| * <p>A "digit" in this sense is a code point with General_Category=Nd, |
| * which does not include circled numbers, roman numerals, etc. |
| * Only a contiguous digit substring is considered, that is, |
| * non-negative integers without separators. |
| * There is no support for plus/minus signs, decimals, exponents, etc. |
| * |
| * @param flag |
| * true to turn numeric collation on and false to turn it off |
| * @see #getNumericCollation |
| * @see #setNumericCollationDefault |
| */ |
| |
| public void setNumericCollation(boolean flag) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @param order the reordering codes to apply to this collator; if this is null or an empty array |
| * then this clears any existing reordering |
| * @throws java.lang.IllegalArgumentException if the reordering codes are malformed in any way (e.g. duplicates, multiple reset codes, overlapping equivalent scripts) |
| * @see #getReorderCodes |
| * @see android.icu.text.Collator#getEquivalentReorderCodes |
| * @see android.icu.text.Collator.ReorderCodes |
| * @see android.icu.lang.UScript |
| */ |
| |
| public void setReorderCodes(int... order) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Gets the collation tailoring rules for this RuleBasedCollator. |
| * Equivalent to String getRules(false). |
| * |
| * <p>On Android, the returned string will be empty unless this instance was |
| * constructed using {@link #RuleBasedCollator(java.lang.String)}. |
| * |
| * @return the collation tailoring rules |
| * @see #getRules(boolean) |
| */ |
| |
| public java.lang.String getRules() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns current rules. |
| * The argument defines whether full rules (root collation + tailored) rules are returned |
| * or just the tailoring. |
| * |
| * <p>The root collation rules are an <i>approximation</i> of the root collator's sort order. |
| * They are almost never used or useful at runtime and can be removed from the data. |
| * See <a href="https://unicode-org.github.io/icu/userguide/collation/customization#building-on-existing-locales">User Guide: |
| * Collation Customization, Building on Existing Locales</a> |
| * |
| * <p>{@link #getRules()} should normally be used instead. |
| * @param fullrules |
| * true if the rules that defines the full set of collation order is required, otherwise false for |
| * returning only the tailored rules |
| * @return the current rules that defines this Collator. |
| * @see #getRules() |
| */ |
| |
| public java.lang.String getRules(boolean fullrules) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Get a UnicodeSet that contains all the characters and sequences tailored in this collator. |
| * |
| * @return a pointer to a UnicodeSet object containing all the code points and sequences that may sort differently |
| * than in the root collator. |
| */ |
| |
| public android.icu.text.UnicodeSet getTailoredSet() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Gets unicode sets containing contractions and/or expansions of a collator |
| * |
| * @param contractions |
| * if not null, set to contain contractions |
| * @param expansions |
| * if not null, set to contain expansions |
| * @param addPrefixes |
| * add the prefix contextual elements to contractions |
| * @throws java.lang.Exception |
| * Throws an exception if any errors occurs. |
| */ |
| |
| public void getContractionsAndExpansions(android.icu.text.UnicodeSet contractions, android.icu.text.UnicodeSet expansions, boolean addPrefixes) throws java.lang.Exception { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * <p> |
| * Get a Collation key for the argument String source from this RuleBasedCollator. |
| * <p> |
| * General recommendation: <br> |
| * If comparison are to be done to the same String multiple times, it would be more efficient to generate |
| * CollationKeys for the Strings and use CollationKey.compareTo(CollationKey) for the comparisons. If the each |
| * Strings are compared to only once, using the method RuleBasedCollator.compare(String, String) will have a better |
| * performance. |
| * <p> |
| * See the class documentation for an explanation about CollationKeys. |
| * |
| * @param source |
| * the text String to be transformed into a collation key. |
| * @return the CollationKey for the given String based on this RuleBasedCollator's collation rules. If the source |
| * String is null, a null CollationKey is returned. |
| * @see android.icu.text.CollationKey |
| * @see #compare(String, String) |
| */ |
| |
| public android.icu.text.CollationKey getCollationKey(java.lang.String source) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns this Collator's strength attribute. The strength attribute |
| * determines the minimum level of difference considered significant. |
| * |
| * <p><strong>[icu] Note:</strong> This can return QUATERNARY strength, which is not supported by the |
| * JDK version. |
| * |
| * <p>See the Collator class description for more details. |
| * |
| * @return this Collator's current strength attribute. |
| * @see #setStrength |
| * @see #PRIMARY |
| * @see #SECONDARY |
| * @see #TERTIARY |
| * @see #QUATERNARY |
| * @see #IDENTICAL |
| */ |
| |
| public int getStrength() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the decomposition mode of this Collator. The decomposition mode |
| * determines how Unicode composed characters are handled. |
| * |
| * <p>See the Collator class description for more details. |
| * |
| * @return the decomposition mode |
| * @see #setDecomposition |
| * @see #NO_DECOMPOSITION |
| * @see #CANONICAL_DECOMPOSITION |
| */ |
| |
| public int getDecomposition() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Return true if an uppercase character is sorted before the corresponding lowercase character. See |
| * setCaseFirst(boolean) for details. |
| * |
| * @see #setUpperCaseFirst |
| * @see #setLowerCaseFirst |
| * @see #isLowerCaseFirst |
| * @see #setCaseFirstDefault |
| * @return true if upper cased characters are sorted before lower cased characters, false otherwise |
| */ |
| |
| public boolean isUpperCaseFirst() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Return true if a lowercase character is sorted before the corresponding uppercase character. See |
| * setCaseFirst(boolean) for details. |
| * |
| * @see #setUpperCaseFirst |
| * @see #setLowerCaseFirst |
| * @see #isUpperCaseFirst |
| * @see #setCaseFirstDefault |
| * @return true lower cased characters are sorted before upper cased characters, false otherwise |
| */ |
| |
| public boolean isLowerCaseFirst() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Checks if the alternate handling behavior is the UCA defined SHIFTED or NON_IGNORABLE. If return value is true, |
| * then the alternate handling attribute for the Collator is SHIFTED. Otherwise if return value is false, then the |
| * alternate handling attribute for the Collator is NON_IGNORABLE See setAlternateHandlingShifted(boolean) for more |
| * details. |
| * |
| * @return true or false |
| * @see #setAlternateHandlingShifted(boolean) |
| * @see #setAlternateHandlingDefault |
| */ |
| |
| public boolean isAlternateHandlingShifted() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Checks if case level is set to true. See setCaseLevel(boolean) for details. |
| * |
| * @return the case level mode |
| * @see #setCaseLevelDefault |
| * @see #isCaseLevel |
| * @see #setCaseLevel(boolean) |
| */ |
| |
| public boolean isCaseLevel() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Checks if French Collation is set to true. See setFrenchCollation(boolean) for details. |
| * |
| * @return true if French Collation is set to true, false otherwise |
| * @see #setFrenchCollation(boolean) |
| * @see #setFrenchCollationDefault |
| */ |
| |
| public boolean isFrenchCollation() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * <strong>[icu]</strong> Gets the variable top value of a Collator. |
| * |
| * @return the variable top primary weight |
| * @see #getMaxVariable |
| */ |
| |
| public int getVariableTop() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Method to retrieve the numeric collation value. When numeric collation is turned on, this Collator generates a |
| * collation key for the numeric value of substrings of digits. This is a way to get '100' to sort AFTER '2' |
| * |
| * @see #setNumericCollation |
| * @see #setNumericCollationDefault |
| * @return true if numeric collation is turned on, false otherwise |
| */ |
| |
| public boolean getNumericCollation() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Retrieves the reordering codes for this collator. |
| * These reordering codes are a combination of UScript codes and ReorderCodes. |
| * @return a copy of the reordering codes for this collator; |
| * if none are set then returns an empty array |
| * @see #setReorderCodes |
| * @see android.icu.text.Collator#getEquivalentReorderCodes |
| */ |
| |
| public int[] getReorderCodes() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| |
| public boolean equals(java.lang.Object obj) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Generates a unique hash code for this RuleBasedCollator. |
| * |
| * @return the unique hash code for this Collator |
| */ |
| |
| public int hashCode() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Compares the source text String to the target text String according to the collation rules, strength and |
| * decomposition mode for this RuleBasedCollator. Returns an integer less than, equal to or greater than zero |
| * depending on whether the source String is less than, equal to or greater than the target String. See the Collator |
| * class description for an example of use. |
| * <p> |
| * General recommendation: <br> |
| * If comparison are to be done to the same String multiple times, it would be more efficient to generate |
| * CollationKeys for the Strings and use CollationKey.compareTo(CollationKey) for the comparisons. If speed |
| * performance is critical and object instantiation is to be reduced, further optimization may be achieved by |
| * generating a simpler key of the form RawCollationKey and reusing this RawCollationKey object with the method |
| * RuleBasedCollator.getRawCollationKey. Internal byte representation can be directly accessed via RawCollationKey |
| * and stored for future use. Like CollationKey, RawCollationKey provides a method RawCollationKey.compareTo for key |
| * comparisons. If the each Strings are compared to only once, using the method RuleBasedCollator.compare(String, |
| * String) will have a better performance. |
| * |
| * @param source |
| * the source text String. |
| * @param target |
| * the target text String. |
| * @return Returns an integer value. Value is less than zero if source is less than target, value is zero if source |
| * and target are equal, value is greater than zero if source is greater than target. |
| * @see android.icu.text.CollationKey |
| * @see #getCollationKey |
| */ |
| |
| public int compare(java.lang.String source, java.lang.String target) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Get the version of this collator object. |
| * |
| * @return the version object associated with this collator |
| */ |
| |
| public android.icu.util.VersionInfo getVersion() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Get the UCA version of this collator object. |
| * |
| * @return the version object associated with this collator |
| */ |
| |
| public android.icu.util.VersionInfo getUCAVersion() { throw new RuntimeException("Stub!"); } |
| } |
| |