1# The set of ICU4J Javadoc replacements. 2 3# This is a version of the upstream UCharacter docs from ICU 58 with some changes: 4# Removal of paragraphs that make no sense on Android. 5--type:android.icu.lang.UCharacter 6/** 7 * {@icuenhanced java.lang.Character}.{@icu _usage_} 8 * 9 * <p>The UCharacter class provides extensions to the {@link java.lang.Character} class. 10 * These extensions provide support for more Unicode properties. 11 * Each ICU release supports the latest version of Unicode available at that time. 12 * 13 * <p>For some time before Java 5 added support for supplementary Unicode code points, 14 * The ICU UCharacter class and many other ICU classes already supported them. 15 * Some UCharacter methods and constants were widened slightly differently than 16 * how the Character class methods and constants were widened later. 17 * In particular, {@link Character#MAX_VALUE} is still a char with the value U+FFFF, 18 * while the {@link UCharacter#MAX_VALUE} is an int with the value U+10FFFF. 19 * 20 * <p>Code points are represented in these API using ints. While it would be 21 * more convenient in Java to have a separate primitive datatype for them, 22 * ints suffice in the meantime. 23 * 24 * <p>Aside from the additions for UTF-16 support, and the updated Unicode 25 * properties, the main differences between UCharacter and Character are: 26 * <ul> 27 * <li> UCharacter is not designed to be a char wrapper and does not have 28 * APIs to which involves management of that single char.<br> 29 * These include: 30 * <ul> 31 * <li> char charValue(), 32 * <li> int compareTo(java.lang.Character, java.lang.Character), etc. 33 * </ul> 34 * <li> UCharacter does not include Character APIs that are deprecated, nor 35 * does it include the Java-specific character information, such as 36 * boolean isJavaIdentifierPart(char ch). 37 * <li> Character maps characters 'A' - 'Z' and 'a' - 'z' to the numeric 38 * values '10' - '35'. UCharacter also does this in digit and 39 * getNumericValue, to adhere to the java semantics of these 40 * methods. New methods unicodeDigit, and 41 * getUnicodeNumericValue do not treat the above code points 42 * as having numeric values. This is a semantic change from ICU4J 1.3.1. 43 * </ul> 44 * <p> 45 * In addition to Java compatibility functions, which calculate derived properties, 46 * this API provides low-level access to the Unicode Character Database. 47 * <p> 48 * Unicode assigns each code point (not just assigned character) values for 49 * many properties. 50 * Most of them are simple boolean flags, or constants from a small enumerated list. 51 * For some properties, values are strings or other relatively more complex types. 52 * <p> 53 * For more information see 54 * <a href="http://www.unicode/org/ucd/">"About the Unicode Character Database"</a> 55 * (http://www.unicode.org/ucd/) 56 * and the <a href="http://www.icu-project.org/userguide/properties.html">ICU 57 * User Guide chapter on Properties</a> 58 * (http://www.icu-project.org/userguide/properties.html). 59 * <p> 60 * There are also functions that provide easy migration from C/POSIX functions 61 * like isblank(). Their use is generally discouraged because the C/POSIX 62 * standards do not define their semantics beyond the ASCII range, which means 63 * that different implementations exhibit very different behavior. 64 * Instead, Unicode properties should be used directly. 65 * <p> 66 * There are also only a few, broad C/POSIX character classes, and they tend 67 * to be used for conflicting purposes. For example, the "isalpha()" class 68 * is sometimes used to determine word boundaries, while a more sophisticated 69 * approach would at least distinguish initial letters from continuation 70 * characters (the latter including combining marks). 71 * (In ICU, BreakIterator is the most sophisticated API for word boundaries.) 72 * Another example: There is no "istitle()" class for titlecase characters. 73 * <p> 74 * ICU 3.4 and later provides API access for all twelve C/POSIX character classes. 75 * ICU implements them according to the Standard Recommendations in 76 * Annex C: Compatibility Properties of UTS #18 Unicode Regular Expressions 77 * (http://www.unicode.org/reports/tr18/#Compatibility_Properties). 78 * <p> 79 * API access for C/POSIX character classes is as follows: 80 * <pre>{@code 81 * - alpha: isUAlphabetic(c) or hasBinaryProperty(c, UProperty.ALPHABETIC) 82 * - lower: isULowercase(c) or hasBinaryProperty(c, UProperty.LOWERCASE) 83 * - upper: isUUppercase(c) or hasBinaryProperty(c, UProperty.UPPERCASE) 84 * - punct: ((1<<getType(c)) & ((1<<DASH_PUNCTUATION)|(1<<START_PUNCTUATION)| 85 * (1<<END_PUNCTUATION)|(1<<CONNECTOR_PUNCTUATION)|(1<<OTHER_PUNCTUATION)| 86 * (1<<INITIAL_PUNCTUATION)|(1<<FINAL_PUNCTUATION)))!=0 87 * - digit: isDigit(c) or getType(c)==DECIMAL_DIGIT_NUMBER 88 * - xdigit: hasBinaryProperty(c, UProperty.POSIX_XDIGIT) 89 * - alnum: hasBinaryProperty(c, UProperty.POSIX_ALNUM) 90 * - space: isUWhiteSpace(c) or hasBinaryProperty(c, UProperty.WHITE_SPACE) 91 * - blank: hasBinaryProperty(c, UProperty.POSIX_BLANK) 92 * - cntrl: getType(c)==CONTROL 93 * - graph: hasBinaryProperty(c, UProperty.POSIX_GRAPH) 94 * - print: hasBinaryProperty(c, UProperty.POSIX_PRINT)}</pre> 95 * <p> 96 * The C/POSIX character classes are also available in UnicodeSet patterns, 97 * using patterns like [:graph:] or \p{graph}. 98 * 99 * <p>{@icunote} There are several ICU (and Java) whitespace functions. 100 * Comparison:<ul> 101 * <li> isUWhiteSpace=UCHAR_WHITE_SPACE: Unicode White_Space property; 102 * most of general categories "Z" (separators) + most whitespace ISO controls 103 * (including no-break spaces, but excluding IS1..IS4 and ZWSP) 104 * <li> isWhitespace: Java isWhitespace; Z + whitespace ISO controls but excluding no-break spaces 105 * <li> isSpaceChar: just Z (including no-break spaces)</ul> 106 * 107 * <p> 108 * This class is not subclassable. 109 * 110 * @author Syn Wee Quek 111 * @stable ICU 2.1 112 * @see com.ibm.icu.lang.UCharacterEnums 113 */ 114-- 115 116# Remove ICU class docs that refer to provisional methods. 117--type:android.icu.util.IslamicCalendar 118/** 119 * <code>IslamicCalendar</code> is a subclass of <code>Calendar</code> 120 * that that implements the Islamic civil and religious calendars. It 121 * is used as the civil calendar in most of the Arab world and the 122 * liturgical calendar of the Islamic faith worldwide. This calendar 123 * is also known as the "Hijri" calendar, since it starts at the time 124 * of Mohammed's emigration (or "hijra") to Medinah on Thursday, 125 * July 15, 622 AD (Julian). 126 * <p> 127 * The Islamic calendar is strictly lunar, and thus an Islamic year of twelve 128 * lunar months does not correspond to the solar year used by most other 129 * calendar systems, including the Gregorian. An Islamic year is, on average, 130 * about 354 days long, so each successive Islamic year starts about 11 days 131 * earlier in the corresponding Gregorian year. 132 * <p> 133 * Each month of the calendar starts when the new moon's crescent is visible 134 * at sunset. However, in order to keep the time fields in this class 135 * synchronized with those of the other calendars and with local clock time, 136 * we treat days and months as beginning at midnight, 137 * roughly 6 hours after the corresponding sunset. 138 * <p> 139 * There are three main variants of the Islamic calendar in existence. The first 140 * is the <em>civil</em> calendar, which uses a fixed cycle of alternating 29- 141 * and 30-day months, with a leap day added to the last month of 11 out of 142 * every 30 years. This calendar is easily calculated and thus predictable in 143 * advance, so it is used as the civil calendar in a number of Arab countries. 144 * This is the default behavior of a newly-created <code>IslamicCalendar</code> 145 * object. 146 * <p> 147 * The Islamic <em>religious</em> calendar and Saudi Arabia's <em>Umm al-Qura</em> 148 * calendar, however, are based on the <em>observation</em> of the crescent moon. 149 * It is thus affected by the position at which the 150 * observations are made, seasonal variations in the time of sunset, the 151 * eccentricities of the moon's orbit, and even the weather at the observation 152 * site. This makes it impossible to calculate in advance, and it causes the 153 * start of a month in the religious calendar to differ from the civil calendar 154 * by up to three days. 155 * <p> 156 * Using astronomical calculations for the position of the sun and moon, the 157 * moon's illumination, and other factors, it is possible to determine the start 158 * of a lunar month with a fairly high degree of certainty. However, these 159 * calculations are extremely complicated and thus slow, so most algorithms, 160 * including the one used here, are only approximations of the true astronomical 161 * calculations. At present, the approximations used in this class are fairly 162 * simplistic; they will be improved in later versions of the code. 163 * <p> 164 * Like the Islamic religious calendar, <em>Umm al-Qura</em> is also based 165 * on the sighting method of the crescent moon but is standardized by Saudi Arabia. 166 * <p> 167 * The fixed-cycle <em>civil</em> calendar is used. 168 * <p> 169 * This class should not be subclassed.</p> 170 * <p> 171 * IslamicCalendar usually should be instantiated using 172 * {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a <code>ULocale</code> 173 * with the tag <code>"@calendar=islamic"</code> or <code>"@calendar=islamic-civil"</code> 174 * or <code>"@calendar=islamic-umalqura"</code>.</p> 175 * 176 * @see com.ibm.icu.util.GregorianCalendar 177 * @see com.ibm.icu.util.Calendar 178 * 179 * @author Laura Werner 180 * @author Alan Liu 181 * @stable ICU 2.8 182 */ 183-- 184 185# Remove @see reference to non-public class TimeUnitAmount. 186--type:android.icu.util.TimeUnit 187/** 188 * Measurement unit for time units. 189 * @see TimeUnit 190 * @author markdavis 191 * @stable ICU 4.0 192 */ 193-- 194 195# Remove references to setDefault* methods that are hidden on Android. 196--type:android.icu.util.TimeZone 197/** 198 * {@icuenhanced java.util.TimeZone}.{@icu _usage_} 199 * 200 * <p><code>TimeZone</code> represents a time zone offset, and also computes daylight 201 * savings. 202 * 203 * <p>Typically, you get a <code>TimeZone</code> using {@link #getDefault()} 204 * which creates a <code>TimeZone</code> based on the time zone where the program 205 * is running. For example, for a program running in Japan, <code>getDefault</code> 206 * creates a <code>TimeZone</code> object based on Japanese Standard Time. 207 * 208 * <p>You can also get a <code>TimeZone</code> using {@link #getTimeZone(String)} 209 * along with a time zone ID. For instance, the time zone ID for the 210 * U.S. Pacific Time zone is "America/Los_Angeles". So, you can get a 211 * U.S. Pacific Time <code>TimeZone</code> object with: 212 * 213 * <blockquote> 214 * <pre> 215 * TimeZone tz = TimeZone.getTimeZone("America/Los_Angeles"); 216 * </pre> 217 * </blockquote> 218 * You can use the {@link #getAvailableIDs()} method to iterate through 219 * all the supported time zone IDs, or getCanonicalID method to check 220 * if a time zone ID is supported or not. You can then choose a 221 * supported ID to get a <code>TimeZone</code>. 222 * If the time zone you want is not represented by one of the 223 * supported IDs, then you can create a custom time zone ID with 224 * the following syntax: 225 * 226 * <blockquote> 227 * <pre> 228 * GMT[+|-]hh[[:]mm] 229 * </pre> 230 * </blockquote> 231 * 232 * For example, you might specify GMT+14:00 as a custom 233 * time zone ID. The <code>TimeZone</code> that is returned 234 * when you specify a custom time zone ID uses the specified 235 * offset from GMT(=UTC) and does not observe daylight saving 236 * time. For example, you might specify GMT+14:00 as a custom 237 * time zone ID to create a TimeZone representing 14 hours ahead 238 * of GMT (with no daylight saving time). In addition, 239 * <code>getCanonicalID</code> can also be used to 240 * normalize a custom time zone ID. 241 * 242 * <p>For compatibility with JDK 1.1.x, some other three-letter time zone IDs 243 * (such as "PST", "CTT", "AST") are also supported. However, <strong>their 244 * use is deprecated</strong> because the same abbreviation is often used 245 * for multiple time zones (for example, "CST" could be U.S. "Central Standard 246 * Time" and "China Standard Time"), and the Java platform can then only 247 * recognize one of them. 248 * 249 * @see Calendar 250 * @see GregorianCalendar 251 * @see SimpleTimeZone 252 * @author Mark Davis, Deborah Goldsmith, Chen-Lieh Huang, Alan Liu 253 * @stable ICU 2.0 254 */ 255-- 256 257# Remove references to {get,set}DefaultTimezoneType methods that are hidden on Android. 258--field:android.icu.util.TimeZone#TIMEZONE_ICU 259/** 260 * <strong>[icu]</strong> A time zone implementation type indicating ICU's own TimeZone used by 261 * <code>getTimeZone</code>. 262 */ 263-- 264 265# Remove references to {get,set}DefaultTimezoneType methods that are hidden on Android. 266--field:android.icu.util.TimeZone#TIMEZONE_JDK 267/** 268 * <strong>[icu]</strong> A time zone implementation type indicating the {@link java.util.TimeZone} 269 * used by <code>getTimeZone</code>. 270 */ 271-- 272 273# Remove ICU class docs that refer to provisional methods. 274--type:android.icu.util.ULocale 275/** 276 * {@icuenhanced java.util.Locale}.{@icu _usage_} 277 * 278 * A class analogous to {@link java.util.Locale} that provides additional 279 * support for ICU protocol. In ICU 3.0 this class is enhanced to support 280 * RFC 3066 language identifiers. 281 * 282 * <p>Many classes and services in ICU follow a factory idiom, in 283 * which a factory method or object responds to a client request with 284 * an object. The request includes a locale (the <i>requested</i> 285 * locale), and the returned object is constructed using data for that 286 * locale. The system may lack data for the requested locale, in 287 * which case the locale fallback mechanism will be invoked until a 288 * populated locale is found (the <i>valid</i> locale). Furthermore, 289 * even when a populated locale is found (the <i>valid</i> locale), 290 * further fallback may be required to reach a locale containing the 291 * specific data required by the service (the <i>actual</i> locale). 292 * 293 * <p>ULocale performs <b>'normalization'</b> and <b>'canonicalization'</b> of locale ids. 294 * Normalization 'cleans up' ICU locale ids as follows: 295 * <ul> 296 * <li>language, script, country, variant, and keywords are properly cased<br> 297 * (lower, title, upper, upper, and lower case respectively)</li> 298 * <li>hyphens used as separators are converted to underscores</li> 299 * <li>three-letter language and country ids are converted to two-letter 300 * equivalents where available</li> 301 * <li>surrounding spaces are removed from keywords and values</li> 302 * <li>if there are multiple keywords, they are put in sorted order</li> 303 * </ul> 304 * Canonicalization additionally performs the following: 305 * <ul> 306 * <li>POSIX ids are converted to ICU format IDs</li> 307 * <li>'grandfathered' 3066 ids are converted to ICU standard form</li> 308 * <li>'PREEURO' and 'EURO' variants are converted to currency keyword form, 309 * with the currency 310 * id appropriate to the country of the locale (for PREEURO) or EUR (for EURO). 311 * </ul> 312 * All ULocale constructors automatically normalize the locale id. To handle 313 * POSIX ids, <code>canonicalize</code> can be called to convert the id 314 * to canonical form, or the <code>canonicalInstance</code> factory method 315 * can be called. 316 * 317 * <p>Note: The <i>actual</i> locale is returned correctly, but the <i>valid</i> 318 * locale is not, in most cases. 319 * 320 * @see java.util.Locale 321 * @author weiv 322 * @author Alan Liu 323 * @author Ram Viswanadha 324 * @stable ICU 2.8 325 */ 326-- 327 328# Remove the reference to ULocale.setDefault() and remove system properties information. 329--method:android.icu.util.ULocale#getDefault() 330/** 331 * Returns the current default ULocale. 332 * <p> 333 * The default ULocale is synchronized to the default Java Locale. This method checks 334 * the current default Java Locale and returns an equivalent ULocale. 335 * 336 * @return the default ULocale. 337 * @stable ICU 2.8 338 */ 339-- 340 341# Removal of sentence containing link to class that is not exposed in Android API 342--type:android.icu.text.UnicodeFilter 343/** 344 * <code>UnicodeFilter</code> defines a protocol for selecting a 345 * subset of the full range (U+0000 to U+FFFF) of Unicode characters. 346 * @stable ICU 2.0 347 */ 348-- 349 350# Document that collation rules are omitted. 351--method:android.icu.text.RuleBasedCollator#getRules() 352/** 353 * Gets the collation tailoring rules for this RuleBasedCollator. 354 * Equivalent to String getRules(false). 355 * 356 * <p>On Android, the returned string will be empty unless this instance was 357 * constructed using {@link #RuleBasedCollator(String)}. 358 * 359 * @return the collation tailoring rules 360 * @see #getRules(boolean) 361 * @stable ICU 2.8 362 */ 363-- 364 365# Deprecate method. 366--method:android.icu.util.Calendar#computeZoneOffset(long,int) 367/** 368 * This method can assume EXTENDED_YEAR has been set. 369 * @param millis milliseconds of the date fields (local midnight millis) 370 * @param millisInDay milliseconds of the time fields; may be out 371 * or range. 372 * @return total zone offset (raw + DST) for the given moment 373 * @stable ICU 2.0 374 * @deprecated This method suffers from a potential integer overflow and may be removed or 375 * changed in a future release. See <a href="http://bugs.icu-project.org/trac/ticket/11632"> 376 * ICU ticket #11632</a> for details. 377 */ 378-- 379 380# Deprecate method. 381--method:android.icu.util.Calendar#computeMillisInDay() 382/** 383 * Compute the milliseconds in the day from the fields. This is a 384 * value from 0 to 23:59:59.999 inclusive, unless fields are out of 385 * range, in which case it can be an arbitrary value. This value 386 * reflects local zone wall time. 387 * @stable ICU 2.0 388 * @deprecated This method suffers from a potential integer overflow and may be removed or 389 * changed in a future release. See <a href="http://bugs.icu-project.org/trac/ticket/11632"> 390 * ICU ticket #11632</a> for details. 391 */ 392-- 393 394# Removal of reference to method that is not exposed in Android API 395--method:android.icu.text.DecimalFormatSymbols#getZeroDigit() 396/** 397 * Returns the character used for zero. Different for Arabic, etc. 398 * @return the character 399 * @stable ICU 2.0 400 */ 401-- 402 403# Removal of reference to method that is not exposed in Android API 404--method:android.icu.text.DecimalFormatSymbols#getDigits() 405/** 406 * Returns the array of characters used as digits, in order from 0 through 9 407 * @return The array 408 * @stable ICU 4.6 409 */ 410-- 411 412# Removal of reference to method that is not exposed in Android API 413--method:android.icu.text.DecimalFormatSymbols#setZeroDigit(char) 414/** 415 * Sets the character used for zero. 416 * <p> 417 * <b>Note:</b> When the specified zeroDigit is a Unicode decimal digit character 418 * (category:Nd) and the number value is 0, then this method propagate digit 1 to 419 * digit 9 by incrementing code point one by one. 420 * 421 * @param zeroDigit the zero character. 422 * @stable ICU 2.0 423 */ 424-- 425 426# Removal of reference to method that is not exposed in Android API 427--method:android.icu.text.DecimalFormatSymbols#getGroupingSeparator() 428/** 429 * Returns the character used for grouping separator. Different for French, etc. 430 * @return the thousands character 431 * @stable ICU 2.0 432 */ 433-- 434 435# Removal of reference to method that is not exposed in Android API 436--method:android.icu.text.DecimalFormatSymbols#getDecimalSeparator() 437/** 438 * Returns the character used for decimal sign. Different for French, etc. 439 * @return the decimal character 440 * @stable ICU 2.0 441 */ 442-- 443 444# Removal of reference to method that is not exposed in Android API 445--method:android.icu.text.DecimalFormatSymbols#getPerMill() 446/** 447 * Returns the character used for mille percent sign. Different for Arabic, etc. 448 * @return the mille percent character 449 * @stable ICU 2.0 450 */ 451-- 452 453# Removal of reference to method that is not exposed in Android API 454--method:android.icu.text.DecimalFormatSymbols#getPercent() 455/** 456 * Returns the character used for percent sign. Different for Arabic, etc. 457 * @return the percent character 458 * @stable ICU 2.0 459 */ 460-- 461 462# Removal of reference to method that is not exposed in Android API 463--method:android.icu.text.DecimalFormatSymbols#getMinusSign() 464/** 465 * Returns the character used to represent minus sign. If no explicit 466 * negative format is specified, one is formed by prefixing 467 * minusSign to the positive format. 468 * @return the minus sign character 469 * @stable ICU 2.0 470 */ 471-- 472 473# Removal of reference to method that is not exposed in Android API 474--method:android.icu.text.DecimalFormatSymbols#getPlusSign() 475/** 476 * {@icu} Returns the localized plus sign. 477 * @return the plus sign, used in localized patterns and formatted 478 * strings 479 * @see #setPlusSign 480 * @see #setMinusSign 481 * @see #getMinusSign 482 * @stable ICU 2.0 483 */ 484-- 485 486# Removal of reference to method that is not exposed in Android API 487--method:android.icu.text.DecimalFormatSymbols#getMonetaryDecimalSeparator() 488/** 489 * Returns the monetary decimal separator. 490 * @return the monetary decimal separator character 491 * @stable ICU 2.0 492 */ 493-- 494 495# Removal of reference to method that is not exposed in Android API 496--method:android.icu.text.DecimalFormatSymbols#getMonetaryGroupingSeparator() 497/** 498 * {@icu} Returns the monetary grouping separator. 499 * @return the monetary grouping separator character 500 * @stable ICU 3.6 501 */ 502-- 503 504# Removal of reference to method that is not exposed in Android API 505--method:android.icu.text.DecimalFormatSymbols#setGroupingSeparator(char) 506/** 507 * Sets the character used for grouping separator. Different for French, etc. 508 * @param groupingSeparator the thousands character 509 * @stable ICU 2.0 510 */ 511-- 512 513# Removal of reference to method that is not exposed in Android API 514--method:android.icu.text.Normalizer#compare(char[],char[],int) 515/** 516 * Compare two strings for canonical equivalence. 517 * Further options include case-insensitive comparison and 518 * code point order (as opposed to code unit order). 519 * Convenience method. 520 * 521 * @param s1 First source string. 522 * @param s2 Second source string. 523 * 524 * @param options A bit set of options: 525 * - FOLD_CASE_DEFAULT or 0 is used for default options: 526 * Case-sensitive comparison in code unit order, and the input strings 527 * are quick-checked for FCD. 528 * 529 * - INPUT_IS_FCD 530 * Set if the caller knows that both s1 and s2 fulfill the FCD 531 * conditions. If not set, the function will quickCheck for FCD 532 * and normalize if necessary. 533 * 534 * - COMPARE_CODE_POINT_ORDER 535 * Set to choose code point order instead of code unit order 536 * 537 * - COMPARE_IGNORE_CASE 538 * Set to compare strings case-insensitively using case folding, 539 * instead of case-sensitively. 540 * If set, then the following case folding options are used. 541 * 542 * @return <0 or 0 or >0 as usual for string comparisons 543 * 544 * @stable ICU 2.8 545 */ 546-- 547 548# Removal of reference to method that is not exposed in Android API 549--method:android.icu.text.Normalizer#compare(char[],int,int,char[],int,int,int) 550/** 551 * Compare two strings for canonical equivalence. 552 * Further options include case-insensitive comparison and 553 * code point order (as opposed to code unit order). 554 * 555 * Canonical equivalence between two strings is defined as their normalized 556 * forms (NFD or NFC) being identical. 557 * This function compares strings incrementally instead of normalizing 558 * (and optionally case-folding) both strings entirely, 559 * improving performance significantly. 560 * 561 * Bulk normalization is only necessary if the strings do not fulfill the 562 * FCD conditions. Only in this case, and only if the strings are relatively 563 * long, is memory allocated temporarily. 564 * For FCD strings and short non-FCD strings there is no memory allocation. 565 * 566 * Semantically, this is equivalent to 567 * strcmp[CodePointOrder](foldCase(NFD(s1)), foldCase(NFD(s2))) 568 * where code point order and foldCase are all optional. 569 * 570 * @param s1 First source character array. 571 * @param s1Start start index of source 572 * @param s1Limit limit of the source 573 * 574 * @param s2 Second source character array. 575 * @param s2Start start index of the source 576 * @param s2Limit limit of the source 577 * 578 * @param options A bit set of options: 579 * - FOLD_CASE_DEFAULT or 0 is used for default options: 580 * Case-sensitive comparison in code unit order, and the input strings 581 * are quick-checked for FCD. 582 * 583 * - INPUT_IS_FCD 584 * Set if the caller knows that both s1 and s2 fulfill the FCD 585 * conditions.If not set, the function will quickCheck for FCD 586 * and normalize if necessary. 587 * 588 * - COMPARE_CODE_POINT_ORDER 589 * Set to choose code point order instead of code unit order 590 * 591 * - COMPARE_IGNORE_CASE 592 * Set to compare strings case-insensitively using case folding, 593 * instead of case-sensitively. 594 * If set, then the following case folding options are used. 595 * 596 * 597 * @return <0 or 0 or >0 as usual for string comparisons 598 * 599 * @stable ICU 2.8 600 */ 601-- 602 603# Removal of reference to method that is not exposed in Android API 604--method:android.icu.text.Normalizer#compare(String,String,int) 605/** 606 * Compare two strings for canonical equivalence. 607 * Further options include case-insensitive comparison and 608 * code point order (as opposed to code unit order). 609 * 610 * Canonical equivalence between two strings is defined as their normalized 611 * forms (NFD or NFC) being identical. 612 * This function compares strings incrementally instead of normalizing 613 * (and optionally case-folding) both strings entirely, 614 * improving performance significantly. 615 * 616 * Bulk normalization is only necessary if the strings do not fulfill the 617 * FCD conditions. Only in this case, and only if the strings are relatively 618 * long, is memory allocated temporarily. 619 * For FCD strings and short non-FCD strings there is no memory allocation. 620 * 621 * Semantically, this is equivalent to 622 * strcmp[CodePointOrder](foldCase(NFD(s1)), foldCase(NFD(s2))) 623 * where code point order and foldCase are all optional. 624 * 625 * @param s1 First source string. 626 * @param s2 Second source string. 627 * 628 * @param options A bit set of options: 629 * - FOLD_CASE_DEFAULT or 0 is used for default options: 630 * Case-sensitive comparison in code unit order, and the input strings 631 * are quick-checked for FCD. 632 * 633 * - INPUT_IS_FCD 634 * Set if the caller knows that both s1 and s2 fulfill the FCD 635 * conditions. If not set, the function will quickCheck for FCD 636 * and normalize if necessary. 637 * 638 * - COMPARE_CODE_POINT_ORDER 639 * Set to choose code point order instead of code unit order 640 * 641 * - COMPARE_IGNORE_CASE 642 * Set to compare strings case-insensitively using case folding, 643 * instead of case-sensitively. 644 * If set, then the following case folding options are used. 645 * 646 * @return <0 or 0 or >0 as usual for string comparisons 647 * 648 * @stable ICU 2.8 649 */ 650-- 651 652# Removal of reference to method that is not exposed in Android API 653--method:android.icu.text.Collator#getCollationKey(String) 654/** 655 * <p> 656 * Transforms the String into a CollationKey suitable for efficient 657 * repeated comparison. The resulting key depends on the collator's 658 * rules, strength and decomposition mode. 659 * 660 * <p>Note that collation keys are often less efficient than simply doing comparison. 661 * For more details, see the ICU User Guide. 662 * 663 * <p>See the CollationKey class documentation for more information. 664 * @param source the string to be transformed into a CollationKey. 665 * @return the CollationKey for the given String based on this Collator's 666 * collation rules. If the source String is null, a null 667 * CollationKey is returned. 668 * @see CollationKey 669 * @see #compare(String, String) 670 * @stable ICU 2.8 671 */ 672-- 673 674# Removal of reference to method that is not exposed in Android API 675--method:android.icu.text.RuleBasedCollator#getCollationKey(String) 676/** 677 * <p> 678 * Get a Collation key for the argument String source from this RuleBasedCollator. 679 * <p> 680 * General recommendation: <br> 681 * If comparison are to be done to the same String multiple times, it would be more efficient to generate 682 * CollationKeys for the Strings and use CollationKey.compareTo(CollationKey) for the comparisons. If the each 683 * Strings are compared to only once, using the method RuleBasedCollator.compare(String, String) will have a better 684 * performance. 685 * <p> 686 * See the class documentation for an explanation about CollationKeys. 687 * 688 * @param source 689 * the text String to be transformed into a collation key. 690 * @return the CollationKey for the given String based on this RuleBasedCollator's collation rules. If the source 691 * String is null, a null CollationKey is returned. 692 * @see CollationKey 693 * @see #compare(String, String) 694 * @stable ICU 2.8 695 */ 696-- 697 698# Removal of reference to method that is not exposed in Android API 699--method:android.icu.util.Calendar#isWeekend(Date) 700/** 701 * {@icu} Returns true if the given date and time is in the weekend in this calendar 702 * system. Equivalent to calling setTime() followed by isWeekend(). Note: This 703 * method changes the time this calendar is set to. 704 * @param date the date and time 705 * @return true if the given date and time is part of the 706 * weekend 707 * @see #isWeekend() 708 * @stable ICU 2.0 709 */ 710-- 711 712# Removal of reference to method that is not exposed in Android API 713--method:android.icu.util.Calendar#isWeekend() 714/** 715 * {@icu} Returns true if this Calendar's current date and time is in the weekend in 716 * this calendar system. 717 * @return true if the given date and time is part of the 718 * weekend 719 * @see #isWeekend(Date) 720 * @stable ICU 2.0 721 */ 722-- 723