</target>
<!-- doclint in V8 is too strict to handle existing html in javadoc -->
+ <!-- doclint options are: html, accessibiltiy, missing, reference, syntax -->
<target name="_setLintV8" unless="is.pre.java8">
- <property name="lintParam" value="-Xdoclint:-html"/>
+ <property name="lintParam" value=""/>
</target>
<target name="_setLintPreV8" if="is.pre.java8">
<property name="lintParam" value=""/>
<echo message="JCite library path: ${jcite.libs}"/>
<echo message="JCite additional source path: ${jcite.addl.src}"/>
<echo message="Custom stylesheet: ${docs.style.sheet}"/>
+ <echo message="lintParam: ${lintParam}"/>
<javadoc
destdir="${doc.dir}"
nodeprecatedlist="true"
</javadoc>
</target>
- <target name="_docsWithoutJCite" unless="jcite.libs">
+ <target name="_docsWithoutJCite" unless="jcite.libs, _setLintV8, _setLintPreV8">
+ <echo message="lintParam: ${lintParam}"/>
<javadoc
destdir="${doc.dir}"
nodeprecatedlist="true"
docencoding="UTF-8"
charset="UTF-8"
bottom="<font size=-1>Copyright (c) ${current.year} IBM Corporation and others.</font>"
- additionalparam="-breakiterator -use -tagletpath ${icu4j.build-tools.jar} -taglet com.ibm.icu.dev.tool.docs.ICUTaglet"
+ additionalparam="${lintParam} -breakiterator -use -tagletpath ${icu4j.build-tools.jar} -taglet com.ibm.icu.dev.tool.docs.ICUTaglet"
link="${icu4j.api.doc.jdk.link}"
source="1.6"
bootclasspath="${java6.bootclasspath}">
/**
*******************************************************************************
-* Copyright (C) 2006-2015, International Business Machines Corporation and
+* Copyright (C) 2006-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* <p>A subclass of java.nio.Charset for providing implementation of ICU's charset converters.
* This API is used to convert codepage or character encoded data to and
* from UTF-16. You can open a converter with {@link Charset#forName} and {@link #forNameICU}. With that
- * converter, you can get its properties, set options, convert your data.</p>
+ * converter, you can get its properties, set options, convert your data.
*
* <p>Since many software programs recognize different converter names for
* different types of converters, there are other functions in this API to
abstract void getUnicodeSetImpl(UnicodeSet setFillIn, int which);
/**
- * <p>Returns the set of Unicode code points that can be converted by an ICU Converter.
- * <p>
- * The current implementation returns only one kind of set (UCNV_ROUNDTRIP_SET): The set of all Unicode code points that can be
+ * Returns the set of Unicode code points that can be converted by an ICU Converter.
+ *
+ * <p>The current implementation returns only one kind of set (UCNV_ROUNDTRIP_SET): The set of all Unicode code points that can be
* roundtrip-converted (converted without any data loss) with the converter This set will not include code points that have fallback
* mappings or are only the result of reverse fallback mappings. See UTR #22 "Character Mapping Markup Language" at <a href="http://www.unicode.org/reports/tr22/">http://www.unicode.org/reports/tr22/</a>
- * <p>* In the future, there may be more UConverterUnicodeSet choices to select sets with different properties.
- * <p>
+ *
+ * <p>In the future, there may be more UConverterUnicodeSet choices to select sets with different properties.
+ *
* <p>This is useful for example for
* <ul><li>checking that a string or document can be roundtrip-converted with a converter,
* without/before actually performing the conversion</li>
/*
*******************************************************************************
- * Copyright (C) 2008-2014, Google Inc, International Business Machines Corporation
+ * Copyright (C) 2008-2016, Google Inc, International Business Machines Corporation
* and others. All Rights Reserved.
*******************************************************************************
*/
* (bucket) of a larger "target" list. That is, each label corresponds to a bucket in
* the target list, where everything in the bucket is greater than or equal to the character
* (according to the locale's collation). Strings can be added to the index;
- * they will be in sorted order in the right bucket.</p>
+ * they will be in sorted order in the right bucket.
* <p>
* The class also supports having buckets for strings before the first (underflow),
* after the last (overflow), and between scripts (inflow). For example, if the index
* is constructed with labels for Russian and English, Greek characters would fall
- * into an inflow bucket between the other two scripts.</p>
+ * into an inflow bucket between the other two scripts.
*
* <p><em>Note:</em> If you expect to have a lot of ASCII or Latin characters
* as well as characters from the user's language,
- * then it is a good idea to call addLabels(ULocale.English).</p>
+ * then it is a good idea to call addLabels(ULocale.English).
*
* <h2>Direct Use</h2>
* <p>The following shows an example of building an index directly.
}
/**
- * Return the number of records in the index: that is, the total number of distinct <name,data> pairs added with addRecord(...), over all the buckets.
+ * Return the number of records in the index: that is, the total number of distinct <name,data> pairs added with addRecord(...), over all the buckets.
*
* @return total number of records in buckets
* @stable ICU 4.8
/**
*******************************************************************************
-* Copyright (C) 1996-2014, International Business Machines Corporation and
+* Copyright (C) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
import com.ibm.icu.impl.coll.UVector32;
/**
- * <p><code>CollationElementIterator</code> is an iterator created by
+ * <code>CollationElementIterator</code> is an iterator created by
* a RuleBasedCollator to walk through a string. The return result of
* each iteration is a 32-bit collation element (CE) that defines the
* ordering priority of the next character or sequence of characters
- * in the source string.</p>
+ * in the source string.
*
* <p>For illustration, consider the following in Slovak and in traditional Spanish collation:
* <blockquote>
* <pre>
- * "ca" -> the first collation element is CE('c') and the second
+ * "ca" -> the first collation element is CE('c') and the second
* collation element is CE('a').
- * "cha" -> the first collation element is CE('ch') and the second
+ * "cha" -> the first collation element is CE('ch') and the second
* collation element is CE('a').
* </pre>
* </blockquote>
* Since the character 'æ' is a composed character of 'a' and 'e', the
* iterator returns two collation elements for the single character 'æ'
*
- * "æb" -> the first collation element is collation_element('a'), the
+ * "æb" -> the first collation element is collation_element('a'), the
* second collation element is collation_element('e'), and the
* third collation element is collation_element('b').
* </pre>
* </blockquote>
- * </p>
*
* <p>For collation ordering comparison, the collation element results
* can not be compared simply by using basic arithmetic operators,
* <a href="http://userguide.icu-project.org/collation/architecture">
* User Guide</a>. An example of using the CollationElementIterator
* for collation ordering comparison is the class
- * {@link com.ibm.icu.text.StringSearch}.</p>
+ * {@link com.ibm.icu.text.StringSearch}.
*
* <p>To construct a CollationElementIterator object, users
* call the method getCollationElementIterator() on a
- * RuleBasedCollator that defines the desired sorting order.</p>
+ * RuleBasedCollator that defines the desired sorting order.
*
* <p> Example:
* <blockquote>
* int primaryOrder = iterator.IGNORABLE;
* while (primaryOrder != iterator.NULLORDER) {
* int order = iterator.next();
- * if (order != iterator.IGNORABLE &&
+ * if (order != iterator.IGNORABLE &&
* order != iterator.NULLORDER) {
* // order is valid, not ignorable and we have not passed the end
* // of the iteration, we do something
* }
* </pre>
* </blockquote>
- * </p>
* <p>
* The method next() returns the collation order of the next character based on
* the comparison level of the collator. The method previous() returns the
* Hence at the next call of next() or previous(), the first or last collation order,
* or collation order at the specified position will be returned. If a change of
* direction is done without one of these calls, the result is undefined.
- * </p>
* <p>
* This class is not subclassable.
- * </p>
* @see Collator
* @see RuleBasedCollator
* @see StringSearch
private RuleBasedCollator rbc_; // aliased
private int otherHalf_;
/**
- * <0: backwards; 0: just after reset() (previous() begins from end);
+ * <0: backwards; 0: just after reset() (previous() begins from end);
* 1: just after setOffset(); >1: forward
*/
private byte dir_;
/**
- * <p>This constant is returned by the iterator in the methods
+ * This constant is returned by the iterator in the methods
* next() and previous() when the end or the beginning of the
* source string has been reached, and there are no more valid
- * collation elements to return.</p>
+ * collation elements to return.
*
- * <p>See class documentation for an example of use.</p>
+ * <p>See class documentation for an example of use.
* @stable ICU 2.8
* @see #next
* @see #previous */
public final static int NULLORDER = 0xffffffff;
/**
- * <p>This constant is returned by the iterator in the methods
+ * This constant is returned by the iterator in the methods
* next() and previous() when a collation element result is to be
- * ignored.</p>
+ * ignored.
*
- * <p>See class documentation for an example of use.</p>
+ * <p>See class documentation for an example of use.
* @stable ICU 2.8
* @see #next
* @see #previous */
}
/**
- * <p>CollationElementIterator constructor. This takes a source
+ * CollationElementIterator constructor. This takes a source
* string and a RuleBasedCollator. The iterator will walk through
* the source string based on the rules defined by the
* collator. If the source string is empty, NULLORDER will be
- * returned on the first call to next().</p>
+ * returned on the first call to next().
*
* @param source the source string.
* @param collator the RuleBasedCollator
// but only contain the part of RBC.equals() related to data and rules.
/**
- * <p>CollationElementIterator constructor. This takes a source
+ * CollationElementIterator constructor. This takes a source
* character iterator and a RuleBasedCollator. The iterator will
* walk through the source string based on the rules defined by
* the collator. If the source string is empty, NULLORDER will be
- * returned on the first call to next().</p>
+ * returned on the first call to next().
*
* @param source the source string iterator.
* @param collator the RuleBasedCollator
}
/**
- * <p>CollationElementIterator constructor. This takes a source
+ * CollationElementIterator constructor. This takes a source
* character iterator and a RuleBasedCollator. The iterator will
* walk through the source string based on the rules defined by
* the collator. If the source string is empty, NULLORDER will be
- * returned on the first call to next().</p>
+ * returned on the first call to next().
*
* @param source the source string iterator.
* @param collator the RuleBasedCollator
}
/**
- * <p>Returns the character offset in the source string
+ * Returns the character offset in the source string
* corresponding to the next collation element. I.e., getOffset()
* returns the position in the source string corresponding to the
* collation element that will be returned by the next call to
* <li> The length of the source string, if iteration has reached
* the end.
*</ul>
- * </p>
+ *
* @return The character offset in the source string corresponding to the
* collation element that will be returned by the next call to
* next() or previous().
}
/**
- * <p>Get the next collation element in the source string.</p>
+ * Get the next collation element in the source string.
*
* <p>This iterator iterates over a sequence of collation elements
* that were built from the string. Because there isn't
* necessarily a one-to-one mapping from characters to collation
* elements, this doesn't mean the same thing as "return the
* collation element [or ordering priority] of the next character
- * in the string".</p>
+ * in the string".
*
* <p>This function returns the collation element that the
* iterator is currently pointing to, and then updates the
- * internal pointer to point to the next element.</p>
+ * internal pointer to point to the next element.
*
* @return the next collation element or NULLORDER if the end of the
* iteration has been reached.
}
/**
- * <p>Get the previous collation element in the source string.</p>
+ * Get the previous collation element in the source string.
*
* <p>This iterator iterates over a sequence of collation elements
* that were built from the string. Because there isn't
* necessarily a one-to-one mapping from characters to collation
* elements, this doesn't mean the same thing as "return the
* collation element [or ordering priority] of the previous
- * character in the string".</p>
+ * character in the string".
*
* <p>This function updates the iterator's internal pointer to
* point to the collation element preceding the one it's currently
* pointing to and then returns that element, while next() returns
- * the current element and then updates the pointer.</p>
+ * the current element and then updates the pointer.
*
* @return the previous collation element, or NULLORDER when the start of
* the iteration has been reached.
}
/**
- * <p> Resets the cursor to the beginning of the string. The next
+ * Resets the cursor to the beginning of the string. The next
* call to next() or previous() will return the first and last
- * collation element in the string, respectively.</p>
+ * collation element in the string, respectively.
*
* <p>If the RuleBasedCollator used by this iterator has had its
* attributes changed, calling reset() will reinitialize the
- * iterator to use the new attributes.</p>
+ * iterator to use the new attributes.
*
* @stable ICU 2.8
*/
}
/**
- * <p> Sets the iterator to point to the collation element
+ * Sets the iterator to point to the collation element
* corresponding to the character at the specified offset. The
* value returned by the next call to next() will be the collation
- * element corresponding to the characters at offset.</p>
+ * element corresponding to the characters at offset.
*
* <p>If offset is in the middle of a contracting character
* sequence, the iterator is adjusted to the start of the
* contracting sequence. This means that getOffset() is not
- * guaranteed to return the same value set by this method.</p>
+ * guaranteed to return the same value set by this method.
*
* <p>If the decomposition mode is on, and offset is in the middle
* of a decomposible range of source text, the iterator may not
* return a correct result for the next forwards or backwards
* iteration. The user must ensure that the offset is not in the
- * middle of a decomposible range.</p>
+ * middle of a decomposible range.
*
* @param newOffset the character offset into the original source string to
* set. Note that this is not an offset into the corresponding
}
/**
- * <p>Set a new source string for iteration, and reset the offset
- * to the beginning of the text.</p>
+ * Set a new source string for iteration, and reset the offset
+ * to the beginning of the text.
*
* @param source the new source string for iteration.
* @stable ICU 2.8
}
/**
- * <p>Set a new source string iterator for iteration, and reset the
+ * Set a new source string iterator for iteration, and reset the
* offset to the beginning of the text.
- * </p>
+ *
* <p>The source iterator's integrity will be preserved since a new copy
- * will be created for use.</p>
+ * will be created for use.
* @param source the new source string iterator for iteration.
* @stable ICU 2.8
*/
}
/**
- * <p>Set a new source string iterator for iteration, and reset the
+ * Set a new source string iterator for iteration, and reset the
* offset to the beginning of the text.
- * </p>
+ *
* @param source the new source string iterator for iteration.
* @stable ICU 2.8
*/
}
/**
- * <p> Returns the maximum length of any expansion sequence that ends with
+ * Returns the maximum length of any expansion sequence that ends with
* the specified collation element. If there is no expansion with this
* collation element as the last element, returns 1.
- * </p>
+ *
* @param ce a collation element returned by previous() or next().
* @return the maximum length of any expansion sequence ending
* with the specified collation element.
/**
*******************************************************************************
-* Copyright (C) 1996-2015, International Business Machines Corporation and
+* Copyright (C) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
import com.ibm.icu.impl.coll.Collation;
/**
- * <p>A <code>CollationKey</code> represents a <code>String</code>
+ * A <code>CollationKey</code> represents a <code>String</code>
* under the rules of a specific <code>Collator</code>
* object. Comparing two <code>CollationKey</code>s returns the
- * relative order of the <code>String</code>s they represent.</p>
+ * relative order of the <code>String</code>s they represent.
*
* <p>Since the rule set of <code>Collator</code>s can differ, the
* sort orders of the same string under two different
* <code>Collator</code>s might differ. Hence comparing
* <code>CollationKey</code>s generated from different
- * <code>Collator</code>s can give incorrect results.</p>
+ * <code>Collator</code>s can give incorrect results.
* <p>Both the method
* <code>CollationKey.compareTo(CollationKey)</code> and the method
* of these two approaches can differ.
* Note that collation keys are often less efficient than simply doing comparison.
* For more details, see the ICU User Guide.
- * </p>
*
* <p>During the construction of a <code>CollationKey</code>, the
* entire source string is examined and processed into a series of
* startup cost when creating the <code>CollationKey</code>, but once
* the key is created, binary comparisons are fast. This approach is
* recommended when the same strings are to be compared over and over
- * again.</p>
+ * again.
*
* <p>On the other hand, implementations of
* <code>Collator.compare(String, String)</code> can examine and
* //...
* <br>
* // Inside body of sort routine, compare keys this way
- * if( keys[i].compareTo( keys[j] ) > 0 )
+ * if( keys[i].compareTo( keys[j] ) > 0 )
* // swap keys[i] and keys[j]
* <br>
* //...
* System.out.println( keys[2].getSourceString() );
* </pre>
* </blockquote>
- * </p>
* <p>
* This class is not subclassable
- * </p>
* @see Collator
* @see RuleBasedCollator
* @author Syn Wee Quek
}
/**
- * <p>Duplicates and returns the value of this CollationKey as a sequence
- * of big-endian bytes terminated by a null.</p>
+ * Duplicates and returns the value of this CollationKey as a sequence
+ * of big-endian bytes terminated by a null.
*
* <p>If two CollationKeys can be legitimately compared, then one can
* compare the byte arrays of each to obtain the same result, e.g.
* int key, targetkey;
* int i = 0;
* do {
- * key = key1[i] & 0xFF;
- * targetkey = key2[i] & 0xFF;
+ * key = key1[i] & 0xFF;
+ * targetkey = key2[i] & 0xFF;
* if (key < targetkey) {
* System.out.println("String 1 is less than string 2");
* return;
* System.out.println("String 1 is more than string 2");
* }
* i ++;
- * } while (key != 0 && targetKey != 0);
+ * } while (key != 0 && targetKey != 0);
*
* System.out.println("Strings are equal.");
* </pre>
- * </p>
+ *
* @return CollationKey value in a sequence of big-endian byte bytes
* terminated by a null.
* @stable ICU 2.8
// public other methods -------------------------------------------------
/**
- * <p>Compare this CollationKey to another CollationKey. The
+ * Compare this CollationKey to another CollationKey. The
* collation rules of the Collator that created this key are
- * applied.</p>
+ * applied.
*
* <p><strong>Note:</strong> Comparison between CollationKeys
* created by different Collators might return incorrect
- * results. See class documentation.</p>
+ * results. See class documentation.
*
* @param target target CollationKey
* @return an integer value. If the value is less than zero this CollationKey
}
/**
- * <p>Compare this CollationKey and the specified Object for
+ * Compare this CollationKey and the specified Object for
* equality. The collation rules of the Collator that created
- * this key are applied.</p>
+ * this key are applied.
*
* <p>See note in compareTo(CollationKey) for warnings about
- * possible incorrect results.</p>
+ * possible incorrect results.
*
* @param target the object to compare to.
* @return true if the two keys compare as equal, false otherwise.
}
/**
- * <p>
- * Compare this CollationKey and the argument target CollationKey for
+ * Compare this CollationKey and the argument target CollationKey for
* equality.
* The collation
* rules of the Collator object which created these objects are applied.
- * </p>
* <p>
* See note in compareTo(CollationKey) for warnings of incorrect results
- * </p>
+ *
* @param target the CollationKey to compare to.
* @return true if two objects are equal, false otherwise.
* @exception NullPointerException is thrown when the argument is null.
}
/**
- * <p>Returns a hash code for this CollationKey. The hash value is calculated
+ * Returns a hash code for this CollationKey. The hash value is calculated
* on the key itself, not the String from which the key was created. Thus
* if x and y are CollationKeys, then x.hashCode(x) == y.hashCode()
* if x.equals(y) is true. This allows language-sensitive comparison in a
* hash table.
- * </p>
+ *
* @return the hash value.
* @stable ICU 2.8
*/
}
/**
- * <p>
- * Produce a bound for the sort order of a given collation key and a
+ * Produces a bound for the sort order of a given collation key and a
* strength level. This API does not attempt to find a bound for the
* CollationKey String representation, hence null will be returned in its
* place.
- * </p>
* <p>
* Resulting bounds can be used to produce a range of strings that are
* between upper and lower bounds. For example, if bounds are produced
* for a sortkey of string "smith", strings between upper and lower
* bounds with primary strength would include "Smith", "SMITH", "sMiTh".
- * </p>
* <p>
* There are two upper bounds that can be produced. If BoundMode.UPPER
* is produced, strings matched would be as above. However, if a bound
* is produced using BoundMode.UPPER_LONG is used, the above example will
* also match "Smithsonian" and similar.
- * </p>
* <p>
* For more on usage, see example in test procedure
* <a href="http://source.icu-project.org/repos/icu/icu4j/trunk/src/com/ibm/icu/dev/test/collator/CollationAPITest.java">
* src/com/ibm/icu/dev/test/collator/CollationAPITest/TestBounds.
* </a>
- * </p>
* <p>
* Collation keys produced may be compared using the <TT>compare</TT> API.
- * </p>
- * @param boundType Mode of bound required. It can be BoundMode.LOWER, which
+ * @param boundType Mode of bound required. It can be BoundMode.LOWER, which
* produces a lower inclusive bound, BoundMode.UPPER, that
* produces upper bound that matches strings of the same
* length or BoundMode.UPPER_LONG that matches strings that
/**
*******************************************************************************
-* Copyright (C) 1996-2015, International Business Machines Corporation and
+* Copyright (C) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
*
* <p>Collator performs locale-sensitive string comparison. A concrete
* subclass, RuleBasedCollator, allows customization of the collation
-* ordering by the use of rule sets.</p>
+* ordering by the use of rule sets.
*
* <p>A Collator is thread-safe only when frozen. See {@link #isFrozen()} and {@link Freezable}.
*
* producing the same results as if the text were normalized in NFD. If
* canonical decomposition is turned off, it is the user's responsibility to
* ensure that all text is already in the appropriate form before performing
-* a comparison or before getting a CollationKey.</p>
+* a comparison or before getting a CollationKey.
*
* <p>For more information about the collation service see the
-* <a href="http://userguide.icu-project.org/collation">User Guide</a>.</p>
+* <a href="http://userguide.icu-project.org/collation">User Guide</a>.
*
* <p>Examples of use
* <pre>
* System.out.println("Error: à\u0325 should be not equals to a\u0325̀ without decomposition");
* }
* </pre>
-* </p>
+*
* @see RuleBasedCollator
* @see CollationKey
* @author Syn Wee Quek
* values of the NFD form of each string are compared, just in case there
* is no difference.
* See class documentation for more explanation.
- * </p>
* <p>
* Note this value is different from JDK's
- * </p>
* @stable ICU 2.8
*/
public final static int IDENTICAL = 15;
* Decomposition mode value. With NO_DECOMPOSITION set, Strings
* will not be decomposed for collation. This is the default
* decomposition setting unless otherwise specified by the locale
- * used to create the Collator.</p>
+ * used to create the Collator.
*
- * <p><strong>Note</strong> this value is different from the JDK's.</p>
+ * <p><strong>Note</strong> this value is different from the JDK's.
* @see #CANONICAL_DECOMPOSITION
* @see #getDecomposition
* @see #setDecomposition
/**
* Decomposition mode value. With CANONICAL_DECOMPOSITION set,
* characters that are canonical variants according to the Unicode standard
- * will be decomposed for collation.</p>
+ * will be decomposed for collation.
*
* <p>CANONICAL_DECOMPOSITION corresponds to Normalization Form D as
* described in <a href="http://www.unicode.org/unicode/reports/tr15/">
* Unicode Technical Report #15</a>.
- * </p>
+ *
* @see #NO_DECOMPOSITION
* @see #getDecomposition
* @see #setDecomposition
/**
* Compares the equality of two Collator objects. Collator objects are equal if they have the same
- * collation (sorting & searching) behavior.
+ * collation (sorting & searching) behavior.
*
* <p>The base class checks for null and for equal types.
* Subclasses should override.
/**
* Sets this Collator's strength attribute. The strength attribute
* determines the minimum level of difference considered significant
- * during comparison.</p>
+ * during comparison.
*
* <p>The base class method does nothing. Subclasses should override it if appropriate.
*
- * <p>See the Collator class description for an example of use.</p>
+ * <p>See the Collator class description for an example of use.
* @param newStrength the new strength value.
* @see #getStrength
* @see #PRIMARY
* 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>
+ * 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.</p>
+ * default decomposition mode.
*
* <p>The base class method does nothing. Subclasses should override it if appropriate.
*
* <p>See getDecomposition for a description of decomposition
- * mode.</p>
+ * mode.
*
* @param decomposition the new decomposition mode
* @see #getDecomposition
* @param isAvailable If non-null, isAvailable[0] will receive and
* output boolean that indicates whether the requested locale was
* 'available' to the collation service. If non-null, isAvailable
- * must have length >= 1.
+ * must have length >= 1.
* @return the locale
* @stable ICU 3.0
*/
/**
* Returns this Collator's strength attribute. The strength attribute
* determines the minimum level of difference considered significant.
- * </p>
* {@icunote} This can return QUATERNARY strength, which is not supported by the
* JDK version.
* <p>
* See the Collator class description for more details.
- * </p>
* <p>The base class method always returns {@link #TERTIARY}.
* Subclasses should override it if appropriate.
*
/**
* Returns the decomposition mode of this Collator. The decomposition mode
* determines how Unicode composed characters are handled.
- * </p>
* <p>
* See the Collator class description for more details.
- * </p>
* <p>The base class method always returns {@link #NO_DECOMPOSITION}.
* Subclasses should override it if appropriate.
*
* 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>
+ *
* @param source the source String.
* @param target the target String.
* @return Returns an integer value. Value is less than zero if source is
/**
* Compares the source Object to the target Object.
- * </p>
+ *
* @param source the source Object.
* @param target the target Object.
* @return Returns an integer value. Value is less than zero if source is
* <p>Note that collation keys are often less efficient than simply doing comparison.
* For more details, see the ICU User Guide.
*
- * <p>See the CollationKey class documentation for more information.</p>
+ * <p>See the CollationKey class documentation for more information.
* @param source the string to be transformed into a CollationKey.
* @return the CollationKey for the given String based on this Collator's
* collation rules. If the source String is null, a null
/**
*******************************************************************************
- * Copyright (C) 1996-2010, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* @param bytesToAdopt the byte array to adopt
* @param size the length of valid data in the byte array
* @throws IndexOutOfBoundsException if bytesToAdopt == null and size != 0, or
- * size < 0, or size > bytesToAdopt.length.
+ * size < 0, or size > bytesToAdopt.length.
* @stable ICU 2.8
*/
public RawCollationKey(byte[] bytesToAdopt, int size)
/**
*******************************************************************************
- * Copyright (C) 1996-2015, International Business Machines Corporation and
+ * Copyright (C) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* 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>
*
* <p>A Collator is thread-safe only when frozen. See {{@link #isFrozen()} and {@link com.ibm.icu.util.Freezable}.
*
* <p>
* Users are strongly encouraged to read the <a href="http://userguide.icu-project.org/collation">User
* Guide</a> for more information about the collation service before using this class.
- * </p>
- *
+ *
* <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>
- *
+ *
* <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>
- *
+ *
* <p>
* For information about the collation rule syntax and details about customization, please refer to the <a
* href="http://userguide.icu-project.org/collation/customization">Collation customization</a> section of the
* User Guide.
- * </p>
- *
+ *
* <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: <i>
- * <p>
- * Modifier '!' : Turns on Thai/Lao vowel-consonant swapping. If this rule is in force when a Thai vowel of the range
+ * <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.
- * </p>
- * <p>
+ * <br>
* If a rule is without the modifier '!', the Thai/Lao vowel-consonant swapping is not turned on.
- * </p>
* </i>
- * <p>
+ * <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.
- * </p>
- * <li>As mentioned in the documentation of the base class Collator, compatibility decomposition mode is not supported.
+ * 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>
* <p>
* Creating Customized RuleBasedCollators: <blockquote>
*
* 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 < "
+ * + "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 "
* // 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, "
+ * String jaString = "& \u2212 <\u3041, \u3042 <\u3043, "
* + "\u3044";
* RuleBasedCollator myJapaneseCollator
* = new RuleBasedCollator(en_USCollator.getRules() + jaString);
* </pre>
*
* </blockquote>
- * </p>
* <p>
* This class is not subclassable
- * </p>
- *
+ *
* @author Syn Wee Quek
* @stable ICU 2.8
*/
* 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>
* <p>
* See the User Guide's section on <a href="http://userguide.icu-project.org/collation/customization">
* Collation Customization</a> for details on the rule syntax.
- * </p>
- *
+ *
* @param rules
* the collation rules to build the collation table from.
* @exception ParseException
* 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>
* <p>
* See the section on <a href="http://userguide.icu-project.org/collation/architecture">case
* level</a> for more information.
- * </p>
- *
+ *
* @param flag
* true if case level sorting is required, false otherwise
* @stable ICU 2.8
* 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>
+ * 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.</p>
+ * 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>
+ * to create the Collator.
*
* <p>See getDecomposition for a description of decomposition
- * mode.</p>
+ * mode.
*
* @param decomposition the new decomposition mode
* @see #getDecomposition
/**
* <p>
* Get a Collation key for the argument String source from this RuleBasedCollator.
- * </p>
* <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>
* <p>
* See the class documentation for an explanation about CollationKeys.
- * </p>
- *
+ *
* @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
/**
* Returns the CEs for the string.
* @param str the string
- * @internal for tests & tools
+ * @internal for tests & tools
* @deprecated This API is ICU internal only.
*/
@Deprecated
* 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>
+ * 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
* 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.
- * </p>
- *
+ *
* @param source
* the source text String.
* @param target
/*
*******************************************************************************
- * Copyright (C) 1996-2015, International Business Machines Corporation and
+ * Copyright (C) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* <p>
* Restriction: <br>
* Currently there are no composite characters that consists of a
- * character with combining class > 0 before a character with combining
+ * character with combining class > 0 before a character with combining
* class == 0. However, if such a character exists in the future,
* <tt>StringSearch</tt> does not guarantee the results for option 1.
* <p>
* <a href=
* "http://source.icu-project.org/repos/icu/icu4j/trunk/src/com/ibm/icu/dev/test/lang/UCharacterCompare.java">
* com.ibm.icu.dev.test.lang.UCharacterCompare</a>
- * </p>
* <p>
* In addition to Java compatibility functions, which calculate derived properties,
* this API provides low-level access to the Unicode Character Database.
- * </p>
* <p>
* Unicode assigns each code point (not just assigned character) values for
* many properties.
* Most of them are simple boolean flags, or constants from a small enumerated list.
* For some properties, values are strings or other relatively more complex types.
- * </p>
* <p>
* For more information see
* <a href="http://www.unicode/org/ucd/">"About the Unicode Character Database"</a>
* and the <a href="http://www.icu-project.org/userguide/properties.html">ICU
* User Guide chapter on Properties</a>
* (http://www.icu-project.org/userguide/properties.html).
- * </p>
* <p>
* There are also functions that provide easy migration from C/POSIX functions
* like isblank(). Their use is generally discouraged because the C/POSIX
* standards do not define their semantics beyond the ASCII range, which means
* that different implementations exhibit very different behavior.
* Instead, Unicode properties should be used directly.
- * </p>
* <p>
* There are also only a few, broad C/POSIX character classes, and they tend
* to be used for conflicting purposes. For example, the "isalpha()" class
* characters (the latter including combining marks).
* (In ICU, BreakIterator is the most sophisticated API for word boundaries.)
* Another example: There is no "istitle()" class for titlecase characters.
- * </p>
* <p>
* ICU 3.4 and later provides API access for all twelve C/POSIX character classes.
* ICU implements them according to the Standard Recommendations in
* Annex C: Compatibility Properties of UTS #18 Unicode Regular Expressions
* (http://www.unicode.org/reports/tr18/#Compatibility_Properties).
- * </p>
* <p>
* API access for C/POSIX character classes is as follows:
* <pre>{@code
* - cntrl: getType(c)==CONTROL
* - graph: hasBinaryProperty(c, UProperty.POSIX_GRAPH)
* - print: hasBinaryProperty(c, UProperty.POSIX_PRINT)}</pre>
- * </p>
* <p>
* The C/POSIX character classes are also available in UnicodeSet patterns,
* using patterns like [:graph:] or \p{graph}.
- * </p>
*
- * {@icunote} There are several ICU (and Java) whitespace functions.
+ * <p>{@icunote} There are several ICU (and Java) whitespace functions.
* Comparison:<ul>
* <li> isUWhiteSpace=UCHAR_WHITE_SPACE: Unicode White_Space property;
* most of general categories "Z" (separators) + most whitespace ISO controls
* (including no-break spaces, but excluding IS1..IS4 and ZWSP)
* <li> isWhitespace: Java isWhitespace; Z + whitespace ISO controls but excluding no-break spaces
* <li> isSpaceChar: just Z (including no-break spaces)</ul>
- * </p>
+ *
* <p>
* This class is not subclassable.
- * </p>
+ *
* @author Syn Wee Quek
* @stable ICU 2.1
* @see com.ibm.icu.lang.UCharacterEnums
* adjust it by looking for the next cased character, and titlecase that one.
* Other characters are lowercased.
*
- * This follows Unicode 4 & 5 section 3.13 Default Case Operations:
+ * This follows Unicode 4 & 5 section 3.13 Default Case Operations:
*
* R3 toTitlecase(X): Find the word boundaries based on Unicode Standard Annex
* #29, "Text Boundaries." Between each pair of word boundaries, find the first
/**
* {@icu} Returns the numeric value for a Unicode code point as defined in the
- * Unicode Character Database.</p>
+ * Unicode Character Database.
* <p>A "double" return type is necessary because some numeric values are
- * fractions, negative, or too large for int.</p>
+ * fractions, negative, or too large for int.
* <p>For characters without any numeric values in the Unicode Character
* Database, this function will return NO_NUMERIC_VALUE.
- * Note: This is different from the Unicode Standard which specifies NaN as the default value.</p>
+ * Note: This is different from the Unicode Standard which specifies NaN as the default value.
* <p><em>API Change:</em> In release 2.2 and prior, this API has a
* return type int and returns -1 when the argument ch does not have a
* corresponding numeric value. This has been changed to synch with ICU4C
- * </p>
+ *
* This corresponds to the ICU4C function u_getNumericValue.
* @param ch Code point to get the numeric value for.
* @return numeric value of ch, or NO_NUMERIC_VALUE if none is defined.
* <em>NOTE:</em> the UCharacterCategory values are <em>not</em> compatible with
* those returned by java.lang.Character.getType. UCharacterCategory values
* match the ones used in ICU4C, while java.lang.Character type
- * values, though similar, skip the value 17.</p>
+ * values, though similar, skip the value 17.
* @param ch code point whose type is to be determined
* @return category which is a value of UCharacterCategory
* @stable ICU 2.1
/**
* Determines if the specified code point is an ISO control character.
* A code point is considered to be an ISO control character if it is in
- * the range \u0000 through \u001F or in the range \u007F through
- * \u009F.<br>
+ * the range \u0000 through \u001F or in the range \u007F through
+ * \u009F.<br>
* Up-to-date Unicode implementation of java.lang.Character.isISOControl()
* @param ch code point to determine if it is an ISO control character
* @return true if code point is a ISO control character
* if it satisfies one of the following criteria:
* <ul>
* <li> It is a Unicode Separator character (categories "Z" = "Zs" or "Zl" or "Zp"), but is not
- * also a non-breaking space (\u00A0 or \u2007 or \u202F).
- * <li> It is \u0009, HORIZONTAL TABULATION.
- * <li> It is \u000A, LINE FEED.
- * <li> It is \u000B, VERTICAL TABULATION.
- * <li> It is \u000C, FORM FEED.
- * <li> It is \u000D, CARRIAGE RETURN.
- * <li> It is \u001C, FILE SEPARATOR.
- * <li> It is \u001D, GROUP SEPARATOR.
- * <li> It is \u001E, RECORD SEPARATOR.
- * <li> It is \u001F, UNIT SEPARATOR.
+ * also a non-breaking space (\u00A0 or \u2007 or \u202F).
+ * <li> It is \u0009, HORIZONTAL TABULATION.
+ * <li> It is \u000A, LINE FEED.
+ * <li> It is \u000B, VERTICAL TABULATION.
+ * <li> It is \u000C, FORM FEED.
+ * <li> It is \u000D, CARRIAGE RETURN.
+ * <li> It is \u001C, FILE SEPARATOR.
+ * <li> It is \u001D, GROUP SEPARATOR.
+ * <li> It is \u001E, RECORD SEPARATOR.
+ * <li> It is \u001F, UNIT SEPARATOR.
* </ul>
*
* This API tries to sync with the semantics of Java's
* {@icu} Returns a name for a valid codepoint. Unlike, getName(int) and
* getName1_0(int), this method will return a name even for codepoints that
* are not assigned a name in UnicodeData.txt.
- * </p>
- * The names are returned in the following order.
+ *
+ * <p>The names are returned in the following order.
* <ul>
* <li> Most current Unicode name if there is any
* <li> Unicode 1.0 name if there is any
/**
* {@icu} <p>Finds a Unicode code point by its most current Unicode name and
- * return its code point value. All Unicode names are in uppercase.</p>
+ * return its code point value. All Unicode names are in uppercase.
* Note calling any methods related to code point names, e.g. get*Name*()
* incurs a one-time initialisation cost to construct the name tables.
* @param name most current Unicode character name whose code point is to
/**
* {@icu} Returns -1.
* <p>Used to find a Unicode character by its version 1.0 Unicode name and return
- * its code point value.</p>
+ * its code point value.
* @param name Unicode 1.0 code point name whose code point is to be
* returned
* @return -1
* {@icu} <p>Find a Unicode character by either its name and return its code
* point value. All Unicode names are in uppercase.
* Extended names are all lowercase except for numbers and are contained
- * within angle brackets.</p>
+ * within angle brackets.
* The names are searched in the following order
* <ul>
* <li> Most current Unicode name if there is any
* <li> Unicode 1.0 name if there is any
* <li> Extended name in the form of
- * "<codepoint_type-codepoint_hex_digits>". E.g. <noncharacter-FFFE>
+ * "<codepoint_type-codepoint_hex_digits>". E.g. <noncharacter-FFFE>
* </ul>
* Note calling any methods related to code point names, e.g. get*Name*()
* incurs a one-time initialisation cost to construct the name tables.
/**
* {@icu} <p>Find a Unicode character by its corrected name alias and return
- * its code point value. All Unicode names are in uppercase.</p>
+ * its code point value. All Unicode names are in uppercase.
* Note calling any methods related to code point names, e.g. get*Name*()
* incurs a one-time initialisation cost to construct the name tables.
* @param name Unicode name alias whose code point is to be returned
}
/**
- * <p>Returns the titlecase version of the argument string.</p>
+ * <p>Returns the titlecase version of the argument string.
* <p>Position for titlecasing is determined by the argument break
* iterator, hence the user can customize his break iterator for
* a specialized titlecasing. In this case only the forward iteration
* needs to be implemented.
* If the break iterator passed in is null, the default Unicode algorithm
* will be used to determine the titlecase positions.
- * </p>
+ *
* <p>Only positions returned by the break iterator will be title cased,
- * character in between the positions will all be in lower case.</p>
- * <p>Casing is dependent on the default locale and context-sensitive</p>
+ * character in between the positions will all be in lower case.
+ * <p>Casing is dependent on the default locale and context-sensitive
* @param str source string to be performed on
* @param breakiter break iterator to determine the positions in which
* the character should be title cased.
}
/**
- * <p>Returns the titlecase version of the argument string.</p>
+ * <p>Returns the titlecase version of the argument string.
* <p>Position for titlecasing is determined by the argument break
* iterator, hence the user can customize his break iterator for
* a specialized titlecasing. In this case only the forward iteration
* needs to be implemented.
* If the break iterator passed in is null, the default Unicode algorithm
* will be used to determine the titlecase positions.
- * </p>
+ *
* <p>Only positions returned by the break iterator will be title cased,
- * character in between the positions will all be in lower case.</p>
- * <p>Casing is dependent on the argument locale and context-sensitive</p>
+ * character in between the positions will all be in lower case.
+ * <p>Casing is dependent on the argument locale and context-sensitive
* @param locale which string is to be converted in
* @param str source string to be performed on
* @param breakiter break iterator to determine the positions in which
}
/**
- * <p>Returns the titlecase version of the argument string.</p>
+ * <p>Returns the titlecase version of the argument string.
* <p>Position for titlecasing is determined by the argument break
* iterator, hence the user can customize his break iterator for
* a specialized titlecasing. In this case only the forward iteration
* needs to be implemented.
* If the break iterator passed in is null, the default Unicode algorithm
* will be used to determine the titlecase positions.
- * </p>
+ *
* <p>Only positions returned by the break iterator will be title cased,
- * character in between the positions will all be in lower case.</p>
- * <p>Casing is dependent on the argument locale and context-sensitive</p>
+ * character in between the positions will all be in lower case.
+ * <p>Casing is dependent on the argument locale and context-sensitive
* @param locale which string is to be converted in
* @param str source string to be performed on
* @param titleIter break iterator to determine the positions in which
}
/**
- * <p>Returns the titlecase version of the argument string.</p>
+ * <p>Returns the titlecase version of the argument string.
* <p>Position for titlecasing is determined by the argument break
* iterator, hence the user can customize his break iterator for
* a specialized titlecasing. In this case only the forward iteration
* needs to be implemented.
* If the break iterator passed in is null, the default Unicode algorithm
* will be used to determine the titlecase positions.
- * </p>
+ *
* <p>Only positions returned by the break iterator will be title cased,
- * character in between the positions will all be in lower case.</p>
- * <p>Casing is dependent on the argument locale and context-sensitive</p>
+ * character in between the positions will all be in lower case.
+ * <p>Casing is dependent on the argument locale and context-sensitive
* @param locale which string is to be converted in
* @param str source string to be performed on
* @param titleIter break iterator to determine the positions in which
}
/**
- * {@icu} <p>Returns the titlecase version of the argument string.</p>
+ * {@icu} <p>Returns the titlecase version of the argument string.
* <p>Position for titlecasing is determined by the argument break
* iterator, hence the user can customize his break iterator for
* a specialized titlecasing. In this case only the forward iteration
* needs to be implemented.
* If the break iterator passed in is null, the default Unicode algorithm
* will be used to determine the titlecase positions.
- * </p>
+ *
* <p>Only positions returned by the break iterator will be title cased,
- * character in between the positions will all be in lower case.</p>
- * <p>Casing is dependent on the argument locale and context-sensitive</p>
+ * character in between the positions will all be in lower case.
+ * <p>Casing is dependent on the argument locale and context-sensitive
* @param locale which string is to be converted in
* @param str source string to be performed on
* @param titleIter break iterator to determine the positions in which
}
/**
- * {@icu} <p>Returns an iterator for character types, iterating over codepoints.</p>
- * Example of use:<br>
+ * {@icu} <p>Returns an iterator for character types, iterating over codepoints.
+ * <p>Example of use:<br>
* <pre>
* RangeValueIterator iterator = UCharacter.getTypeIterator();
* RangeValueIterator.Element element = new RangeValueIterator.Element();
}
/**
- * {@icu} <p>Returns an iterator for character names, iterating over codepoints.</p>
+ * {@icu} <p>Returns an iterator for character names, iterating over codepoints.
* <p>This API only gets the iterator for the modern, most up-to-date
* Unicode names. For older 1.0 Unicode names use get1_0NameIterator() or
- * for extended names use getExtendedNameIterator().</p>
- * Example of use:<br>
+ * for extended names use getExtendedNameIterator().
+ * <p>Example of use:<br>
* <pre>
* ValueIterator iterator = UCharacter.getNameIterator();
* ValueIterator.Element element = new ValueIterator.Element();
* }
* </pre>
* <p>The maximal range which the name iterator iterates is from
- * UCharacter.MIN_VALUE to UCharacter.MAX_VALUE.</p>
+ * UCharacter.MIN_VALUE to UCharacter.MAX_VALUE.
* @return an iterator
* @stable ICU 2.6
*/
/**
* {@icu} Returns an empty iterator.
- * <p>Used to return an iterator for the older 1.0 Unicode character names, iterating over codepoints.</p>
+ * <p>Used to return an iterator for the older 1.0 Unicode character names, iterating over codepoints.
* @return an empty iterator
* @deprecated ICU 49
* @see #getName1_0(int)
}
/**
- * {@icu} <p>Returns an iterator for character names, iterating over codepoints.</p>
+ * {@icu} <p>Returns an iterator for character names, iterating over codepoints.
* <p>This API only gets the iterator for the extended names.
* For modern, most up-to-date Unicode names use getNameIterator() or
- * for older 1.0 Unicode names use get1_0NameIterator().</p>
- * Example of use:<br>
+ * for older 1.0 Unicode names use get1_0NameIterator().
+ * <p>Example of use:<br>
* <pre>
* ValueIterator iterator = UCharacter.getExtendedNameIterator();
* ValueIterator.Element element = new ValueIterator.Element();
}
/**
- * {@icu} Returns the "age" of the code point.</p>
+ * {@icu} Returns the "age" of the code point.
* <p>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.
* <p>This can be useful to avoid emitting code points to receiving
- * processes that do not accept newer characters.</p>
- * <p>The data is from the UCD file DerivedAge.txt.</p>
+ * processes that do not accept newer characters.
+ * <p>The data is from the UCD file DerivedAge.txt.
* @param ch The code point.
* @return the Unicode version number
* @stable ICU 2.6
}
/**
- * {@icu} <p>Check a binary Unicode property for a code point.</p>
+ * {@icu} <p>Check a binary Unicode property for a code point.
* <p>Unicode, especially in version 3.2, defines many more properties
- * than the original set in UnicodeData.txt.</p>
+ * than the original set in UnicodeData.txt.
* <p>This API is intended to reflect Unicode properties as defined in
* the Unicode Character Database (UCD) and Unicode Technical Reports
- * (UTR).</p>
+ * (UTR).
* <p>For details about the properties see
- * <a href=http://www.unicode.org/>http://www.unicode.org/</a>.</p>
+ * <a href=http://www.unicode.org/>http://www.unicode.org/</a>.
* <p>For names of Unicode properties see the UCD file
- * PropertyAliases.txt.</p>
- * <p>This API does not check the validity of the codepoint.</p>
+ * PropertyAliases.txt.
+ * <p>This API does not check the validity of the codepoint.
* <p>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.</p>
+ * not fully available.
* @param ch code point to test.
* @param property selector constant from com.ibm.icu.lang.UProperty,
* identifies which binary property to check.
}
/**
- * {@icu} <p>Check if a code point has the Alphabetic Unicode property.</p>
- * <p>Same as UCharacter.hasBinaryProperty(ch, UProperty.ALPHABETIC).</p>
- * <p>Different from UCharacter.isLetter(ch)!</p>
+ * {@icu} <p>Check if a code point has the Alphabetic Unicode property.
+ * <p>Same as UCharacter.hasBinaryProperty(ch, UProperty.ALPHABETIC).
+ * <p>Different from UCharacter.isLetter(ch)!
* @stable ICU 2.6
* @param ch codepoint to be tested
*/
}
/**
- * {@icu} <p>Check if a code point has the Lowercase Unicode property.</p>
- * <p>Same as UCharacter.hasBinaryProperty(ch, UProperty.LOWERCASE).</p>
- * <p>This is different from UCharacter.isLowerCase(ch)!</p>
+ * {@icu} <p>Check if a code point has the Lowercase Unicode property.
+ * <p>Same as UCharacter.hasBinaryProperty(ch, UProperty.LOWERCASE).
+ * <p>This is different from UCharacter.isLowerCase(ch)!
* @param ch codepoint to be tested
* @stable ICU 2.6
*/
}
/**
- * {@icu} <p>Check if a code point has the Uppercase Unicode property.</p>
- * <p>Same as UCharacter.hasBinaryProperty(ch, UProperty.UPPERCASE).</p>
- * <p>This is different from UCharacter.isUpperCase(ch)!</p>
+ * {@icu} <p>Check if a code point has the Uppercase Unicode property.
+ * <p>Same as UCharacter.hasBinaryProperty(ch, UProperty.UPPERCASE).
+ * <p>This is different from UCharacter.isUpperCase(ch)!
* @param ch codepoint to be tested
* @stable ICU 2.6
*/
}
/**
- * {@icu} <p>Check if a code point has the White_Space Unicode property.</p>
- * <p>Same as UCharacter.hasBinaryProperty(ch, UProperty.WHITE_SPACE).</p>
+ * {@icu} <p>Check if a code point has the White_Space Unicode property.
+ * <p>Same as UCharacter.hasBinaryProperty(ch, UProperty.WHITE_SPACE).
* <p>This is different from both UCharacter.isSpace(ch) and
- * UCharacter.isWhitespace(ch)!</p>
+ * UCharacter.isWhitespace(ch)!
* @param ch codepoint to be tested
* @stable ICU 2.6
*/
/**
* {@icu} <p>Returns the property value for an Unicode property type of a code point.
- * Also returns binary and mask property values.</p>
+ * Also returns binary and mask property values.
* <p>Unicode, especially in version 3.2, defines many more properties than
- * the original set in UnicodeData.txt.</p>
+ * the original set in UnicodeData.txt.
* <p>The properties APIs are 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/.</p>
+ * http://www.unicode.org/.
* <p>For names of Unicode properties see the UCD file PropertyAliases.txt.
- * </p>
+ *
* <pre>
* Sample usage:
* int ea = UCharacter.getIntPropertyValue(c, UProperty.EAST_ASIAN_WIDTH);
package com.ibm.icu.lang;
/**
- * <p>Selection constants for Unicode properties. </p>
- * <p>These constants are used in functions like
- * UCharacter.hasBinaryProperty(int) to select one of the Unicode properties.
- * </p>
- * <p>The properties APIs are intended to reflect Unicode properties as
- * defined in the Unicode Character Database (UCD) and Unicode Technical
- * Reports (UTR).</p>
+ * <p>Selection constants for Unicode properties.
+ * <p>These constants are used in functions like
+ * UCharacter.hasBinaryProperty(int) to select one of the Unicode properties.
+ *
+ * <p>The properties APIs are intended to reflect Unicode properties as
+ * defined in the Unicode Character Database (UCD) and Unicode Technical
+ * Reports (UTR).
* <p>For details about the properties see <a href=http://www.unicode.org>
- * http://www.unicode.org</a>.</p>
+ * http://www.unicode.org</a>.
* <p>For names of Unicode properties see the UCD file PropertyAliases.txt.
- * </p>
- * <p>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. Check UCharacter.getUnicodeVersion() to be sure.</p>
+ *
+ * <p>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. Check UCharacter.getUnicodeVersion() to be sure.
* @author Syn Wee Quek
* @stable ICU 2.6
* @see com.ibm.icu.lang.UCharacter
@Deprecated
public static final int UNDEFINED = -1;
- /**
- * <p>Binary property Alphabetic. </p>
- * <p>Property for UCharacter.isUAlphabetic(), different from the property
- * in UCharacter.isalpha().</p>
- * <p>Lu + Ll + Lt + Lm + Lo + Nl + Other_Alphabetic.</p>
+ /**
+ * <p>Binary property Alphabetic.
+ * <p>Property for UCharacter.isUAlphabetic(), different from the property
+ * in UCharacter.isalpha().
+ * <p>Lu + Ll + Lt + Lm + Lo + Nl + Other_Alphabetic.
* @stable ICU 2.6
- */
- public static final int ALPHABETIC = 0;
+ */
+ public static final int ALPHABETIC = 0;
- /**
- * First constant for binary Unicode properties.
+ /**
+ * First constant for binary Unicode properties.
* @stable ICU 2.6
- */
+ */
public static final int BINARY_START = ALPHABETIC;
- /**
+ /**
* Binary property ASCII_Hex_Digit (0-9 A-F a-f).
* @stable ICU 2.6
- */
- public static final int ASCII_HEX_DIGIT = 1;
+ */
+ public static final int ASCII_HEX_DIGIT = 1;
- /**
- * <p>Binary property Bidi_Control.</p>
+ /**
+ * <p>Binary property Bidi_Control.
* <p>Format controls which have specific functions in the Bidi Algorithm.
- * </p>
+ *
* @stable ICU 2.6
- */
- public static final int BIDI_CONTROL = 2;
+ */
+ public static final int BIDI_CONTROL = 2;
- /**
- * <p>Binary property Bidi_Mirrored.</p>
- * <p>Characters that may change display in RTL text.</p>
- * <p>Property for UCharacter.isMirrored().</p>
- * <p>See Bidi Algorithm; UTR 9.</p>
+ /**
+ * <p>Binary property Bidi_Mirrored.
+ * <p>Characters that may change display in RTL text.
+ * <p>Property for UCharacter.isMirrored().
+ * <p>See Bidi Algorithm; UTR 9.
* @stable ICU 2.6
- */
- public static final int BIDI_MIRRORED = 3;
+ */
+ public static final int BIDI_MIRRORED = 3;
- /**
- * <p>Binary property Dash.</p>
- * <p>Variations of dashes.</p>
+ /**
+ * <p>Binary property Dash.
+ * <p>Variations of dashes.
* @stable ICU 2.6
- */
- public static final int DASH = 4;
+ */
+ public static final int DASH = 4;
- /**
+ /**
* <p>Binary property Default_Ignorable_Code_Point (new).
- * </p>
+ *
* <p>Property that indicates codepoint is ignorable in most processing.
- * </p>
- * <p>Codepoints (2060..206F, FFF0..FFFB, E0000..E0FFF) +
- * Other_Default_Ignorable_Code_Point + (Cf + Cc + Cs - White_Space)</p>
+ *
+ * <p>Codepoints (2060..206F, FFF0..FFFB, E0000..E0FFF) +
+ * Other_Default_Ignorable_Code_Point + (Cf + Cc + Cs - White_Space)
* @stable ICU 2.6
- */
- public static final int DEFAULT_IGNORABLE_CODE_POINT = 5;
+ */
+ public static final int DEFAULT_IGNORABLE_CODE_POINT = 5;
- /**
- * <p>Binary property Deprecated (new).</p>
- * <p>The usage of deprecated characters is strongly discouraged.</p>
+ /**
+ * <p>Binary property Deprecated (new).
+ * <p>The usage of deprecated characters is strongly discouraged.
* @stable ICU 2.6
- */
- public static final int DEPRECATED = 6;
+ */
+ public static final int DEPRECATED = 6;
- /**
- * <p>Binary property Diacritic.</p>
- * <p>Characters that linguistically modify the meaning of another
- * character to which they apply.</p>
+ /**
+ * <p>Binary property Diacritic.
+ * <p>Characters that linguistically modify the meaning of another
+ * character to which they apply.
* @stable ICU 2.6
- */
- public static final int DIACRITIC = 7;
+ */
+ public static final int DIACRITIC = 7;
- /**
- * <p>Binary property Extender.</p>
+ /**
+ * <p>Binary property Extender.
* <p>Extend the value or shape of a preceding alphabetic character, e.g.
- * length and iteration marks.</p>
+ * length and iteration marks.
* @stable ICU 2.6
- */
- public static final int EXTENDER = 8;
+ */
+ public static final int EXTENDER = 8;
- /**
- * <p>Binary property Full_Composition_Exclusion.</p>
- * <p>CompositionExclusions.txt + Singleton Decompositions +
- * Non-Starter Decompositions.</p>
+ /**
+ * <p>Binary property Full_Composition_Exclusion.
+ * <p>CompositionExclusions.txt + Singleton Decompositions +
+ * Non-Starter Decompositions.
* @stable ICU 2.6
- */
- public static final int FULL_COMPOSITION_EXCLUSION = 9;
+ */
+ public static final int FULL_COMPOSITION_EXCLUSION = 9;
- /**
- * <p>Binary property Grapheme_Base (new).</p>
- * <p>For programmatic determination of grapheme cluster boundaries.
- * [0..10FFFF]-Cc-Cf-Cs-Co-Cn-Zl-Zp-Grapheme_Link-Grapheme_Extend-CGJ</p>
+ /**
+ * <p>Binary property Grapheme_Base (new).
+ * <p>For programmatic determination of grapheme cluster boundaries.
+ * [0..10FFFF]-Cc-Cf-Cs-Co-Cn-Zl-Zp-Grapheme_Link-Grapheme_Extend-CGJ
* @stable ICU 2.6
- */
- public static final int GRAPHEME_BASE = 10;
+ */
+ public static final int GRAPHEME_BASE = 10;
- /**
- * <p>Binary property Grapheme_Extend (new).</p>
- * <p>For programmatic determination of grapheme cluster boundaries.</p>
- * <p>Me+Mn+Mc+Other_Grapheme_Extend-Grapheme_Link-CGJ</p>
+ /**
+ * <p>Binary property Grapheme_Extend (new).
+ * <p>For programmatic determination of grapheme cluster boundaries.
+ * <p>Me+Mn+Mc+Other_Grapheme_Extend-Grapheme_Link-CGJ
* @stable ICU 2.6
- */
- public static final int GRAPHEME_EXTEND = 11;
+ */
+ public static final int GRAPHEME_EXTEND = 11;
- /**
- * <p>Binary property Grapheme_Link (new).</p>
- * <p>For programmatic determination of grapheme cluster boundaries.</p>
+ /**
+ * <p>Binary property Grapheme_Link (new).
+ * <p>For programmatic determination of grapheme cluster boundaries.
* @stable ICU 2.6
- */
- public static final int GRAPHEME_LINK = 12;
+ */
+ public static final int GRAPHEME_LINK = 12;
- /**
- * <p>Binary property Hex_Digit.</p>
- * <p>Characters commonly used for hexadecimal numbers.</p>
+ /**
+ * <p>Binary property Hex_Digit.
+ * <p>Characters commonly used for hexadecimal numbers.
* @stable ICU 2.6
- */
- public static final int HEX_DIGIT = 13;
+ */
+ public static final int HEX_DIGIT = 13;
- /**
- * <p>Binary property Hyphen.</p>
+ /**
+ * <p>Binary property Hyphen.
* <p>Dashes used to mark connections between pieces of words, plus the
- * Katakana middle dot.</p>
+ * Katakana middle dot.
* @stable ICU 2.6
*/
public static final int HYPHEN = 14;
/**
- * <p>Binary property ID_Continue.</p>
- * <p>Characters that can continue an identifier.</p>
- * <p>ID_Start+Mn+Mc+Nd+Pc</p>
+ * <p>Binary property ID_Continue.
+ * <p>Characters that can continue an identifier.
+ * <p>ID_Start+Mn+Mc+Nd+Pc
* @stable ICU 2.6
*/
public static final int ID_CONTINUE = 15;
/**
- * <p>Binary property ID_Start.</p>
- * <p>Characters that can start an identifier.</p>
- * <p>Lu+Ll+Lt+Lm+Lo+Nl</p>
+ * <p>Binary property ID_Start.
+ * <p>Characters that can start an identifier.
+ * <p>Lu+Ll+Lt+Lm+Lo+Nl
* @stable ICU 2.6
*/
public static final int ID_START = 16;
/**
- * <p>Binary property Ideographic.</p>
- * <p>CJKV ideographs.</p>
+ * <p>Binary property Ideographic.
+ * <p>CJKV ideographs.
* @stable ICU 2.6
*/
public static final int IDEOGRAPHIC = 17;
/**
- * <p>Binary property IDS_Binary_Operator (new).</p>
+ * <p>Binary property IDS_Binary_Operator (new).
* <p>For programmatic determination of Ideographic Description Sequences.
- * </p>
+ *
* @stable ICU 2.6
*/
public static final int IDS_BINARY_OPERATOR = 18;
/**
- * <p>Binary property IDS_Trinary_Operator (new).</p>
- * <p?For programmatic determination of Ideographic Description
- * Sequences.</p>
+ * <p>Binary property IDS_Trinary_Operator (new).
+ * <p>For programmatic determination of Ideographic Description
+ * Sequences.
* @stable ICU 2.6
*/
public static final int IDS_TRINARY_OPERATOR = 19;
/**
- * <p>Binary property Join_Control.</p>
- * <p>Format controls for cursive joining and ligation.</p>
+ * <p>Binary property Join_Control.
+ * <p>Format controls for cursive joining and ligation.
* @stable ICU 2.6
*/
public static final int JOIN_CONTROL = 20;
/**
- * <p>Binary property Logical_Order_Exception (new).</p>
+ * <p>Binary property Logical_Order_Exception (new).
* <p>Characters that do not use logical order and require special
- * handling in most processing.</p>
+ * handling in most processing.
* @stable ICU 2.6
*/
public static final int LOGICAL_ORDER_EXCEPTION = 21;
/**
- * <p>Binary property Lowercase.</p>
+ * <p>Binary property Lowercase.
* <p>Same as UCharacter.isULowercase(), different from
- * UCharacter.islower().</p>
- * <p>Ll+Other_Lowercase</p>
+ * UCharacter.islower().
+ * <p>Ll+Other_Lowercase
* @stable ICU 2.6
*/
public static final int LOWERCASE = 22;
- /** <p>Binary property Math.</p>
- * <p>Sm+Other_Math</p>
+ /** <p>Binary property Math.
+ * <p>Sm+Other_Math
* @stable ICU 2.6
*/
public static final int MATH = 23;
/**
- * <p>Binary property Noncharacter_Code_Point.</p>
+ * <p>Binary property Noncharacter_Code_Point.
* <p>Code points that are explicitly defined as illegal for the encoding
- * of characters.</p>
+ * of characters.
* @stable ICU 2.6
*/
public static final int NONCHARACTER_CODE_POINT = 24;
/**
- * <p>Binary property Quotation_Mark.</p>
+ * <p>Binary property Quotation_Mark.
* @stable ICU 2.6
*/
public static final int QUOTATION_MARK = 25;
/**
- * <p>Binary property Radical (new).</p>
+ * <p>Binary property Radical (new).
* <p>For programmatic determination of Ideographic Description
- * Sequences.</p>
+ * Sequences.
* @stable ICU 2.6
*/
public static final int RADICAL = 26;
/**
- * <p>Binary property Soft_Dotted (new).</p>
- * <p>Characters with a "soft dot", like i or j.</p>
- * <p>An accent placed on these characters causes the dot to disappear.</p>
+ * <p>Binary property Soft_Dotted (new).
+ * <p>Characters with a "soft dot", like i or j.
+ * <p>An accent placed on these characters causes the dot to disappear.
* @stable ICU 2.6
*/
public static final int SOFT_DOTTED = 27;
/**
- * <p>Binary property Terminal_Punctuation.</p>
+ * <p>Binary property Terminal_Punctuation.
* <p>Punctuation characters that generally mark the end of textual
- * units.</p>
+ * units.
* @stable ICU 2.6
*/
public static final int TERMINAL_PUNCTUATION = 28;
/**
- * <p>Binary property Unified_Ideograph (new).</p>
+ * <p>Binary property Unified_Ideograph (new).
* <p>For programmatic determination of Ideographic Description
- * Sequences.</p>
+ * Sequences.
* @stable ICU 2.6
*/
public static final int UNIFIED_IDEOGRAPH = 29;
/**
- * <p>Binary property Uppercase.</p>
+ * <p>Binary property Uppercase.
* <p>Same as UCharacter.isUUppercase(), different from
- * UCharacter.isUpperCase().</p>
- * <p>Lu+Other_Uppercase</p>
+ * UCharacter.isUpperCase().
+ * <p>Lu+Other_Uppercase
* @stable ICU 2.6
*/
public static final int UPPERCASE = 30;
/**
- * <p>Binary property White_Space.</p>
+ * <p>Binary property White_Space.
* <p>Same as UCharacter.isUWhiteSpace(), different from
- * UCharacter.isSpace() and UCharacter.isWhitespace().</p>
- * Space characters+TAB+CR+LF-ZWSP-ZWNBSP</p>
+ * UCharacter.isSpace() and UCharacter.isWhitespace().
+ * Space characters+TAB+CR+LF-ZWSP-ZWNBSP
* @stable ICU 2.6
*/
public static final int WHITE_SPACE = 31;
/**
- * <p>Binary property XID_Continue.</p>
+ * <p>Binary property XID_Continue.
* <p>ID_Continue modified to allow closure under normalization forms
- * NFKC and NFKD.</p>
+ * NFKC and NFKD.
* @stable ICU 2.6
*/
public static final int XID_CONTINUE = 32;
/**
- * <p>Binary property XID_Start.</p>
+ * <p>Binary property XID_Start.
* <p>ID_Start modified to allow closure under normalization forms NFKC
- * and NFKD.</p>
+ * and NFKD.
* @stable ICU 2.6
*/
public static final int XID_START = 33;
/**
- * <p>Binary property Case_Sensitive.</p>
+ * <p>Binary property Case_Sensitive.
* <p>Either the source of a case
* mapping or _in_ the target of a case mapping. Not the same as
- * the general category Cased_Letter.</p>
+ * the general category Cased_Letter.
* @stable ICU 2.6
*/
public static final int CASE_SENSITIVE = 34;
/**
*******************************************************************************
- * Copyright (C) 2001-2015 International Business Machines Corporation and
+ * Copyright (C) 2001-2016 International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* </ul>
* In other words, if the return value is non-negative, it is c's single Script code
* and the set contains exactly this Script code.
- * If the return value is -n, then the set contains c's n>=2 Script_Extensions script codes.
+ * If the return value is -n, then the set contains c's n>=2 Script_Extensions script codes.
*
* <p>Some characters are commonly used in multiple scripts.
* For more information, see UAX #24: http://www.unicode.org/reports/tr24/.
/* ------------------------------------------------------------------ */
/* BigDecimal -- Decimal arithmetic for Java */
/* ------------------------------------------------------------------ */
-/* Copyright IBM Corporation, 1996-2011. All Rights Reserved. */
+/* Copyright IBM Corporation, 1996-2016. All Rights Reserved. */
/* */
/* The BigDecimal class provides immutable arbitrary-precision */
/* floating point (including integer) decimal numbers. */
* results in <code>3.33333333E-11</code> instead of <code>0.0000000000333333333</code>.
* <p>
* The form of the exponential notation (scientific or engineering) is determined by the <code>form</code> setting.
- * <eul>
+ * </ul>
* <p>
* The names of methods in this class follow the conventions established by <code>java.lang.Number</code>,
* <code>java.math.BigInteger</code>, and <code>java.math.BigDecimal</code> in Java 1.1 and Java 1.2.
* <p>
* Once constructed, this may become shared between several BigDecimal objects, so must not be altered.
* <p>
- * For efficiency (speed), this is a byte array, with each byte taking a value of 0 -> 9.
+ * For efficiency (speed), this is a byte array, with each byte taking a value of 0 -> 9.
* <p>
* If the first byte is 0 then the value of the number is zero (and mant.length=1, except when constructed from a
* plain number, for example, 0.000).
* </pre>
* <p>
* (Exponential notation means that the number includes an optional sign and a power of ten following an
- * '</code>E</code>' that indicates how the decimal point will be shifted. Thus the <code>"4E+9"</code> above is
+ * '<code>E</code>' that indicates how the decimal point will be shifted. Thus the <code>"4E+9"</code> above is
* just a short way of writing <code>4000000000</code>, and the <code>"0.73e-7"</code> is short for <code>
* 0.000000073</code>.)
* <p>
* the single digit 0, and if non-zero it will have an exponent unless that exponent would be 0. The exponent must
* fit in nine digits both before and after it is expressed in scientific notation.
* <p>
- * Any digits in the parameter must be decimal; that is, <code>Character.digit(c, 10)</code> (where </code>c</code>
+ * Any digits in the parameter must be decimal; that is, <code>Character.digit(c, 10)</code> (where <code>c</code>
* is the character in question) would not return -1.
*
* @param string The <code>String</code> to be converted.
/**
* Returns a <code>BigDecimal</code> whose value is <code>this*rhs</code>.
* <p>
- * Implements the multiplication (<b><code> </code></b>) operator (as defined in the decimal documentation, see
+ * Implements the multiplication (<b><code>*</code></b>) operator (as defined in the decimal documentation, see
* {@link BigDecimal class header}), and returns the result as a <code>BigDecimal</code> object.
*
* @param rhs The <code>BigDecimal</code> for the right hand side of the multiplication.
/**
* Returns a <code>BigDecimal</code> whose value is <code>this**rhs</code>.
* <p>
- * Implements the power (<b><code> </code></b>) operator (as defined in the decimal documentation, see
+ * Implements the power (<b><code>^</code></b>) operator (as defined in the decimal documentation, see
* {@link BigDecimal class header}), and returns the result as a <code>BigDecimal</code> object.
* <p>
* The first parameter is the power to which the <code>this</code> will be raised; it must be in the range
* <code>explaces</code> must be a positive number; it sets the number of places (digits after the sign of the
* exponent) to be used for any exponent part, the default (when <code>explaces</code> is -1) being to use as many
* as are needed. If <code>explaces</code> is not -1, space is always reserved for an exponent; if one is not needed
- * (for example, if the exponent will be 0) then <code>explaces</code>+2 blanks are appended to the result. <!--
- * (This preserves vertical alignment of similarly formatted numbers in a monospace font.) --> If <code>explaces
+ * (for example, if the exponent will be 0) then <code>explaces</code>+2 blanks are appended to the result.
+ * (This preserves vertical alignment of similarly formatted numbers in a monospace font.) If <code>explaces
* </code> is not -1 and is not large enough to contain the exponent, an exception is thrown.
* <p>
* <code>exdigits</code> sets the trigger point for use of exponential notation. If, before any rounding, the number
* Some of the API methods provide access to "runs". Such a
* "run" is defined as a sequence of characters that are at the same
* embedding level after performing the Bidi algorithm.
- * <p>
*
* <h3>Basic concept: paragraph</h3>
* A piece of text can be divided into several paragraphs by characters
*
* <p>
* The basic assumptions are:
- * </p>
+ *
* <ul>
* <li>Rendering is done from left to right on a horizontal line.</li>
* <li>A run of single-style, unidirectional text can be rendered at once.
* // iterate over style runs
* if (direction == Bidi.LTR) {
* int styleLimit;
- * for (i = 0; i < styleRunCount; ++i) {
+ * for (i = 0; i < styleRunCount; ++i) {
* styleLimit = styleRuns[i].limit;
- * if (start < styleLimit) {
- * if (styleLimit > limit) {
+ * if (start < styleLimit) {
+ * if (styleLimit > limit) {
* styleLimit = limit;
* }
* renderRun(text, start, styleLimit,
* } else {
* int styleStart;
*
- * for (i = styleRunCount-1; i >= 0; --i) {
- * if (i > 0) {
+ * for (i = styleRunCount-1; i >= 0; --i) {
+ * if (i > 0) {
* styleStart = styleRuns[i-1].limit;
* } else {
* styleStart = 0;
* }
- * if (limit >= styleStart) {
- * if (styleStart < start) {
+ * if (limit >= styleStart) {
+ * if (styleStart < start) {
* styleStart = start;
* }
* renderRun(text, styleStart, limit, direction,
* byte direction = line.getDirection();
* if (direction != Bidi.MIXED) {
* // unidirectional
- * if (styleRunCount <= 1) {
+ * if (styleRunCount <= 1) {
* renderRun(text, start, limit, direction, styleRuns[0].style);
* } else {
* renderDirectionalRun(text, start, limit, direction,
* e.printStackTrace();
* return;
* }
- * if (styleRunCount <= 1) {
+ * if (styleRunCount <= 1) {
* int style = styleRuns[0].style;
*
* // iterate over directional runs
- * for (i = 0; i < count; ++i) {
+ * for (i = 0; i < count; ++i) {
* run = line.getVisualRun(i);
* renderRun(text, run.getStart(), run.getLimit(),
* run.getDirection(), style);
* }
* } else {
* // iterate over both directional and style runs
- * for (i = 0; i < count; ++i) {
+ * for (i = 0; i < count; ++i) {
* run = line.getVisualRun(i);
* renderDirectionalRun(text, run.getStart(),
* run.getLimit(), run.getDirection(),
* e.printStackTrace();
* return;
* }
- * byte paraLevel = (byte)(1 & para.getParaLevel());
+ * byte paraLevel = (byte)(1 & para.getParaLevel());
* StyleRun styleRun = new StyleRun(length, styleNormal);
*
- * if (styleRuns == null || styleRunCount <= 0) {
+ * if (styleRuns == null || styleRunCount <= 0) {
* styleRuns = new StyleRun[1];
* styleRunCount = 1;
* styleRuns[0] = styleRun;
* }
- * // assume styleRuns[styleRunCount-1].limit>=length
+ * // assume styleRuns[styleRunCount-1].limit>=length
*
* int width = getTextWidth(text, 0, length, styleRuns, styleRunCount);
- * if (width <= lineWidth) {
+ * if (width <= lineWidth) {
* // everything fits onto one line
*
* // prepare rendering a new line from either left or right
* // from either left or right
* startLine(paraLevel, width);
*
- * if (styleRunStart > 0) {
+ * if (styleRunStart > 0) {
* int newRunCount = styleRuns.length - styleRunStart;
* StyleRun[] newRuns = new StyleRun[newRunCount];
* System.arraycopy(styleRuns, styleRunStart, newRuns, 0,
* }
* start = limit;
* styleRunStart = styleRunLimit - 1;
- * if (start >= styleRuns[styleRunStart].limit) {
+ * if (start >= styleRuns[styleRunStart].limit) {
* ++styleRunStart;
* }
* }
* this is part of the approximate "inverse Bidi" algorithm
*
* <p>This option does not imply corresponding adjustment of the index
- * mappings.</p>
+ * mappings.
*
* @see #setInverse
* @see #writeReordered
* (this does not affect INSERT_LRM_FOR_NUMERIC)
*
* <p>This option does not imply corresponding adjustment of the index
- * mappings.</p>
+ * mappings.
*
* @see #writeReordered
* @see #INSERT_LRM_FOR_NUMERIC
* <code>writeReverse()</code> without mirroring.
* Doing this in the same step is faster and avoids a temporary buffer.
* An example for using this option is output to a character terminal that
- * is designed for RTL scripts and stores text in reverse order.</p>
+ * is designed for RTL scripts and stores text in reverse order.
*
* @see #writeReordered
* @stable ICU 3.8
* a reordering to a Logical order
*
* <p>This option must be set or reset before calling
- * <code>setPara</code>.</p>
+ * <code>setPara</code>.
*
* <p>This option is significant only with reordering modes which generate
- * a result with Logical order, specifically.</p>
+ * a result with Logical order, specifically.
* <ul>
* <li><code>REORDER_RUNS_ONLY</code></li>
* <li><code>REORDER_INVERSE_NUMBERS_AS_L</code></li>
* <code>REORDER_INVERSE_NUMBERS_AS_L</code> or with calling
* <code>setInverse(true)</code>, it implies option
* <code>INSERT_LRM_FOR_NUMERIC</code> in calls to method
- * <code>writeReordered()</code>.</p>
+ * <code>writeReordered()</code>.
*
* <p>For other reordering modes, a minimum number of LRM or RLM characters
* will be added to the source text after reordering it so as to ensure
* <code>writeReordered()</code> and it implies option
* <code>INSERT_LRM_FOR_NUMERIC</code> in calls to method
* <code>writeReordered()</code> if the reordering mode is
- * <code>REORDER_INVERSE_NUMBERS_AS_L</code>.</p>
+ * <code>REORDER_INVERSE_NUMBERS_AS_L</code>.
*
* @see #setReorderingMode
* @see #setReorderingOptions
* remove Bidi control characters
*
* <p>This option must be set or reset before calling
- * <code>setPara</code>.</p>
+ * <code>setPara</code>.
*
* <p>This option nullifies option
* <code>OPTION_INSERT_MARKS</code>. It inhibits option
* <code>INSERT_LRM_FOR_NUMERIC</code> in calls to method
* <code>writeReordered()</code> and it implies option
- * <code>REMOVE_BIDI_CONTROLS</code> in calls to that method.</p>
+ * <code>REMOVE_BIDI_CONTROLS</code> in calls to that method.
*
* @see #setReorderingMode
* @see #setReorderingOptions
* process the output as part of a stream to be continued
*
* <p>This option must be set or reset before calling
- * <code>setPara</code>.</p>
+ * <code>setPara</code>.
*
* <p>This option specifies that the caller is interested in processing
* large text object in parts. The results of the successive calls are
* expected to be concatenated by the caller. Only the call for the last
- * part will have this option bit off.</p>
+ * part will have this option bit off.
*
* <p>When this option bit is on, <code>setPara()</code> may process
* less than the full source text in order to truncate the text at a
* <li>resubmit the same text after turning off option
* <code>OPTION_STREAMING</code>.</li></ul>
* In all cases, this option should be turned off before processing the last
- * part of the text.</p>
+ * part of the text.
*
* <p>When the <code>OPTION_STREAMING</code> option is used, it is
* recommended to call <code>orderParagraphsLTR(true)</code> before calling
* <code>setPara()</code> so that later paragraphs may be concatenated to
* previous paragraphs on the right.
- * </p>
*
* @see #setReorderingMode
* @see #setReorderingOptions
* to logical order. This is effectively the inverse algorithm of the
* described Bidi algorithm. Note that there is no standard algorithm for
* this "inverse Bidi" and that the current implementation provides only an
- * approximation of "inverse Bidi".</p>
+ * approximation of "inverse Bidi".
*
* <p>With <code>isInversed</code> set to <code>true</code>,
* this method changes the behavior of some of the subsequent methods
* in a way that they can be used for the inverse Bidi algorithm.
* Specifically, runs of text with numeric characters will be treated in a
* special way and may need to be surrounded with LRM characters when they are
- * written in reordered sequence.</p>
+ * written in reordered sequence.
*
* <p>Output runs should be retrieved using <code>getVisualRun()</code>.
* Since the actual input for "inverse Bidi" is visually ordered text and
* <code>getVisualRun()</code> gets the reordered runs, these are actually
- * the runs of the logically ordered output.</p>
+ * the runs of the logically ordered output.
*
* <p>Calling this method with argument <code>isInverse</code> set to
* <code>true</code> is equivalent to calling <code>setReorderingMode</code>
* <code>setReorderingMode</code> will return <code>true</code> if the
* reordering mode was set to
* <code>REORDER_INVERSE_NUMBERS_AS_L</code>, <code>false</code>
- * for all other values.</p>
+ * for all other values.
*
* @return <code>true</code> if the <code>Bidi</code> object is set to
* perform the inverse Bidi algorithm by handling numbers as L.
*
* <p>The normal operation of the Bidi algorithm as described in the Unicode
* Standard Annex #9 is to take text stored in logical (keyboard, typing)
- * order and to determine how to reorder it for visual rendering.</p>
+ * order and to determine how to reorder it for visual rendering.
*
* <p>With the reordering mode set to a value other than
* <code>REORDER_DEFAULT</code>, this method changes the behavior of some of
* the subsequent methods in a way such that they implement an inverse Bidi
- * algorithm or some other algorithm variants.</p>
+ * algorithm or some other algorithm variants.
*
* <p>Some legacy systems store text in visual order, and for operations
* with standard, Unicode-based algorithms, the text needs to be transformed
* into logical order. This is effectively the inverse algorithm of the
* described Bidi algorithm. Note that there is no standard algorithm for
- * this "inverse Bidi", so a number of variants are implemented here.</p>
+ * this "inverse Bidi", so a number of variants are implemented here.
*
* <p>In other cases, it may be desirable to emulate some variant of the
* Logical to Visual algorithm (e.g. one used in MS Windows), or perform a
- * Logical to Logical transformation.</p>
+ * Logical to Logical transformation.
*
* <ul>
* <li>When the Reordering Mode is set to
* or <code>writeReordered()</code> are actually runs or character string
* of logically ordered output.<br>
* For all the "inverse Bidi" modes, the source text should not contain
- * Bidi control characters other than LRM or RLM.</p>
+ * Bidi control characters other than LRM or RLM.
*
* <p>Note that option <code>OUTPUT_REVERSE</code> of
* <code>writeReordered</code> has no useful meaning and should not be used
* (same index) character if the level has the
* <code>LEVEL_OVERRIDE</code> bit set.<br><br>
* Except for that bit, it must be
- * <code>paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL</code>,
+ * <code>paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL</code>,
* with one exception: a level of zero may be specified for a
* paragraph separator even if <code>paraLevel>0</code> when multiple
* paragraphs are submitted in the same call to <code>setPara()</code>.<br><br>
* (same index) character if the level has the
* <code>LEVEL_OVERRIDE</code> bit set.<br><br>
* Except for that bit, it must be
- * <code>paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL</code>,
+ * <code>paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL</code>,
* with one exception: a level of zero may be specified for a
* paragraph separator even if <code>paraLevel>0</code> when multiple
* paragraphs are submitted in the same call to <code>setPara()</code>.<br><br>
* Retrieves the Bidi class for a given code point.
* <p>If a <code>BidiClassifier</code> is defined and returns a value
* other than <code>CLASS_DEFAULT</code>, that value is used; otherwise
- * the default class determination mechanism is invoked.</p>
+ * the default class determination mechanism is invoked.
*
* @param c The code point to get a Bidi class for.
*
* Some elements of the source array may have no mapping in the
* destination array. In that case, their value will be
* the special value <code>MAP_NOWHERE</code>.
- * All elements must be >=0 or equal to <code>MAP_NOWHERE</code>.
+ * All elements must be >=0 or equal to <code>MAP_NOWHERE</code>.
* Some elements in the source map may have a value greater than the
* srcMap.length if the destination array has more elements than the
* source array.
*
* <p>The text may have been aliased (only a reference was stored
* without copying the contents), thus it must not have been modified
- * since the <code>setPara()</code> call.</p>
+ * since the <code>setPara()</code> call.
*
* This method preserves the integrity of characters with multiple
* code units and (optionally) combining characters.
/*
*******************************************************************************
-* Copyright (C) 2001-2011, International Business Machines
+* Copyright (C) 2001-2016, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
*/
/**
* A BidiRun represents a sequence of characters at the same embedding level.
* The Bidi algorithm decomposes a piece of text into sequences of characters
- * at the same embedding level, each such sequence is called a <quote>run</quote>.
+ * at the same embedding level, each such sequence is called a "run".
*
* <p>A BidiRun represents such a run by storing its essential properties,
* but does not duplicate the characters which form the run.
/*
*******************************************************************************
- * Copyright (C) 1996-2015, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* int last = wb.following(pos);
* int current = wb.next();
* while (current != BreakIterator.DONE) {
- * for (int p = last; p < current; p++) {
+ * for (int p = last; p < current; p++) {
* if (Character.isLetter(text.charAt(p)))
* return last;
* }
/**
*******************************************************************************
-* Copyright (C) 2005-2014, International Business Machines Corporation and *
+* Copyright (C) 2005-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* The result of the detection operation is a list of possibly matching
* charsets, or, for simple use, you can just ask for a Java Reader that
* will will work over the input data.
- * <p/>
+ * <p>
* Character set detection is at best an imprecise operation. The detection
* process will attempt to identify the charset that best matches the characteristics
* of the byte data, but the process is partly statistical in nature, and
* the results can not be guaranteed to always be correct.
- * <p/>
+ * <p>
* For best accuracy in charset detection, the input data should be primarily
* in a single language, and a minimum of a few hundred bytes worth of plain text
* in the language are needed. The detection process will attempt to
* ignore html or xml style markup that could otherwise obscure the content.
- * <p/>
+ * <p>
* @stable ICU 3.4
*/
public class CharsetDetector {
* A match between a declared encoding and a possible detected encoding
* will raise the quality of that detected encoding by a small delta,
* and will also appear as a "reason" for the match.
- * <p/>
+ * <p>
* A declared encoding that is incompatible with the input data being
* analyzed will not be added to the list of possible encodings.
*
/**
* Set the input text (byte) data whose charset is to be detected.
- * <p/>
+ * <p>
* The input stream that supplies the character data must have markSupported()
* == true; the charset detection process will read a small amount of data,
* then return the stream to its original position via
* only looks at the start of the input data,
* there is a possibility that the returned charset will fail to handle
* the full set of input data.
- * <p/>
+ * <p>
* Raise an exception if
* <ul>
* <li>no charset appears to match the data.</li>
* Return an array of all charsets that appear to be plausible
* matches with the input data. The array is ordered with the
* best quality match first.
- * <p/>
+ * <p>
* Raise an exception if
* <ul>
* <li>no charsets appear to match the input data.</li>
/**
* Autodetect the charset of an inputStream, and return a Java Reader
* to access the converted input data.
- * <p/>
+ * <p>
* This is a convenience method that is equivalent to
* <code>this.setDeclaredEncoding(declaredEncoding).setText(in).detect().getReader();</code>
- * <p/>
+ * <p>
* For the input stream that supplies the character data, markSupported()
* must be true; the charset detection will read a small amount of data,
* then return the stream to its original position via
* the InputStream.reset() operation. The exact amount that will
* be read depends on the characteristics of the data itself.
- *<p/>
+ *<p>
* Raise an exception if no charsets appear to match the input data.
*
* @param in The source of the byte data in the unknown charset.
/**
* Autodetect the charset of an inputStream, and return a String
* containing the converted input data.
- * <p/>
+ * <p>
* This is a convenience method that is equivalent to
* <code>this.setDeclaredEncoding(declaredEncoding).setText(in).detect().getString();</code>
- *<p/>
+ *<p>
* Raise an exception if no charsets appear to match the input data.
*
* @param in The source of the byte data in the unknown charset.
/**
* Enable filtering of input text. If filtering is enabled,
- * text within angle brackets ("<" and ">") will be removed
+ * text within angle brackets ("<" and ">") will be removed
* before detection.
*
* @param filter <code>true</code> to enable input text filtering.
/**
*******************************************************************************
-* Copyright (C) 2005-2012, International Business Machines Corporation and *
+* Copyright (C) 2005-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* as a possible encoding for a set of input data. From an instance of this
* class, you can ask for a confidence level in the charset identification,
* or for Java Reader or String to access the original byte data in Unicode form.
- * <p/>
+ * <p>
* Instances of this class are created only by CharsetDetectors.
- * <p/>
+ * <p>
* Note: this class has a natural ordering that is inconsistent with equals.
* The natural ordering is based on the match confidence value.
*
/**
* Create a java.io.Reader for reading the Unicode character data corresponding
* to the original byte data supplied to the Charset detect operation.
- * <p/>
+ * <p>
* CAUTION: if the source of the byte data was an InputStream, a Reader
* can be created for only one matching char set using this method. If more
* than one charset needs to be tried, the caller will need to reset
* <p>
* DateFormat is an abstract class for date/time formatting subclasses which formats and parses dates or time in a
* language-independent manner. The date/time formatting subclass, such as SimpleDateFormat, allows for formatting
- * (i.e., date -> text), parsing (text -> date), and normalization. The date is represented as a <code>Date</code>
+ * (i.e., date -> text), parsing (text -> date), and normalization. The date is represented as a <code>Date</code>
* object or as the milliseconds since January 1, 1970, 00:00:00 GMT.
*
* <p>
* <li>align any particular field, or find out where it is for selection on the screen.
* </ul>
*
- * <h4>Synchronization</h4>
+ * <h3>Synchronization</h3>
*
* Date formats are not synchronized. It is recommended to create separate format instances for each thread. If multiple
* threads access a format concurrently, it must be synchronized externally.
* lenient parsing, the parser may use heuristics to interpret inputs that
* do not precisely match this object's format. Without lenient parsing,
* inputs must match this object's format more closely.
- * <br/><br/>
+ * <br><br>
* <b>Note:</b> ICU 53 introduced finer grained control of leniency (and added
* new control points) making the preferred method a combination of
- * setCalendarLenient() & setBooleanAttribute() calls.
+ * setCalendarLenient() & setBooleanAttribute() calls.
* This method supports prior functionality but may not support all
- * future leniency control & behavior of DateFormat. For control of pre 53 leniency,
- * Calendar and DateFormat whitespace & numeric tolerance, this method is safe to
+ * future leniency control & behavior of DateFormat. For control of pre 53 leniency,
+ * Calendar and DateFormat whitespace & numeric tolerance, this method is safe to
* use. However, mixing leniency control via this method and modification of the
* newer attributes via setBooleanAttribute() may produce undesirable
* results.
}
/**
- * Returns whether both date/time parsing in the encapsulated Calendar object and DateFormat whitespace &
+ * Returns whether both date/time parsing in the encapsulated Calendar object and DateFormat whitespace &
* numeric processing is lenient.
* @stable ICU 2.0
*/
* <li><code>zoneStrings[i][5]</code> - location name of zone</li>
* <li><code>zoneStrings[i][6]</code> - long generic name of zone</li>
* <li><code>zoneStrings[i][7]</code> - short generic of zone</li>
+ * </ul>
* The zone ID is <em>not</em> localized; it corresponds to the ID
* value associated with a system time zone object. All other entries
* are localized names. If a zone does not implement daylight savings
* second (though we do not currently have specific intervalFormat data for
* skeletons with seconds).
* Those calendar fields can be defined in the following order:
- * year > month > date > hour (in day) > minute > second
+ * year > month > date > hour (in day) > minute > second
*
* The largest different calendar fields between 2 calendars is the
* first different calendar field in above order.
*
*
* </pre>
- * <h4>Synchronization</h4>
+ * <h3>Synchronization</h3>
*
* The format methods of DateIntervalFormat may be used concurrently from multiple threads.
* Functions that alter the state of a DateIntervalFormat object (setters)
* date time interval strings into Formattable objects with
* DateInterval type, which is a pair of UDate.
* <P>
- * <P>
* Before calling, set parse_pos.index to the offset you want to start
* parsing at in the source. After calling, parse_pos.index is the end of
* the text you parsed. If error occurs, index is unchanged.
* second (though we do not currently have specific intervalFormat data for
* skeletons with seconds).
* Those calendar fields can be defined in the following order:
- * year > month > date > am-pm > hour > minute > second
+ * year > month > date > am-pm > hour > minute > second
*
* The largest different calendar fields between 2 calendars is the
* first different calendar field in above order.
import java.util.TreeMap;
import java.util.TreeSet;
+
import com.ibm.icu.impl.ICUCache;
import com.ibm.icu.impl.ICUResourceBundle;
import com.ibm.icu.impl.PatternTokenizer;
/**
* Construct a flexible generator according to data for a given locale.
- * @param locale The {@link java.text.Locale} to pass.
+ * @param locale The {@link java.util.Locale} to pass.
* @stable ICU 54
*/
public static DateTimePatternGenerator getInstance(Locale locale) {
* Locale[] locales = NumberFormat.getAvailableLocales();
* double myNumber = -1234.56;
* NumberFormat format;
- * for (int j=0; j<3; ++j) {
+ * for (int j=0; j<3; ++j) {
* System.out.println("FORMAT");
- * for (int i = 0; i < locales.length; ++i) {
+ * for (int i = 0; i < locales.length; ++i) {
* if (locales[i].getCountry().length() == 0) {
* // Skip language-only locales
* continue;
* try {
* // Assume format is a DecimalFormat
* System.out.print(": " + ((DecimalFormat) format).toPattern()
- * + " -> " + form.format(myNumber));
+ * + " -> " + form.format(myNumber));
* } catch (Exception e) {}
* try {
- * System.out.println(" -> " + format.parse(form.format(myNumber)));
+ * System.out.println(" -> " + format.parse(form.format(myNumber)));
* } catch (ParseException e) {}
* }
* }</pre></blockquote>
*
- * <p>Another example use getInstance(style).<br/>
+ * <p>Another example use getInstance(style).<br>
* Print out a number using the localized number, currency, percent,
* scientific, integer, iso currency, and plural currency format for each locale.
*
* <blockquote><pre>
* ULocale locale = new ULocale("en_US");
* double myNumber = 1234.56;
- * for (int j=NumberFormat.NUMBERSTYLE; j<=NumberFormat.PLURALCURRENCYSTYLE; ++j) {
+ * for (int j=NumberFormat.NUMBERSTYLE; j<=NumberFormat.PLURALCURRENCYSTYLE; ++j) {
* NumberFormat format = NumberFormat.getInstance(locale, j);
* try {
* // Assume format is a DecimalFormat
* System.out.print(": " + ((DecimalFormat) format).toPattern()
- * + " -> " + form.format(myNumber));
+ * + " -> " + form.format(myNumber));
* } catch (Exception e) {}
* try {
- * System.out.println(" -> " + format.parse(form.format(myNumber)));
+ * System.out.println(" -> " + format.parse(form.format(myNumber)));
* } catch (ParseException e) {}
* }</pre></blockquote>
*
- * <h4>Patterns</h4>
+ * <h3>Patterns</h3>
*
* <p>A <code>DecimalFormat</code> consists of a <em>pattern</em> and a set of
* <em>symbols</em>. The pattern may be set directly using {@link #applyPattern}, or
* <blockquote>
* <table border=0 cellspacing=3 cellpadding=0 summary="Chart showing symbol,
* location, localized, and meaning.">
- * <tr bgcolor="#ccccff">
+ * <tr style="background-color: #ccccff">
* <th align=left>Symbol
* <th align=left>Location
* <th align=left>Localized?
* <th align=left>Meaning
- * <tr valign=top>
+ * <tr style="vertical-align: top;">
* <td><code>0</code>
* <td>Number
* <td>Yes
* <td>Digit
- * <tr valign=top bgcolor="#eeeeff">
+ * <tr style="vertical-align: top; background-color: #eeeeff;">
* <td><code>1-9</code>
* <td>Number
* <td>Yes
* <td>'1' through '9' indicate rounding.
- * <tr valign=top>
+ * <tr style="vertical-align: top;">
* <td><code>@</code>
* <td>Number
* <td>No
* <td>Significant digit
- * <tr valign=top bgcolor="#eeeeff">
+ * <tr style="vertical-align: top; background-color: #eeeeff;">
* <td><code>#</code>
* <td>Number
* <td>Yes
* <td>Digit, zero shows as absent
- * <tr valign=top>
+ * <tr style="vertical-align: top;">
* <td><code>.</code>
* <td>Number
* <td>Yes
* <td>Decimal separator or monetary decimal separator
- * <tr valign=top bgcolor="#eeeeff">
+ * <tr style="vertical-align: top; background-color: #eeeeff;">
* <td><code>-</code>
* <td>Number
* <td>Yes
* <td>Minus sign
- * <tr valign=top>
+ * <tr style="vertical-align: top;">
* <td><code>,</code>
* <td>Number
* <td>Yes
* <td>Grouping separator
- * <tr valign=top bgcolor="#eeeeff">
+ * <tr style="vertical-align: top; background-color: #eeeeff;">
* <td><code>E</code>
* <td>Number
* <td>Yes
* <td>Separates mantissa and exponent in scientific notation.
* <em>Need not be quoted in prefix or suffix.</em>
- * <tr valign=top>
+ * <tr style="vertical-align: top;">
* <td><code>+</code>
* <td>Exponent
* <td>Yes
* <td>Prefix positive exponents with localized plus sign.
* <em>Need not be quoted in prefix or suffix.</em>
- * <tr valign=top bgcolor="#eeeeff">
+ * <tr style="vertical-align: top; background-color: #eeeeff;">
* <td><code>;</code>
* <td>Subpattern boundary
* <td>Yes
* <td>Separates positive and negative subpatterns
- * <tr valign=top>
+ * <tr style="vertical-align: top;">
* <td><code>%</code>
* <td>Prefix or suffix
* <td>Yes
* <td>Multiply by 100 and show as percentage
- * <tr valign=top bgcolor="#eeeeff">
+ * <tr style="vertical-align: top; background-color: #eeeeff;">
* <td><code>\u2030</code>
* <td>Prefix or suffix
* <td>Yes
* <td>Multiply by 1000 and show as per mille
- * <tr valign=top>
+ * <tr style="vertical-align: top;">
* <td><code>¤</code> (<code>\u00A4</code>)
* <td>Prefix or suffix
* <td>No
* "US dollar" or "US dollars" for America.
* If present in a pattern, the monetary decimal separator
* is used instead of the decimal separator.
- * <tr valign=top bgcolor="#eeeeff">
+ * <tr style="vertical-align: top; background-color: #eeeeff;">
* <td><code>'</code>
* <td>Prefix or suffix
* <td>No
* for example, <code>"'#'#"</code> formats 123 to
* <code>"#123"</code>. To create a single quote
* itself, use two in a row: <code>"# o''clock"</code>.
- * <tr valign=top>
+ * <tr style="vertical-align: top;">
* <td><code>*</code>
* <td>Prefix or suffix boundary
* <td>Yes
* with the positive or negative prefixes and suffixes applied. The infinity character is
* determined by the {@link DecimalFormatSymbols} object.
*
- * <a name="sci"><h4>Scientific Notation</h4></a>
+ * <h4><a name="sci">Scientific Notation</a></h4>
*
* <p>Numbers in scientific notation are expressed as the product of a mantissa and a
* power of ten, for example, 1234 can be expressed as 1.234 x 10<sup>3</sup>. The
*
* </ul>
*
- * <a name="sigdig"><h4>Significant Digits</h4></a>
+ * <h4><a name="sigdig">Significant Digits</a></h4>
*
* <code>DecimalFormat</code> has two ways of controlling how many digits are shows: (a)
* significant digits counts, or (b) integer and fraction digit counts. Integer and
*
* <blockquote>
* <table border=0 cellspacing=3 cellpadding=0>
- * <tr bgcolor="#ccccff">
+ * <tr style="background-color: #ccccff">
* <th align=left>Pattern
* <th align=left>Minimum significant digits
* <th align=left>Maximum significant digits
* <th align=left>Number
* <th align=left>Output of format()
- * <tr valign=top>
+ * <tr style="vertical-align: top;">
* <td><code>@@@</code>
* <td>3
* <td>3
* <td>12345
* <td><code>12300</code>
- * <tr valign=top bgcolor="#eeeeff">
+ * <tr style="vertical-align: top; background-color: #eeeeff;">
* <td><code>@@@</code>
* <td>3
* <td>3
* <td>0.12345
* <td><code>0.123</code>
- * <tr valign=top>
+ * <tr style="vertical-align: top;">
* <td><code>@@##</code>
* <td>2
* <td>4
* <td>3.14159
* <td><code>3.142</code>
- * <tr valign=top bgcolor="#eeeeff">
+ * <tr style="vertical-align: top; background-color: #eeeeff;">
* <td><code>@@##</code>
* <td>2
* <td>4
*
* @param text the text to parse
* @param pos input-output position; on input, the position within text to match; must
- * have 0 <= pos.getIndex() < text.length(); on output, the position after the last
+ * have 0 <= pos.getIndex() < text.length(); on output, the position after the last
* matched character. If the parse fails, the position in unchanged upon output.
* @return a CurrencyAmount, or null upon failure
* @stable ICU 49
* symbol). For a permill, set the suffixes to have "\u2031" and the multiplier to be
* 1000.
*
- * <p>Examples: with 100, 1.23 -> "123", and "123" -> 1.23
+ * <p>Examples: with 100, 1.23 -> "123", and "123" -> 1.23
*
* @return the multiplier
* @stable ICU 2.0
* symbol). For a permill, set the suffixes to have "\u2031" and the multiplier to be
* 1000.
*
- * <p>Examples: with 100, 1.23 -> "123", and "123" -> 1.23
+ * <p>Examples: with 100, 1.23 -> "123", and "123" -> 1.23
*
* @param newValue the multiplier
* @stable ICU 2.0
*
* @param newValue A positive rounding increment, or <code>null</code> or
* <code>BigDecimal(0.0)</code> to use the default rounding increment.
- * @throws IllegalArgumentException if <code>newValue</code> is < 0.0
+ * @throws IllegalArgumentException if <code>newValue</code> is < 0.0
* @see #getRoundingIncrement
* @see #getRoundingMode
* @see #setRoundingMode
*
* @param newValue A positive rounding increment, or <code>null</code> or
* <code>BigDecimal(0.0)</code> to use the default rounding increment.
- * @throws IllegalArgumentException if <code>newValue</code> is < 0.0
+ * @throws IllegalArgumentException if <code>newValue</code> is < 0.0
* @see #getRoundingIncrement
* @see #getRoundingMode
* @see #setRoundingMode
*
* @param newValue A positive rounding increment, or 0.0 to use the default
* rounding increment.
- * @throws IllegalArgumentException if <code>newValue</code> is < 0.0
+ * @throws IllegalArgumentException if <code>newValue</code> is < 0.0
* @see #getRoundingIncrement
* @see #getRoundingMode
* @see #setRoundingMode
*
* @param width the width to which to pad the result of
* <code>format()</code>, or zero to disable padding
- * @exception IllegalArgumentException if <code>width</code> is < 0
+ * @exception IllegalArgumentException if <code>width</code> is < 0
* @see #getFormatWidth
* @see #getPadCharacter
* @see #setPadCharacter
/**
* {@icu} Sets whether or not scientific notation is used. When scientific notation is
- * used, the effective maximum number of integer digits is <= 8. If the maximum number
+ * used, the effective maximum number of integer digits is <= 8. If the maximum number
* of integer digits is set to more than 8, the effective maximum will be 1. This
* allows this call to generate a 'default' scientific number format without
* additional changes.
* {@icu} Sets the minimum exponent digits that will be shown. This has no effect
* unless scientific notation is in use.
*
- * @param minExpDig a value >= 1 indicating the fewest exponent
+ * @param minExpDig a value >= 1 indicating the fewest exponent
* digits that will be shown
- * @exception IllegalArgumentException if <code>minExpDig</code> < 1
+ * @exception IllegalArgumentException if <code>minExpDig</code> < 1
* @see #setScientificNotation
* @see #isScientificNotation
* @see #getMinimumExponentDigits
/**
* Returns the behavior of the decimal separator with integers. (The decimal
- * separator will always appear with decimals.) <p> Example: Decimal ON: 12345 ->
- * 12345.; OFF: 12345 -> 12345
+ * separator will always appear with decimals.) <p> Example: Decimal ON: 12345 ->
+ * 12345.; OFF: 12345 -> 12345
*
* @stable ICU 2.0
*/
* will always appear with decimals.)
*
* <p>This only affects formatting, and only where there might be no digits after the
- * decimal point, e.g., if true, 3456.00 -> "3,456." if false, 3456.00 -> "3456" This
+ * decimal point, e.g., if true, 3456.00 -> "3,456." if false, 3456.00 -> "3456" This
* is independent of parsing. If you want parsing to stop at the decimal point, use
* setParseIntegerOnly.
*
* <p>
- * Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
+ * Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
*
* @stable ICU 2.0
*/
* typical end-user desire; use setMaximumInteger if you want to set a real value. For
* negative numbers, use a second pattern, separated by a semicolon
*
- * <p>Example "#,#00.0#" -> 1,234.56
+ * <p>Example "#,#00.0#" -> 1,234.56
*
* <p>This means a minimum of 2 integer digits, 1 fraction digit, and a maximum of 2
* fraction digits.
* typical end-user desire; use setMaximumInteger if you want to set a real value. For
* negative numbers, use a second pattern, separated by a semicolon
*
- * <p>Example "#,#00.0#" -> 1,234.56
+ * <p>Example "#,#00.0#" -> 1,234.56
*
* <p>This means a minimum of 2 integer digits, 1 fraction digit, and a maximum of 2
* fraction digits.
private boolean useSignificantDigits = false;
/**
- * The minimum number of significant digits to show. Must be >= 1 and <=
+ * The minimum number of significant digits to show. Must be >= 1 and <=
* maxSignificantDigits. Ignored unless useSignificantDigits == true.
*
* @serial
private int minSignificantDigits = 1;
/**
- * The maximum number of significant digits to show. Must be >=
+ * The maximum number of significant digits to show. Must be >=
* minSignficantDigits. Ignored unless useSignificantDigits == true.
*
* @serial
private MathContext mathContext = new MathContext(0, MathContext.PLAIN);
/**
- * The padded format width, or zero if there is no padding. Must be >= 0. Default
+ * The padded format width, or zero if there is no padding. Must be >= 0. Default
* value zero.
*
* @serial
/*
*******************************************************************************
- * Copyright (C) 2014, International Business Machines Corporation and
+ * Copyright (C) 2014-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* Construct a FilteredBreakIteratorBuilder based on rules in a locale.
* The rules are taken from CLDR exception data for the locale,
* see http://www.unicode.org/reports/tr35/tr35-general.html#Segmentation_Exceptions
- * This is the equivalent of calling createInstance(UErrorCode&)
+ * This is the equivalent of calling createInstance(UErrorCode&)
* and then repeatedly calling addNoBreakAfter(...) with the contents
* of the CLDR exception data.
* @param where the locale.
/*
*******************************************************************************
- * Copyright (C) 2003-2014, International Business Machines Corporation and *
+ * Copyright (C) 2003-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* - IDNA.USE_STD3_RULES Use STD3 ASCII rules for host name syntax restrictions
* If this option is set and the input does not satisfy STD3 rules,
* the operation will fail with ParseException
- * @return 0 if the strings are equal, > 0 if s1 > s2 and < 0 if s1 < s2
+ * @return 0 if the strings are equal, > 0 if s1 > s2 and < 0 if s1 < s2
* @deprecated ICU 55 Use UTS 46 instead via {@link #getUTS46Instance(int)}.
*/
@Deprecated
* - IDNA.USE_STD3_RULES Use STD3 ASCII rules for host name syntax restrictions
* If this option is set and the input does not satisfy STD3 rules,
* the operation will fail with ParseException
- * @return 0 if the strings are equal, > 0 if s1 > s2 and < 0 if s1 < s2
+ * @return 0 if the strings are equal, > 0 if s1 > s2 and < 0 if s1 < s2
* @deprecated ICU 55 Use UTS 46 instead via {@link #getUTS46Instance(int)}.
*/
@Deprecated
* - IDNA.USE_STD3_RULES Use STD3 ASCII rules for host name syntax restrictions
* If this option is set and the input does not satisfy STD3 rules,
* the operation will fail with ParseException
- * @return 0 if the strings are equal, > 0 if i1 > i2 and < 0 if i1 < i2
+ * @return 0 if the strings are equal, > 0 if i1 > i2 and < 0 if i1 < i2
* @deprecated ICU 55 Use UTS 46 instead via {@link #getUTS46Instance(int)}.
*/
@Deprecated
/*
***************************************************************************
- * Copyright (C) 2008-2015, Google, International Business Machines Corporation
+ * Copyright (C) 2008-2016, Google, International Business Machines Corporation
* and others. All Rights Reserved.
***************************************************************************
*/
* to be of a script that already appears elsewhere in the identifier
* when possible.
* The alternate script computation may not be perfect. The distinction
- * between 0, 1 and > 1 scripts will be valid, however.
+ * between 0, 1 and > 1 scripts will be valid, however.
* @return the number of scripts.
* @internal
* @deprecated This API is ICU internal only.
* Return a comparator that compares the locale names for the display locale or the in-self names,
* depending on an input parameter.
* @param inSelf if true, compares the nameInSelf, otherwise the nameInDisplayLocale
- * @param comparator (meant for strings, but because Java Collator doesn't have <String>...)
+ * @param comparator (meant for strings, but because Java Collator doesn't have <String>...)
* @return UiListItem comparator
* @draft ICU 55
* @provisional This API might change or be removed in a future release.
* <code>formatMeasures</code> method is preferred over calling
* this method as they give better performance.
*
- * @param obj must be a Collection<? extends Measure>, Measure[], or Measure object.
+ * @param obj must be a Collection<? extends Measure>, Measure[], or Measure object.
* @param toAppendTo Formatted string appended here.
* @param pos Identifies a field in the formatted text.
* @see java.text.Format#format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
* A numbered pattern argument is matched with a map key that contains that number
* as an ASCII-decimal-digit string (without leading zero).
*
- * <h4><a name="patterns">Patterns and Their Interpretation</a></h4>
+ * <h3><a name="patterns">Patterns and Their Interpretation</a></h3>
*
* <code>MessageFormat</code> uses patterns of the following form:
* <blockquote><pre>
* shown in the table are illegal. Any <code>argStyleText</code> must
* be a valid pattern string for the Format subclass used.
*
- * <p><table border=1>
+ * <table border=1>
* <tr>
* <th>argType
* <th>argStyle
* <td><code>DateFormat.getDateInstance(DateFormat.FULL, getLocale())</code>
* <tr>
* <td><i>argStyleText</i>
- * <td><code>new SimpleDateFormat(argStyleText, getLocale())
+ * <td><code>new SimpleDateFormat(argStyleText, getLocale())</code>
* <tr>
* <td rowspan=6><code>time</code>
* <td><i>(none)</i>
* <td><code>DateFormat.getTimeInstance(DateFormat.FULL, getLocale())</code>
* <tr>
* <td><i>argStyleText</i>
- * <td><code>new SimpleDateFormat(argStyleText, getLocale())
+ * <td><code>new SimpleDateFormat(argStyleText, getLocale())</code>
* <tr>
* <td><code>spellout</code>
* <td><i>argStyleText (optional)</i>
* <td><code>new RuleBasedNumberFormat(getLocale(), RuleBasedNumberFormat.SPELLOUT)
- * <br/> .setDefaultRuleset(argStyleText);</code>
+ * <br> .setDefaultRuleset(argStyleText);</code>
* <tr>
* <td><code>ordinal</code>
* <td><i>argStyleText (optional)</i>
* <td><code>new RuleBasedNumberFormat(getLocale(), RuleBasedNumberFormat.ORDINAL)
- * <br/> .setDefaultRuleset(argStyleText);</code>
+ * <br> .setDefaultRuleset(argStyleText);</code>
* <tr>
* <td><code>duration</code>
* <td><i>argStyleText (optional)</i>
* <td><code>new RuleBasedNumberFormat(getLocale(), RuleBasedNumberFormat.DURATION)
- * <br/> .setDefaultRuleset(argStyleText);</code>
+ * <br> .setDefaultRuleset(argStyleText);</code>
* </table>
- * <p>
*
* <h4><a name="diffsjdk">Differences from java.text.MessageFormat</a></h4>
*
* argument is <i>unavailable</i> if <code>arguments</code> is
* <code>null</code> or has fewer than argumentIndex+1 elements. When
* an argument is unavailable no substitution is performed.
- * <p>
+ *
* <table border=1>
* <tr>
* <th>argType or Format
* @throws IllegalArgumentException if an argument in
* <code>arguments</code> is not of the type
* expected by the format element(s) that use it
- * @throws IllegalArgumentException if <code>arguments<code> is
+ * @throws IllegalArgumentException if <code>arguments</code> is
* an array of Object and this format uses named arguments
* @stable ICU 3.0
*/
* <li>Literal output text is not represented directly by "parts" but accessed
* between parts of a message, from one part's getLimit() to the next part's getIndex().
* <li><code>ARG_START.CHOICE</code> stands for an ARG_START Part with ArgType CHOICE.
- * <li>In the choiceStyle, the ARG_SELECTOR has the '<', the '#' or
+ * <li>In the choiceStyle, the ARG_SELECTOR has the '<', the '#' or
* the less-than-or-equal-to sign (U+2264).
* <li>In the pluralStyle, the first, optional numeric Part has the "offset:" value.
* The optional numeric Part between each (ARG_SELECTOR, message) pair
* is the value of an explicit-number selector like "=2",
* otherwise the selector is a non-numeric identifier.
* <li>The REPLACE_NUMBER Part can occur only in an immediate sub-message of the pluralStyle.
+ * </ul>
* <p>
* This class is not intended for public subclassing.
*
* <p>
* The following table shows examples of desired MessageFormat.format() output
* with the pattern strings that yield that output.
- * <p>
+ *
* <table>
* <tr>
* <th>Desired output</th>
* Returns the index of the ARG|MSG_LIMIT part corresponding to the ARG|MSG_START at start.
* @param start The index of some Part data (0..countParts()-1);
* this Part should be of Type ARG_START or MSG_START.
- * @return The first i>start where getPart(i).getType()==ARG|MSG_LIMIT at the same nesting level,
+ * @return The first i>start where getPart(i).getType()==ARG|MSG_LIMIT at the same nesting level,
* or start itself if getPartType(msgStart)!=ARG|MSG_START.
* @throws IndexOutOfBoundsException if start is outside the (0..countParts()-1) range
* @stable ICU 4.8
/*
*******************************************************************************
- * Copyright (C) 2000-2015, International Business Machines Corporation and
+ * Copyright (C) 2000-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* The most significant bits, however, are shifted down and passed on
* to the normalization implementation.
* (That is, from compare(..., options, ...),
- * options>>COMPARE_NORM_OPTIONS_SHIFT will be passed on to the
+ * options>>COMPARE_NORM_OPTIONS_SHIFT will be passed on to the
* internal normalization functions.)
*
* @see #compare
* If set, then the following case folding options are used.
*
*
- * @return <0 or 0 or >0 as usual for string comparisons
+ * @return <0 or 0 or >0 as usual for string comparisons
*
* @see #normalize
* @see #FCD
* instead of case-sensitively.
* If set, then the following case folding options are used.
*
- * @return <0 or 0 or >0 as usual for string comparisons
+ * @return <0 or 0 or >0 as usual for string comparisons
*
* @see #normalize
* @see #FCD
* instead of case-sensitively.
* If set, then the following case folding options are used.
*
- * @return <0 or 0 or >0 as usual for string comparisons
+ * @return <0 or 0 or >0 as usual for string comparisons
*
* @see #normalize
* @see #FCD
* that is being performed , but they control whether
* certain optional portions of the operation are done.
* Currently the only available option is:
- * <p>
+ *
* <ul>
* <li>{@link #UNICODE_3_2} - Use Normalization conforming to Unicode version 3.2.
* </ul>
- * <p>
+ *
* @param option the option whose value is to be set.
* @param value the new setting for the option. Use <tt>true</tt> to
* turn the option on and <tt>false</tt> to turn it off.
/*
*******************************************************************************
- * Copyright (C) 2009-2015, International Business Machines
+ * Copyright (C) 2009-2016, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
*/
public String getRawDecomposition(int c) { return null; }
/**
- * Performs pairwise composition of a & b and returns the composite if there is one.
+ * Performs pairwise composition of a & b and returns the composite if there is one.
*
* <p>Returns a composite code point c only if c has a two-way mapping to a+b.
* In standard Unicode normalization, this means that
* <blockquote>
* <pre>
* NumberFormat nf = NumberFormat.getInstance();
- * for (int i = 0; i < a.length; ++i) {
+ * for (int i = 0; i < a.length; ++i) {
* output.println(nf.format(myNumber[i]) + "; ");
* }
* </pre>
* the detailed description for each these control methods,
* <p>
* setParseIntegerOnly : only affects parsing, e.g.
- * if true, "3456.78" -> 3456 (and leaves the parse position just after '6')
- * if false, "3456.78" -> 3456.78 (and leaves the parse position just after '8')
+ * if true, "3456.78" -> 3456 (and leaves the parse position just after '6')
+ * if false, "3456.78" -> 3456.78 (and leaves the parse position just after '8')
* This is independent of formatting. If you want to not show a decimal point
* where there might be no digits after the decimal point, use
* setDecimalSeparatorAlwaysShown on DecimalFormat.
* numbers: "(12)" for -12.
* </ol>
*
- * <h4>Synchronization</h4>
+ * <h3>Synchronization</h3>
* <p>
* Number formats are generally not synchronized. It is recommended to create
* separate format instances for each thread. If multiple threads access a format
* concurrently, it must be synchronized externally.
- * <p>
*
* <h4>DecimalFormat</h4>
* <p>DecimalFormat is the concrete implementation of NumberFormat, and the
*
* @param text the text to parse
* @param pos input-output position; on input, the position within
- * text to match; must have 0 <= pos.getIndex() < text.length();
+ * text to match; must have 0 <= pos.getIndex() < text.length();
* on output, the position after the last matched character. If
* the parse fails, the position in unchanged upon output.
* @return a CurrencyAmount, or null upon failure
/**
* Sets the maximum number of digits allowed in the integer portion of a
- * number. This must be >= minimumIntegerDigits. If the
+ * number. This must be >= minimumIntegerDigits. If the
* new value for maximumIntegerDigits is less than the current value
* of minimumIntegerDigits, then minimumIntegerDigits will also be set to
* the new value.
/**
* Sets the minimum number of digits allowed in the integer portion of a
- * number. This must be <= maximumIntegerDigits. If the
+ * number. This must be <= maximumIntegerDigits. If the
* new value for minimumIntegerDigits is more than the current value
* of maximumIntegerDigits, then maximumIntegerDigits will also be set to
* the new value.
/**
* Sets the maximum number of digits allowed in the fraction portion of a
- * number. This must be >= minimumFractionDigits. If the
+ * number. This must be >= minimumFractionDigits. If the
* new value for maximumFractionDigits is less than the current value
* of minimumFractionDigits, then minimumFractionDigits will also be set to
* the new value.
/**
* Sets the minimum number of digits allowed in the fraction portion of a
- * number. This must be <= maximumFractionDigits. If the
+ * number. This must be <= maximumFractionDigits. If the
* new value for minimumFractionDigits exceeds the current value
* of maximumFractionDigits, then maximumFractionDigits will also be set to
* the new value.
import com.ibm.icu.util.ULocale.Category;
/**
- * <p>
* <code>PluralFormat</code> supports the creation of internationalized
* messages with plural inflection. It is based on <i>plural
* selection</i>, i.e. the caller specifies messages for each
* plural case that can appear in the user's language and the
* <code>PluralFormat</code> selects the appropriate message based on
* the number.
- * </p>
- * <h4>The Problem of Plural Forms in Internationalized Messages</h4>
+ *
+ * <h3>The Problem of Plural Forms in Internationalized Messages</h3>
* <p>
* Different languages have different ways to inflect
* plurals. Creating internationalized messages that include plural
* applies to infinitely many intervals (e.g., the paucal case applies to
* numbers ending with 2, 3, or 4 except those ending with 12, 13, or
* 14). Thus <code>ChoiceFormat</code> is not adequate.
- * </p><p>
+ * <p>
* <code>PluralFormat</code> deals with this by breaking the problem
* into two parts:
* <ul>
* rules, see the CLDR <i>Language Plural Rules</i> page at
* http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html
* </ul>
- * </p>
+ *
* <h4>Usage of <code>PluralFormat</code></h4>
* <p>Note: Typically, plural formatting is done via <code>MessageFormat</code>
* with a <code>plural</code> argument type,
* rather than using a stand-alone <code>PluralFormat</code>.
- * </p><p>
+ * <p>
* This discussion assumes that you use <code>PluralFormat</code> with
* a predefined set of plural rules. You can create one using one of
* the constructors that takes a <code>ULocale</code> object. To
* <code>applyPattern()</code> method. The <code>format()</code>
* method takes a number object and selects the message of the
* matching plural case. This message will be returned.
- * </p>
+ *
* <h5>Patterns and Their Interpretation</h5>
* <p>
* The pattern text defines the message output for each plural case of the
* Pattern_White_Space between syntax elements is ignored, except
* between the {curly braces} and their sub-message,
* and between the '=' and the number of an explicitValue.
- *
- * </p><p>
+ * <p>
* There are 6 predefined case keywords in CLDR/ICU - 'zero', 'one', 'two', 'few', 'many' and
* 'other'. You always have to define a message text for the default plural case
* "<code>other</code>" which is contained in every rule set.
* If you do not specify a message text for a particular plural case, the
* message text of the plural case "<code>other</code>" gets assigned to this
* plural case.
- * </p><p>
+ * <p>
* When formatting, the input number is first matched against the explicitValue clauses.
* If there is no exact-number match, then a keyword is selected by calling
* the <code>PluralRules</code> with the input number <em>minus the offset</em>.
* (The offset defaults to 0 if it is omitted from the pattern string.)
* If there is no clause with that keyword, then the "other" clauses is returned.
- * </p><p>
+ * <p>
* An unquoted pound sign (<code>#</code>) in the selected sub-message
* itself (i.e., outside of arguments nested in the sub-message)
* is replaced by the input number minus the offset.
* <strong>Note:</strong> That argument is formatting without subtracting the offset!
* If you need a custom format and have a non-zero offset, then you need to pass the
* number-minus-offset value as a separate parameter.
- * </p>
- * For a usage example, see the {@link MessageFormat} class documentation.
+ *
+ * <p>For a usage example, see the {@link MessageFormat} class documentation.
*
* <h4>Defining Custom Plural Rules</h4>
* <p>If you need to use <code>PluralFormat</code> with custom rules, you can
* <code>PluralFormat</code>'s constructor. If you also specify a locale in this
* constructor, this locale will be used to format the number in the message
* texts.
- * </p><p>
+ * <p>
* For more information about <code>PluralRules</code>, see
* {@link PluralRules}.
- * </p>
*
* @author tschumann (Tim Schumann)
* @stable ICU 3.8
/**
* Returns the 'functionally equivalent' locale with respect to plural rules. Calling PluralRules.forLocale with
- * the functionally equivalent locale, and with the provided locale, returns rules that behave the same. <br/>
+ * the functionally equivalent locale, and with the provided locale, returns rules that behave the same. <br>
* All locales with the same functionally equivalent locale have plural rules that behave the same. This is not
* exaustive; there may be other locales whose plural rules behave the same that do not have the same equivalent
* locale.
* @param locale
* the locale to check
* @param isAvailable
- * if not null and of length > 0, this will hold 'true' at index 0 if locale is directly defined
+ * if not null and of length > 0, this will hold 'true' at index 0 if locale is directly defined
* (without fallback) as having plural rules
* @return the functionally-equivalent locale
* @internal
* Returns the 'functionally equivalent' locale with respect to
* plural rules. Calling PluralRules.forLocale with the functionally equivalent
* locale, and with the provided locale, returns rules that behave the same.
- * <br/>
+ * <br>
* All locales with the same functionally equivalent locale have
* plural rules that behave the same. This is not exaustive;
* there may be other locales whose plural rules behave the same
* that do not have the same equivalent locale.
*
* @param locale the locale to check
- * @param isAvailable if not null and of length > 0, this will hold 'true' at
+ * @param isAvailable if not null and of length > 0, this will hold 'true' at
* index 0 if locale is directly defined (without fallback) as having plural rules
* @return the functionally-equivalent locale
* @draft ICU 4.2 (retain)
/*
*******************************************************************************
- * Copyright (C) 1996-2004, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* <code>dstStart + (srcLimit-srcStart) - 1</code>.
*
* @param srcStart the beginning index to copy, inclusive; <code>0
- * <= start <= limit</code>.
+ * <= start <= limit</code>.
* @param srcLimit the ending index to copy, exclusive;
- * <code>start <= limit <= length()</code>.
+ * <code>start <= limit <= length()</code>.
* @param dst the destination array.
* @param dstStart the start offset in the destination array.
* @stable ICU 2.0
* check for initial and trailing identical characters, and make a
* smaller replacement if possible. This will preserve as much
* metadata as possible.
- * @param start the beginning index, inclusive; <code>0 <= start
- * <= limit</code>.
- * @param limit the ending index, exclusive; <code>start <= limit
- * <= length()</code>.
+ * @param start the beginning index, inclusive; <code>0 <= start
+ * <= limit</code>.
+ * @param limit the ending index, exclusive; <code>start <= limit
+ * <= length()</code>.
* @param text the text to replace characters <code>start</code>
* to <code>limit - 1</code>
* @stable ICU 2.0
* check for initial and trailing identical characters, and make a
* smaller replacement if possible. This will preserve as much
* metadata as possible.
- * @param start the beginning index, inclusive; <code>0 <= start
- * <= limit</code>.
- * @param limit the ending index, exclusive; <code>start <= limit
- * <= length()</code>.
+ * @param start the beginning index, inclusive; <code>0 <= start
+ * <= limit</code>.
+ * @param limit the ending index, exclusive; <code>start <= limit
+ * <= length()</code>.
* @param chars the text to replace characters <code>start</code>
* to <code>limit - 1</code>
* @param charsStart the beginning index into <code>chars</code>,
- * inclusive; <code>0 <= start <= limit</code>.
+ * inclusive; <code>0 <= start <= limit</code>.
* @param charsLen the number of characters of <code>chars</code>.
* @stable ICU 2.0
*/
* getChars(start, limit, text, 0);
* replace(dest, dest, text, 0, limit - start);</pre>
*
- * @param start the beginning index, inclusive; <code>0 <= start <=
+ * @param start the beginning index, inclusive; <code>0 <= start <=
* limit</code>.
- * @param limit the ending index, exclusive; <code>start <= limit <=
+ * @param limit the ending index, exclusive; <code>start <= limit <=
* length()</code>.
* @param dest the destination index. The characters from
* <code>start..limit-1</code> will be copied to <code>dest</code>.
- * Implementations of this method may assume that <code>dest <= start ||
- * dest >= limit</code>.
+ * Implementations of this method may assume that <code>dest <= start ||
+ * dest >= limit</code>.
* @stable ICU 2.0
*/
void copy(int start, int limit, int dest);
- /**
+ /**R
* Returns true if this object contains metadata. If a
* Replaceable object has metadata, calls to the Replaceable API
* must be made so as to preserve metadata. If it does not, calls
/*
*******************************************************************************
- * Copyright (C) 1996-2009, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* <code>dstStart + (srcLimit-srcStart) - 1</code>.
*
* @param srcStart the beginning index to copy, inclusive; <code>0
- * <= start <= limit</code>.
+ * <= start <= limit</code>.
* @param srcLimit the ending index to copy, exclusive;
- * <code>start <= limit <= length()</code>.
+ * <code>start <= limit <= length()</code>.
* @param dst the destination array.
* @param dstStart the start offset in the destination array.
* @stable ICU 2.0
/**
* Replace zero or more characters with new characters.
* <code>Replaceable</code> API.
- * @param start the beginning index, inclusive; <code>0 <= start
- * <= limit</code>.
- * @param limit the ending index, exclusive; <code>start <= limit
- * <= length()</code>.
+ * @param start the beginning index, inclusive; <code>0 <= start
+ * <= limit</code>.
+ * @param limit the ending index, exclusive; <code>start <= limit
+ * <= length()</code>.
* @param text new text to replace characters <code>start</code> to
* <code>limit - 1</code>
* @stable ICU 2.0
/**
* Replace a substring of this object with the given text.
- * @param start the beginning index, inclusive; <code>0 <= start
- * <= limit</code>.
- * @param limit the ending index, exclusive; <code>start <= limit
- * <= length()</code>.
+ * @param start the beginning index, inclusive; <code>0 <= start
+ * <= limit</code>.
+ * @param limit the ending index, exclusive; <code>start <= limit
+ * <= length()</code>.
* @param chars the text to replace characters <code>start</code>
* to <code>limit - 1</code>
* @param charsStart the beginning index into <code>chars</code>,
- * inclusive; <code>0 <= start <= limit</code>.
+ * inclusive; <code>0 <= start <= limit</code>.
* @param charsLen the number of characters of <code>chars</code>.
* @stable ICU 2.0
*/
* information. This method is used to duplicate or reorder substrings.
* The destination index must not overlap the source range.
*
- * @param start the beginning index, inclusive; <code>0 <= start <=
+ * @param start the beginning index, inclusive; <code>0 <= start <=
* limit</code>.
- * @param limit the ending index, exclusive; <code>start <= limit <=
+ * @param limit the ending index, exclusive; <code>start <= limit <=
* length()</code>.
* @param dest the destination index. The characters from
* <code>start..limit-1</code> will be copied to <code>dest</code>.
- * Implementations of this method may assume that <code>dest <= start ||
- * dest >= limit</code>.
+ * Implementations of this method may assume that <code>dest <= start ||
+ * dest >= limit</code>.
* @stable ICU 2.0
*/
public void copy(int start, int limit, int dest) {
/*
*******************************************************************************
- * Copyright (C) 2005-2015 International Business Machines Corporation and
+ * Copyright (C) 2005-2016 International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
}
/**
- * Throw IllegalArgumentException unless begin <= offset < end.
+ * Throw IllegalArgumentException unless begin <= offset < end.
* @stable ICU 2.0
*/
protected static final void checkOffset(int offset, CharacterIterator text) {
* that contain alphabetic letters, "words" that appear to be numbers,
* punctuation and spaces, words containing ideographic characters, and
* more. Call <code>getRuleStatus</code> after obtaining a boundary
- * position from <code>next()<code>, <code>previous()</code>, or
+ * position from <code>next()</code>, <code>previous()</code>, or
* any other break iterator functions that returns a boundary position.
* <p>
* @return the status from the break rule that determined the most recently
/*
*******************************************************************************
- * Copyright (C) 1996-2015, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
*
* <table border="0" width="630">
* <tr>
- * <td width="21"></td>
- * <td width="257" valign="top"><strong><< thousand >></strong></td>
- * <td width="340" valign="top">[the rule whose base value is 1,000 is applicable to 25,340]</td>
+ * <td style="width: 21;"></td>
+ * <td style="width: 257; vertical-align: top;"><strong><< thousand >></strong></td>
+ * <td style="width: 340; vertical-align: top;">[the rule whose base value is 1,000 is applicable to 25,340]</td>
* </tr>
* <tr>
- * <td width="21"></td>
- * <td width="257" valign="top"><strong>twenty->></strong> thousand >></td>
- * <td width="340" valign="top">[25,340 over 1,000 is 25. The rule for 20 applies.]</td>
+ * <td style="width: 21;"></td>
+ * <td style="width: 257; vertical-align: top;"><strong>twenty->></strong> thousand >></td>
+ * <td style="width: 340; vertical-align: top;">[25,340 over 1,000 is 25. The rule for 20 applies.]</td>
* </tr>
* <tr>
- * <td width="21"></td>
- * <td width="257" valign="top">twenty-<strong>five</strong> thousand >></td>
- * <td width="340" valign="top">[25 mod 10 is 5. The rule for 5 is "five."</td>
+ * <td style="width: 21;"></td>
+ * <td style="width: 257; vertical-align: top;">twenty-<strong>five</strong> thousand >></td>
+ * <td style="width: 340; vertical-align: top;">[25 mod 10 is 5. The rule for 5 is "five."</td>
* </tr>
* <tr>
- * <td width="21"></td>
- * <td width="257" valign="top">twenty-five thousand <strong><< hundred >></strong></td>
- * <td width="340" valign="top">[25,340 mod 1,000 is 340. The rule for 100 applies.]</td>
+ * <td style="width: 21;"></td>
+ * <td style="width: 257; vertical-align: top;">twenty-five thousand <strong><< hundred >></strong></td>
+ * <td style="width: 340; vertical-align: top;">[25,340 mod 1,000 is 340. The rule for 100 applies.]</td>
* </tr>
* <tr>
- * <td width="21"></td>
- * <td width="257" valign="top">twenty-five thousand <strong>three</strong> hundred >></td>
- * <td width="340" valign="top">[340 over 100 is 3. The rule for 3 is "three."]</td>
+ * <td style="width: 21;"></td>
+ * <td style="width: 257; vertical-align: top;">twenty-five thousand <strong>three</strong> hundred >></td>
+ * <td style="width: 340; vertical-align: top;">[340 over 100 is 3. The rule for 3 is "three."]</td>
* </tr>
* <tr>
- * <td width="21"></td>
- * <td width="257" valign="top">twenty-five thousand three hundred <strong>forty</strong></td>
- * <td width="340" valign="top">[340 mod 100 is 40. The rule for 40 applies. Since 40 divides
+ * <td style="width: 21;"></td>
+ * <td style="width: 257; vertical-align: top;">twenty-five thousand three hundred <strong>forty</strong></td>
+ * <td style="width: 340; vertical-align: top;">[340 mod 100 is 40. The rule for 40 applies. Since 40 divides
* evenly by 10, the hyphen and substitution in the brackets are omitted.]</td>
* </tr>
* </table>
*
* <table border="0" width="100%">
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top"><em>bv</em>:</td>
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;"><em>bv</em>:</td>
* <td valign="top"><em>bv</em> specifies the rule's base value. <em>bv</em> is a decimal
* number expressed using ASCII digits. <em>bv</em> may contain spaces, period, and commas,
* which are ignored. The rule's divisor is the highest power of 10 less than or equal to
* the base value.</td>
* </tr>
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top"><em>bv</em>/<em>rad</em>:</td>
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;"><em>bv</em>/<em>rad</em>:</td>
* <td valign="top"><em>bv</em> specifies the rule's base value. The rule's divisor is the
* highest power of <em>rad</em> less than or equal to the base value.</td>
* </tr>
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top"><em>bv</em>>:</td>
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;"><em>bv</em>>:</td>
* <td valign="top"><em>bv</em> specifies the rule's base value. To calculate the divisor,
* let the radix be 10, and the exponent be the highest exponent of the radix that yields a
* result less than or equal to the base value. Every > character after the base value
* raised to the power of the exponent; otherwise, the divisor is 1.</td>
* </tr>
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top"><em>bv</em>/<em>rad</em>>:</td>
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;"><em>bv</em>/<em>rad</em>>:</td>
* <td valign="top"><em>bv</em> specifies the rule's base value. To calculate the divisor,
* let the radix be <em>rad</em>, and the exponent be the highest exponent of the radix that
* yields a result less than or equal to the base value. Every > character after the radix
* raised to the power of the exponent; otherwise, the divisor is 1.</td>
* </tr>
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top">-x:</td>
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;">-x:</td>
* <td valign="top">The rule is a negative-number rule.</td>
* </tr>
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top">x.x:</td>
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;">x.x:</td>
* <td valign="top">The rule is an <em>improper fraction rule</em>. If the full stop in
* the middle of the rule name is replaced with the decimal point
* that is used in the language or DecimalFormatSymbols, then that rule will
* the punctuation of either the full stop or comma.</td>
* </tr>
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top">0.x:</td>
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;">0.x:</td>
* <td valign="top">The rule is a <em>proper fraction rule</em>. If the full stop in
* the middle of the rule name is replaced with the decimal point
* that is used in the language or DecimalFormatSymbols, then that rule will
* the punctuation of either the full stop or comma</td>
* </tr>
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top">x.0:</td>
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;">x.0:</td>
* <td valign="top">The rule is a <em>master rule</em>. If the full stop in
* the middle of the rule name is replaced with the decimal point
* that is used in the language or DecimalFormatSymbols, then that rule will
* the punctuation of either the full stop or comma</td>
* </tr>
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top">Inf:</td>
- * <td valign="top">The rule for infinity.</td>
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;">Inf:</td>
+ * <td style="vertical-align: top;">The rule for infinity.</td>
* </tr>
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top">NaN:</td>
- * <td valign="top">The rule for an IEEE 754 NaN (not a number).</td>
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;">NaN:</td>
+ * <td style="vertical-align: top;">The rule for an IEEE 754 NaN (not a number).</td>
* </tr>
* <tr>
- * <td width="5%" valign="top"></td>
- * <td width="8%" valign="top"><em>nothing</em></td>
- * <td valign="top">If the rule's rule descriptor is left out, the base value is one plus the
+ * <td style="width: 5%; vertical-align: top;"></td>
+ * <td style="width: 8%; vertical-align: top;"><em>nothing</em></td>
+ * <td style="vertical-align: top;">If the rule's rule descriptor is left out, the base value is one plus the
* preceding rule's base value (or zero if this is the first rule in the list) in a normal
* rule set. In a fraction rule set, the base value is the same as the preceding rule's
* base value.</td>
*
* <table border="0" width="100%">
* <tr>
- * <td width="37"></td>
- * <td width="23">>></td>
- * <td width="165" valign="top">in normal rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;">>></td>
+ * <td style="width: 165; vertical-align: top;">in normal rule</td>
* <td>Divide the number by the rule's divisor and format the remainder</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in negative-number rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in negative-number rule</td>
* <td>Find the absolute value of the number and format the result</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in fraction or master rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in fraction or master rule</td>
* <td>Isolate the number's fractional part and format it.</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in rule in fraction rule set</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in rule in fraction rule set</td>
* <td>Not allowed.</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23">>>></td>
- * <td width="165" valign="top">in normal rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;">>>></td>
+ * <td style="width: 165; vertical-align: top;">in normal rule</td>
* <td>Divide the number by the rule's divisor and format the remainder,
* but bypass the normal rule-selection process and just use the
* rule that precedes this one in this rule list.</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in all other rules</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in all other rules</td>
* <td>Not allowed.</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"><<</td>
- * <td width="165" valign="top">in normal rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"><<</td>
+ * <td style="width: 165; vertical-align: top;">in normal rule</td>
* <td>Divide the number by the rule's divisor and format the quotient</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in negative-number rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in negative-number rule</td>
* <td>Not allowed.</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in fraction or master rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in fraction or master rule</td>
* <td>Isolate the number's integral part and format it.</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in rule in fraction rule set</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in rule in fraction rule set</td>
* <td>Multiply the number by the rule's base value and format the result.</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23">==</td>
- * <td width="165" valign="top">in all rule sets</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;">==</td>
+ * <td style="width: 165; vertical-align: top;">in all rule sets</td>
* <td>Format the number unchanged</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23">[]</td>
- * <td width="165" valign="top">in normal rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;">[]</td>
+ * <td style="width: 165; vertical-align: top;">in normal rule</td>
* <td>Omit the optional text if the number is an even multiple of the rule's divisor</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in negative-number rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in negative-number rule</td>
* <td>Not allowed.</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in improper-fraction rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in improper-fraction rule</td>
* <td>Omit the optional text if the number is between 0 and 1 (same as specifying both an
* x.x rule and a 0.x rule)</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in master rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in master rule</td>
* <td>Omit the optional text if the number is an integer (same as specifying both an x.x
* rule and an x.0 rule)</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in proper-fraction rule</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in proper-fraction rule</td>
* <td>Not allowed.</td>
* </tr>
* <tr>
- * <td width="37"></td>
- * <td width="23"></td>
- * <td width="165" valign="top">in rule in fraction rule set</td>
+ * <td style="width: 37;"></td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in rule in fraction rule set</td>
* <td>Omit the optional text if multiplying the number by the rule's base value yields 1.</td>
* </tr>
* <tr>
- * <td width="37">$(cardinal,<i>plural syntax</i>)$</td>
- * <td width="23"></td>
- * <td width="165" valign="top">in all rule sets</td>
+ * <td style="width: 37;">$(cardinal,<i>plural syntax</i>)$</td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in all rule sets</td>
* <td>This provides the ability to choose a word based on the number divided by the radix to the power of the
* exponent of the base value for the specified locale, which is normally equivalent to the << value.
* This uses the cardinal plural rules from PluralFormat. All strings used in the plural format are treated
* as the same base value for parsing.</td>
* </tr>
* <tr>
- * <td width="37">$(ordinal,<i>plural syntax</i>)$</td>
- * <td width="23"></td>
- * <td width="165" valign="top">in all rule sets</td>
+ * <td style="width: 37;">$(ordinal,<i>plural syntax</i>)$</td>
+ * <td style="width: 23;"></td>
+ * <td style="width: 165; vertical-align: top;">in all rule sets</td>
* <td>This provides the ability to choose a word based on the number divided by the radix to the power of the
* exponent of the base value for the specified locale, which is normally equivalent to the << value.
* This uses the ordinal plural rules from PluralFormat. All strings used in the plural format are treated
*
* <table border="0" width="100%">
* <tr>
- * <td width="42"></td>
- * <td width="166" valign="top">a rule set name</td>
+ * <td style="width: 42;"></td>
+ * <td style="width: 166; vertical-align: top;">a rule set name</td>
* <td>Perform the mathematical operation on the number, and format the result using the
* named rule set.</td>
* </tr>
* <tr>
- * <td width="42"></td>
- * <td width="166" valign="top">a DecimalFormat pattern</td>
+ * <td style="width: 42;"></td>
+ * <td style="width: 166; vertical-align: top;">a DecimalFormat pattern</td>
* <td>Perform the mathematical operation on the number, and format the result using a
* DecimalFormat with the specified pattern. The pattern must begin with 0 or #.</td>
* </tr>
* <tr>
- * <td width="42"></td>
- * <td width="166" valign="top">nothing</td>
+ * <td style="width: 42;"></td>
+ * <td style="width: 166; vertical-align: top;">nothing</td>
* <td>Perform the mathematical operation on the number, and format the result using the rule
* set containing the current rule, except:<ul>
* <li>You can't have an empty substitution descriptor with a == substitution.</li>
}
/**
- * <strong><font face=helvetica color=red>NEW</font></strong>
+ * <strong style="font-family: helvetica; color: red;">NEW</strong>
* Implement com.ibm.icu.text.NumberFormat:
* Format a BigInteger.
* @stable ICU 2.0
}
/**
- * <strong><font face=helvetica color=red>NEW</font></strong>
+ * <strong style="font-family: helvetica; color: red;">NEW</strong>
* Implement com.ibm.icu.text.NumberFormat:
* Format a BigDecimal.
* @stable ICU 2.0
}
/**
- * <strong><font face=helvetica color=red>NEW</font></strong>
+ * <strong style="font-family: helvetica; color: red;">NEW</strong>
* Implement com.ibm.icu.text.NumberFormat:
* Format a BigDecimal.
* @stable ICU 2.0
/*
*******************************************************************************
- * Copyright (C) 2014, International Business Machines Corporation and
+ * Copyright (C) 2014-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* <pre>
* ULocale en = new ULocale("en");
* ScientificNumberFormatter fmt = ScientificNumberFormatter.getMarkupInstance(
- * en, "<sup>", "</sup>");
+ * en, "<sup>", "</sup>");
+ * </pre>
* <pre>
- * // Output: "1.23456×10<sup>-78</sup>"
+ * // Output: "1.23456×10<sup>-78</sup>"
* System.out.println(fmt.format(1.23456e-78));
* </pre>
*
/*
*******************************************************************************
- * Copyright (C) 2004-2011, International Business Machines Corporation and *
+ * Copyright (C) 2004-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
* Copyright (C) 2009 , Yahoo! Inc. *
*******************************************************************************
* how to map keywords to phrases and provides a default phrase. The
* object provided to the format method is a string that's matched
* against the keywords. If there is a match, the corresponding phrase
- * is selected; otherwise, the default phrase is used.</p>
+ * is selected; otherwise, the default phrase is used.
*
- * <h4>Using <code>SelectFormat</code> for Gender Agreement</h4>
+ * <h3>Using <code>SelectFormat</code> for Gender Agreement</h3>
*
* <p>Note: Typically, select formatting is done via <code>MessageFormat</code>
* with a <code>select</code> argument type,
- * rather than using a stand-alone <code>SelectFormat</code>.</p>
+ * rather than using a stand-alone <code>SelectFormat</code>.
*
* <p>The main use case for the select format is gender based inflection.
* When names or nouns are inserted into sentences, their gender can affect pronouns,
* verb forms, articles, and adjectives. Special care needs to be
* taken for the case where the gender cannot be determined.
- * The impact varies between languages:</p>
+ * The impact varies between languages:
*
* <ul>
* <li>English has three genders, and unknown gender is handled as a special
* The gender only affects pronouns: "he", "she", "it", "they".
*
* <li>German differs from English in that the gender of nouns is rather
- * arbitrary, even for nouns referring to people ("M&#u00E4;dchen", girl, is neutral).
+ * arbitrary, even for nouns referring to people ("Mädchen", girl, is neutral).
* The gender affects pronouns ("er", "sie", "es"), articles ("der", "die",
- * "das"), and adjective forms ("guter Mann", "gute Frau", "gutes M&#u00E4;dchen").
+ * "das"), and adjective forms ("guter Mann", "gute Frau", "gutes Mädchen").
*
* <li>French has only two genders; as in German the gender of nouns
* is rather arbitrary - for sun and moon, the genders
* are the opposite of those in German. The gender affects
* pronouns ("il", "elle"), articles ("le", "la"),
* adjective forms ("bon", "bonne"), and sometimes
- * verb forms ("all&#u00E9;", "all&#u00E9e;").
+ * verb forms ("allé", "allée").
*
* <li>Polish distinguishes five genders (or noun classes),
* human masculine, animate non-human masculine, inanimate masculine,
*
* <p>Some other languages have noun classes that are not related to gender,
* but similar in grammatical use.
- * Some African languages have around 20 noun classes.</p>
+ * Some African languages have around 20 noun classes.
*
* <p><b>Note:</b>For the gender of a <i>person</i> in a given sentence,
- * we usually need to distinguish only between female, male and other/unknown.</p>
+ * we usually need to distinguish only between female, male and other/unknown.
*
* <p>To enable localizers to create sentence patterns that take their
* language's gender dependencies into consideration, software has to provide
* information about the gender associated with a noun or name to
* <code>MessageFormat</code>.
- * Two main cases can be distinguished:</p>
+ * Two main cases can be distinguished:
*
* <ul>
* <li>For people, natural gender information should be maintained for each person.
* would be provided: The name of the person as argument 0, the gender of
* the person as argument 1, and the name of the city as argument 2.
* The sentence pattern for English, where the gender of the person has
- * no impact on this simple sentence, would not refer to argument 1 at all:</p>
+ * no impact on this simple sentence, would not refer to argument 1 at all:
*
* <pre>{0} went to {2}.</pre>
*
* <p><b>Note:</b> The entire sentence should be included (and partially repeated)
* inside each phrase. Otherwise translators would have to be trained on how to
* move bits of the sentence in and out of the select argument of a message.
- * (The examples below do not follow this recommendation!)</p>
+ * (The examples below do not follow this recommendation!)
*
* <p>The sentence pattern for French, where the gender of the person affects
- * the form of the participle, uses a select format based on argument 1:</p>
+ * the form of the participle, uses a select format based on argument 1:
*
- * <pre>{0} est {1, select, female {all&#u00E9;e} other {all&#u00E9;}} &#u00E0; {2}.</pre>
+ * <pre>{0} est {1, select, female {allée} other {allé}} à {2}.</pre>
*
* <p>Patterns can be nested, so that it's possible to handle interactions of
* number and gender where necessary. For example, if the above sentence should
* allow for the names of several people to be inserted, the following sentence
* pattern can be used (with argument 0 the list of people's names,
* argument 1 the number of people, argument 2 their combined gender, and
- * argument 3 the city name):</p>
+ * argument 3 the city name):
*
* <pre>{0} {1, plural,
- * one {est {2, select, female {all&#u00E9;e} other {all&#u00E9;}}}
- * other {sont {2, select, female {all&#u00E9;es} other {all&#u00E9;s}}}
- * }&#u00E0; {3}.</pre>
+ * one {est {2, select, female {allée} other {allé}}}
+ * other {sont {2, select, female {allées} other {allés}}}
+ * }à {3}.</pre>
*
* <h4>Patterns and Their Interpretation</h4>
*
* <p>The <code>SelectFormat</code> pattern string defines the phrase output
* for each user-defined keyword.
* The pattern is a sequence of (keyword, message) pairs.
- * A keyword is a "pattern identifier": [^[[:Pattern_Syntax:][:Pattern_White_Space:]]]+</p>
+ * A keyword is a "pattern identifier": [^[[:Pattern_Syntax:][:Pattern_White_Space:]]]+
*
- * <p>Each message is a MessageFormat pattern string enclosed in {curly braces}.</p>
+ * <p>Each message is a MessageFormat pattern string enclosed in {curly braces}.
*
* <p>You always have to define a phrase for the default keyword
* <code>other</code>; this phrase is returned when the keyword
* the <code>format</code> method matches no other keyword.
* If a pattern does not provide a phrase for <code>other</code>, the method
* it's provided to returns the error <code>U_DEFAULT_KEYWORD_MISSING</code>.
- * <br/>
+ * <br>
* Pattern_White_Space between keywords and messages is ignored.
- * Pattern_White_Space within a message is preserved and output.</p>
+ * Pattern_White_Space within a message is preserved and output.
*
- * <p><pre>Example:
+ * <pre>Example:
* MessageFormat msgFmt = new MessageFormat("{0} est " +
- * "{1, select, female {all&#u00E9;e} other {all&#u00E9;}} &#u00E0; Paris.",
+ * "{1, select, female {allée} other {allé}} à Paris.",
* new ULocale("fr"));
* Object args[] = {"Kirti","female"};
* System.out.println(msgFmt.format(args));
* </pre>
* <p>
- * Produces the output:<br/>
- * <code>Kirti est all&#u00E9;e &#u00E0; Paris.</code>
- * </p>
+ * Produces the output:<br>
+ * <code>Kirti est allée à Paris.</code>
*
* @stable ICU 4.4
*/
*
* <p><code>SimpleDateFormat</code> is a concrete class for formatting and
* parsing dates in a locale-sensitive manner. It allows for formatting
- * (date -> text), parsing (text -> date), and normalization.
+ * (date -> text), parsing (text -> date), and normalization.
*
* <p>
* <code>SimpleDateFormat</code> allows you to start by choosing
* <td style="text-align: center">1..n</td>
* <td>1996</td>
* <td>Year. Normally the length specifies the padding, but for two letters it also specifies the maximum
- * length. Example:<div align="center">
+ * length. Example:<div style="text-align: center">
* <center>
* <table border="1" cellpadding="2" cellspacing="0">
* <tr>
* <pre>
* Format Pattern Result
* -------------- -------
- * "yyyy.MM.dd G 'at' HH:mm:ss vvvv" ->> 1996.07.10 AD at 15:08:56 Pacific Time
- * "EEE, MMM d, ''yy" ->> Wed, July 10, '96
- * "h:mm a" ->> 12:08 PM
- * "hh 'o''clock' a, zzzz" ->> 12 o'clock PM, Pacific Daylight Time
- * "K:mm a, vvv" ->> 0:00 PM, PT
- * "yyyyy.MMMMM.dd GGG hh:mm aaa" ->> 01996.July.10 AD 12:08 PM
+ * "yyyy.MM.dd G 'at' HH:mm:ss vvvv" ->> 1996.07.10 AD at 15:08:56 Pacific Time
+ * "EEE, MMM d, ''yy" ->> Wed, July 10, '96
+ * "h:mm a" ->> 12:08 PM
+ * "hh 'o''clock' a, zzzz" ->> 12 o'clock PM, Pacific Daylight Time
+ * "K:mm a, vvv" ->> 0:00 PM, PT
+ * "yyyyy.MMMMM.dd GGG hh:mm aaa" ->> 01996.July.10 AD 12:08 PM
* </pre>
* </blockquote>
* <strong>Code Sample:</strong>
* time zone. There is one common decimal format to handle all the numbers;
* the digit count is handled programmatically according to the pattern.
*
- * <h4>Synchronization</h4>
+ * <h3>Synchronization</h3>
*
* Date formats are not synchronized. It is recommended to create separate
* format instances for each thread. If multiple threads access a format
* Formats a date or time, which is the standard millis
* since January 1, 1970, 00:00:00 GMT.
* <p>Example: using the US locale:
- * "yyyy.MM.dd G 'at' HH:mm:ss zzz" ->> 1996.07.10 AD at 15:08:56 PDT
+ * "yyyy.MM.dd G 'at' HH:mm:ss zzz" ->> 1996.07.10 AD at 15:08:56 PDT
* @param cal the calendar whose date-time value is to be formatted into a date-time string
* @param toAppendTo where the new date-time text is to be appended
* @param pos the formatting position. On input: an alignment field,
/**
* Returns a frozen instance of <code>TimeZoneFormat</code> for the given
- * {@link java.text.Locale}.
+ * {@link java.util.Locale}.
* <p><b>Note</b>: The instance returned by this method is frozen. If you want to
* customize a TimeZoneFormat, you must use {@link #cloneAsThawed()} to get a
* thawed copy first.
/**
* Sets the default parse options.
* <p>
- * <b>Note:</b> By default, an instance of <code>TimeZoneFormat></code>
+ * <b>Note:</b> By default, an instance of <code>TimeZoneFormat</code>
* created by {#link {@link #getInstance(ULocale)} has no parse options set.
*
* @param options the default parse options.
* @serialField _locale ULocale The locale of this TimeZoneFormat object.
* @serialField _tznames TimeZoneNames The time zone name data.
* @serialField _gmtPattern String The pattern string for localized GMT format.
- * @serialField _gmtOffsetPatterns Stirng[] The array of GMT offset patterns used by localized GMT format
+ * @serialField _gmtOffsetPatterns String[] The array of GMT offset patterns used by localized GMT format
* (positive hour-min, positive hour-min-sec, negative hour-min, negative hour-min-sec).
* @serialField _gmtOffsetDigits String[] The array of decimal digits used by localized GMT format
* (the size of array is 10).
/*
*******************************************************************************
- * Copyright (C) 1996-2015, International Business Machines Corporation and
+ * Copyright (C) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* iterator obtained by calling <code>getLength()</code>).
* <b>Usage:</b>
*
- * <code>
* <pre>
* UChacterIterator iter = new UCharacterIterator.getInstance(text);
* char[] buf = new char[iter.getLength()];
* }
* }
* </pre>
- * </code>
- *
+ *
* @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.
+ * room after offset in the array, or if offset < 0.
* @stable ICU 2.4
*/
public abstract int getText(char[] fillIn, int offset);
/*
*******************************************************************************
- * Copyright (C) 1996-2004, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* Some processes may be designed to work with sequences of code units,
* or it may be known that all characters that are important to an
* algorithm can be represented with single code units.
- * Other processes will need to use the code point access functions.</p>
+ * Other processes will need to use the code point access functions.
*
* <p>ForwardCharacterIterator provides next() to access
* a code unit and advance an internal position into the text object,
* similar to a <code>return text[position++]</code>.<br>
* It provides nextCodePoint() to access a code point and advance an internal
- * position.</p>
+ * position.
*
* <p>nextCodePoint() assumes that the current position is that of
* the beginning of a code point, i.e., of its first code unit.
* In general, access to code units and code points in the same
* iteration loop should not be mixed. In UTF-16, if the current position
* is on a second code unit (Low Surrogate), then only that code unit
- * is returned even by nextCodePoint().</p>
+ * is returned even by nextCodePoint().
*
* Usage:
* <code>
* }
* }
* </code>
- * </p>
* @stable ICU 2.4
*
*/
* Returns the code point at index, and increments to the next code
* point (post-increment semantics). If index does not point to a
* valid surrogate pair, the behavior is the same as
- * <code>next()<code>. Otherwise the iterator is incremented past
+ * <code>next()</code>. Otherwise the iterator is incremented past
* the surrogate pair, and the code point represented by the pair
* is returned.
* @return the next codepoint in text, or DONE if the index is at
/**
*******************************************************************************
- * Copyright (C) 1996-2015, International Business Machines Corporation and
+ * Copyright (C) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
// public variables ---------------------------------------------------
/**
- * Value returned in <code><a href="#bounds(java.lang.String, int)">
- * bounds()</a></code>.
+ * Value returned in {@link #bounds(String, int) bounds()}.
* These values are chosen specifically so that it actually represents the position of the
- * character [offset16 - (value >> 2), offset16 + (value & 3)]
+ * character [offset16 - (value >> 2), offset16 + (value & 3)]
*
* @stable ICU 2.1
*/
* bounds are [offset16 - 1, offset16 + 1]
* </ul>
* For bit-twiddlers, the return values for these are chosen so that the boundaries
- * can be gotten by: [offset16 - (value >> 2), offset16 + (value & 3)].
+ * can be gotten by: [offset16 - (value >> 2), offset16 + (value & 3)].
* @exception IndexOutOfBoundsException If offset16 is out of bounds.
* @stable ICU 2.1
*/
* bounds are [offset16 - 1, offset16 + 1]
* </ul>
* For bit-twiddlers, the return values for these are chosen so that the boundaries
- * can be gotten by: [offset16 - (value >> 2), offset16 + (value & 3)].
+ * can be gotten by: [offset16 - (value >> 2), offset16 + (value & 3)].
* @exception IndexOutOfBoundsException If offset16 is out of bounds.
* @stable ICU 2.1
*/
* bounds are [offset16 - 1, offset16 + 1]
* </ul>
* For bit-twiddlers, the boundary values for these are chosen so that the boundaries
- * can be gotten by: [offset16 - (boundvalue >> 2), offset16 + (boundvalue & 3)].
+ * can be gotten by: [offset16 - (boundvalue >> 2), offset16 + (boundvalue & 3)].
* @exception IndexOutOfBoundsException If offset16 is not within the range of start and limit.
* @stable ICU 2.1
*/
/**
* Convenience method corresponding to String.valueOf(char). Returns a one or two char string
- * containing the UTF-32 value in UTF16 format. If a validity check is required, use <a
- * href="../lang/UCharacter.html#isLegal(char)">isLegal()</a></code> on char32 before calling.
+ * containing the UTF-32 value in UTF16 format. If a validity check is required, use
+ * {@link com.ibm.icu.lang.UCharacter#isLegal(int)} on char32 before calling.
*
* @param char32 The input character.
* @return string value of char32 in UTF16 format
* Convenience method corresponding to String.valueOf(codepoint at offset16). Returns a one or
* two char string containing the UTF-32 value in UTF16 format. If offset16 indexes a surrogate
* character, the whole supplementary codepoint will be returned. If a validity check is
- * required, use <a href="../lang/UCharacter.html#isLegal(char)">isLegal()</a></code> on the
+ * required, use {@link com.ibm.icu.lang.UCharacter#isLegal(int)} on the
* codepoint at offset16 before calling. The result returned will be a newly created String
* obtained by calling source.substring(..) with the appropriate indexes.
*
* Convenience method corresponding to StringBuffer.valueOf(codepoint at offset16). Returns a
* one or two char string containing the UTF-32 value in UTF16 format. If offset16 indexes a
* surrogate character, the whole supplementary codepoint will be returned. If a validity check
- * is required, use <a href="../lang/UCharacter.html#isLegal(char)">isLegal()</a></code> on
+ * is required, use {@link com.ibm.icu.lang.UCharacter#isLegal(int)} on
* the codepoint at offset16 before calling. The result returned will be a newly created String
* obtained by calling source.substring(..) with the appropriate indexes.
*
* format. If offset16 indexes a surrogate character, the whole supplementary codepoint will be
* returned, except when either the leading or trailing surrogate character lies out of the
* specified subarray. In the latter case, only the surrogate character within bounds will be
- * returned. If a validity check is required, use <a
- * href="../lang/UCharacter.html#isLegal(char)">isLegal()</a></code> on the codepoint at
+ * returned. If a validity check is required, use
+ * {@link com.ibm.icu.lang.UCharacter#isLegal(int)} on the codepoint at
* offset16 before calling. The result returned will be a newly created String containing the
* relevant characters.
*
/**
* Returns the UTF-16 offset that corresponds to a UTF-32 offset. Used for random access. See
- * the <a name="_top_">class description</a> for notes on roundtripping.
+ * the {@link UTF16 class description} for notes on roundtripping.
*
* @param source The UTF-16 string
* @param offset32 UTF-32 offset
/**
* Returns the UTF-16 offset that corresponds to a UTF-32 offset. Used for random access. See
- * the <a name="_top_">class description</a> for notes on roundtripping.
+ * the {@link UTF16 class description} for notes on roundtripping.
*
* @param source The UTF-16 string buffer
* @param offset32 UTF-32 offset
/**
* Returns the UTF-16 offset that corresponds to a UTF-32 offset. Used for random access. See
- * the <a name="_top_">class description</a> for notes on roundtripping.
+ * the {@link UTF16 class description} for notes on roundtripping.
*
* @param source The UTF-16 char array whose substring is to be analysed
* @param start Offset of the substring to be analysed
/**
* Returns the UTF-32 offset corresponding to the first UTF-32 boundary at or after the given
- * UTF-16 offset. Used for random access. See the <a name="_top_">class description</a> for
+ * UTF-16 offset. Used for random access. See the {@link UTF16 class description} for
* notes on roundtripping.<br>
* <i>Note: If the UTF-16 offset is into the middle of a surrogate pair, then the UTF-32 offset
* of the <strong>lead</strong> of the pair is returned. </i>
* len32 = countCodePoint(source, source.length());
* </pre>
*
- * </p>
- * <p>
- *
* @param source Text to analyse
- * @param offset16 UTF-16 offset < source text length.
+ * @param offset16 UTF-16 offset < source text length.
* @return UTF-32 offset
* @exception IndexOutOfBoundsException If offset16 is out of bounds.
* @stable ICU 2.1
/**
* Returns the UTF-32 offset corresponding to the first UTF-32 boundary at the given UTF-16
- * offset. Used for random access. See the <a name="_top_">class description</a> for notes on
+ * offset. Used for random access. See the {@link UTF16 class description} for notes on
* roundtripping.<br>
* <i>Note: If the UTF-16 offset is into the middle of a surrogate pair, then the UTF-32 offset
* of the <strong>lead</strong> of the pair is returned. </i>
* <pre>
* len32 = countCodePoint(source);
* </pre>
- *
- * </p>
- * <p>
- *
+ *
* @param source Text to analyse
- * @param offset16 UTF-16 offset < source text length.
+ * @param offset16 UTF-16 offset < source text length.
* @return UTF-32 offset
* @exception IndexOutOfBoundsException If offset16 is out of bounds.
* @stable ICU 2.1
/**
* Returns the UTF-32 offset corresponding to the first UTF-32 boundary at the given UTF-16
- * offset. Used for random access. See the <a name="_top_">class description</a> for notes on
+ * offset. Used for random access. See the {@link UTF16 class description} for notes on
* roundtripping.<br>
* <i>Note: If the UTF-16 offset is into the middle of a surrogate pair, then the UTF-32 offset
* of the <strong>lead</strong> of the pair is returned. </i>
* <pre>
* len32 = countCodePoint(source, start, limit);
* </pre>
- *
- * </p>
- * <p>
- *
+ *
* @param source Text to analyse
* @param start Offset of the substring
* @param limit Offset of the substring
/**
* Append a single UTF-32 value to the end of a StringBuffer. If a validity check is required,
- * use <a href="../lang/UCharacter.html#isLegal(char)">isLegal()</a></code> on char32 before
+ * use {@link com.ibm.icu.lang.UCharacter#isLegal(int)} on char32 before
* calling.
*
* @param target The buffer to append to
* The offset argument must be greater than or equal to 0, and less than or equal to the limit.
*
* @param target Char array to insert to
- * @param limit End index of the char array, limit <= target.length
+ * @param limit End index of the char array, limit <= target.length
* @param offset16 Offset which char32 will be inserted in
* @param char32 Codepoint to be inserted
* @return new limit size
* character if the codepoint is a non-supplementary, 2 otherwise).
*
* @param target String buffer to remove codepoint from
- * @param limit End index of the char array, limit <= target.length
+ * @param limit End index of the char array, limit <= target.length
* @param offset16 Offset which the codepoint will be removed
* @return a new limit size
* @exception IndexOutOfBoundsException Thrown if offset16 is invalid.
/**
* Returns the index within the argument UTF16 format Unicode string of the first occurrence of
* the argument codepoint. I.e., the smallest index i such that: <br>
- * (UTF16.charAt(source, i) == char32 && i >= fromIndex) is true.
+ * (UTF16.charAt(source, i) == char32 && i >= fromIndex) is true.
* <p>
* If no such character occurs in this string, then -1 is returned.
* </p>
* efficient than counting all code points in the entire string and comparing that number with a
* threshold. This function may not need to scan the string at all if the length is within a
* certain range, and never needs to count more than 'number + 1' code points. Logically
- * equivalent to (countCodePoint(s) > number). A Unicode code point may occupy either one or two
+ * equivalent to (countCodePoint(s) > number). A Unicode code point may occupy either one or two
* code units.
*
* @param source The input string.
* the entire char array range and comparing that number with a threshold. This function may not
* need to scan the char array at all if start and limit is within a certain range, and never
* needs to count more than 'number + 1' code points. Logically equivalent to
- * (countCodePoint(source, start, limit) > number). A Unicode code point may occupy either one
+ * (countCodePoint(source, start, limit) > number). A Unicode code point may occupy either one
* or two code units.
*
* @param source Array of UTF-16 chars
* more efficient than counting all code points in the entire string buffer and comparing that
* number with a threshold. This function may not need to scan the string buffer at all if the
* length is within a certain range, and never needs to count more than 'number + 1' code
- * points. Logically equivalent to (countCodePoint(s) > number). A Unicode code point may occupy
- * either one or two code units.
+ * points. Logically equivalent to (countCodePoint(s) > number). A Unicode code point may
+ * occupy either one or two code units.
*
* @param source The input string buffer.
* @param number The number of code points in the string buffer is compared against the 'number'
*
* @param a first source string.
* @param b second source string.
- * @return 0 returned if a == b. If a < b, a negative value is returned. Otherwise if a > b,
+ * @return 0 returned if a == b. If a < b, a negative value is returned. Otherwise if a > b,
* a positive value is returned.
* @exception ClassCastException thrown when either a or b is not a String object
* @stable ICU 4.4
* slower = sc.compare(UTF16.valueOf(codePoint), charSequence == null ? "" : charSequence.toString())
* </pre>
* then
- * </pre>
+ * <pre>
* Integer.signum(fast) == Integer.signum(slower)
* </pre>
* @param codePoint to test
/*
*******************************************************************************
- * Copyright (C) 1996-2009, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* // update the no. of bytes written
* totalBytesWritten += bytesWritten;
*
-* } while(totalCharsCompressed < len);
+* } while(totalCharsCompressed < len);
*
* myCompressor.reset(); // reuse compressor
* </PRE>
/*
*******************************************************************************
- * Copyright (C) 1996-2009, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* // update the no. of chars written
* totalCharsWritten += charsWritten;
*
-* } while(totalBytesDecompressed < len);
+* } while(totalBytesDecompressed < len);
*
* myDecompressor.reset(); // reuse decompressor
* </PRE>
/*
*******************************************************************************
- * Copyright (C) 1996-2014, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* <code>UnicodeFilter</code> defines a protocol for selecting a
* subset of the full range (U+0000 to U+FFFF) of Unicode characters.
* Currently, filters are used in conjunction with classes like
- * <a href="Transliterator.html" title="class in com.ibm.icu.text"><code>Transliterator</code></a>
+ * {@link com.ibm.icu.text.Transliterator}
* to only process selected characters through a
* transformation.
* @stable ICU 2.0
/*
*******************************************************************************
- * Copyright (C) 2001-2004, International Business Machines Corporation and *
+ * Copyright (C) 2001-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
public static final int U_MATCH = 2;
/**
- * The character at index i, where i < contextStart || i >= contextLimit,
+ * The character at index i, where i < contextStart || i >= contextLimit,
* is ETHER. This allows explicit matching by rules and UnicodeSets
* of text outside the context. In traditional terms, this allows anchoring
* at the start and/or end.
* the given text at the given offset. Zero, one, or more
* characters may be matched.
*
- * Matching in the forward direction is indicated by limit >
+ * Matching in the forward direction is indicated by limit >
* offset. Characters from offset forwards to limit-1 will be
* considered for matching.
*
- * Matching in the reverse direction is indicated by limit <
+ * Matching in the reverse direction is indicated by limit <
* offset. Characters from offset backwards to limit+1 will be
* considered for matching.
*
/**
* Returns TRUE if this matcher will match a character c, where c
- * & 0xFF == v, at offset, in the forward direction (with limit >
+ * & 0xFF == v, at offset, in the forward direction (with limit >
* offset). This is used by <tt>RuleBasedTransliterator</tt> for
* indexing.
*
/*
*******************************************************************************
- * Copyright (C) 1996-2015, International Business Machines Corporation and
+ * Copyright (C) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
*
* <blockquote>
* <table>
- * <tr align="top">
- * <td nowrap valign="top" align="left"><code>[]</code></td>
- * <td valign="top">No characters</td>
- * </tr><tr align="top">
- * <td nowrap valign="top" align="left"><code>[a]</code></td>
- * <td valign="top">The character 'a'</td>
- * </tr><tr align="top">
- * <td nowrap valign="top" align="left"><code>[ae]</code></td>
- * <td valign="top">The characters 'a' and 'e'</td>
+ * <tr style="vertical-align: top">
+ * <td style="white-space: nowrap; vertical-align: top; horizontal-align: left;"><code>[]</code></td>
+ * <td style="vertical-align: top;">No characters</td>
+ * </tr><tr style="vertical-align: top">
+ * <td style="white-space: nowrap; vertical-align: top; horizontal-align: left;"><code>[a]</code></td>
+ * <td style="vertical-align: top;">The character 'a'</td>
+ * </tr><tr style="vertical-align: top">
+ * <td style="white-space: nowrap; vertical-align: top; horizontal-align: left;"><code>[ae]</code></td>
+ * <td style="vertical-align: top;">The characters 'a' and 'e'</td>
* </tr>
* <tr>
- * <td nowrap valign="top" align="left"><code>[a-e]</code></td>
- * <td valign="top">The characters 'a' through 'e' inclusive, in Unicode code
+ * <td style="white-space: nowrap; vertical-align: top; horizontal-align: left;"><code>[a-e]</code></td>
+ * <td style="vertical-align: top;">The characters 'a' through 'e' inclusive, in Unicode code
* point order</td>
* </tr>
* <tr>
- * <td nowrap valign="top" align="left"><code>[\\u4E01]</code></td>
- * <td valign="top">The character U+4E01</td>
+ * <td style="white-space: nowrap; vertical-align: top; horizontal-align: left;"><code>[\\u4E01]</code></td>
+ * <td style="vertical-align: top;">The character U+4E01</td>
* </tr>
* <tr>
- * <td nowrap valign="top" align="left"><code>[a{ab}{ac}]</code></td>
- * <td valign="top">The character 'a' and the multicharacter strings "ab" and
+ * <td style="white-space: nowrap; vertical-align: top; horizontal-align: left;"><code>[a{ab}{ac}]</code></td>
+ * <td style="vertical-align: top;">The character 'a' and the multicharacter strings "ab" and
* "ac"</td>
* </tr>
* <tr>
- * <td nowrap valign="top" align="left"><code>[\p{Lu}]</code></td>
- * <td valign="top">All characters in the general category Uppercase Letter</td>
+ * <td style="white-space: nowrap; vertical-align: top; horizontal-align: left;"><code>[\p{Lu}]</code></td>
+ * <td style="vertical-align: top;">All characters in the general category Uppercase Letter</td>
* </tr>
* </table>
* </blockquote>
* literal. Thus "[a\\-b]", "[-ab]", and "[ab-]" all indicate the same
* set of three characters, 'a', 'b', and '-'.
*
- * <p>Sets may be intersected using the '&' operator or the asymmetric
+ * <p>Sets may be intersected using the '&' operator or the asymmetric
* set difference may be taken using the '-' operator, for example,
- * "[[:L:]&[\\u0000-\\u0FFF]]" indicates the set of all Unicode letters
- * with values less than 4096. Operators ('&' and '|') have equal
+ * "[[:L:]&[\\u0000-\\u0FFF]]" indicates the set of all Unicode letters
+ * with values less than 4096. Operators ('&' and '|') have equal
* precedence and bind left-to-right. Thus
* "[[:L:]-[a-z]-[\\u0100-\\u01FF]]" is equivalent to
* "[[[:L:]-[a-z]]-[\\u0100-\\u01FF]]". This only really matters for
* difference; intersection is commutative.
*
* <table>
- * <tr valign=top><td nowrap><code>[a]</code><td>The set containing 'a'
- * <tr valign=top><td nowrap><code>[a-z]</code><td>The set containing 'a'
+ * <tr style="vertical-align: top;"><td style="white-space: nowrap;"><code>[a]</code><td>The set containing 'a'
+ * <tr style="vertical-align: top;"><td style="white-space: nowrap;"><code>[a-z]</code><td>The set containing 'a'
* through 'z' and all letters in between, in Unicode order
- * <tr valign=top><td nowrap><code>[^a-z]</code><td>The set containing
+ * <tr style="vertical-align: top;"><td style="white-space: nowrap;"><code>[^a-z]</code><td>The set containing
* all characters but 'a' through 'z',
* that is, U+0000 through 'a'-1 and 'z'+1 through U+10FFFF
- * <tr valign=top><td nowrap><code>[[<em>pat1</em>][<em>pat2</em>]]</code>
+ * <tr style="vertical-align: top;"><td style="white-space: nowrap;"><code>[[<em>pat1</em>][<em>pat2</em>]]</code>
* <td>The union of sets specified by <em>pat1</em> and <em>pat2</em>
- * <tr valign=top><td nowrap><code>[[<em>pat1</em>]&[<em>pat2</em>]]</code>
+ * <tr style="vertical-align: top;"><td style="white-space: nowrap;"><code>[[<em>pat1</em>]&[<em>pat2</em>]]</code>
* <td>The intersection of sets specified by <em>pat1</em> and <em>pat2</em>
- * <tr valign=top><td nowrap><code>[[<em>pat1</em>]-[<em>pat2</em>]]</code>
+ * <tr style="vertical-align: top;"><td style="white-space: nowrap;"><code>[[<em>pat1</em>]-[<em>pat2</em>]]</code>
* <td>The asymmetric difference of sets specified by <em>pat1</em> and
* <em>pat2</em>
- * <tr valign=top><td nowrap><code>[:Lu:] or \p{Lu}</code>
+ * <tr style="vertical-align: top;"><td style="white-space: nowrap;"><code>[:Lu:] or \p{Lu}</code>
* <td>The set of characters having the specified
* Unicode property; in
* this case, Unicode uppercase letters
- * <tr valign=top><td nowrap><code>[:^Lu:] or \P{Lu}</code>
+ * <tr style="vertical-align: top;"><td style="white-space: nowrap;"><code>[:^Lu:] or \P{Lu}</code>
* <td>The set of characters <em>not</em> having the given
* Unicode property
* </table>
*
* <blockquote>
* <table>
- * <tr align="top">
- * <td nowrap valign="top" align="right"><code>pattern := </code></td>
- * <td valign="top"><code>('[' '^'? item* ']') |
+ * <tr style="vertical-align: top">
+ * <td style="white-space: nowrap; vertical-align: top;" align="right"><code>pattern := </code></td>
+ * <td style="vertical-align: top;"><code>('[' '^'? item* ']') |
* property</code></td>
* </tr>
- * <tr align="top">
- * <td nowrap valign="top" align="right"><code>item := </code></td>
- * <td valign="top"><code>char | (char '-' char) | pattern-expr<br>
+ * <tr style="vertical-align: top">
+ * <td style="white-space: nowrap; vertical-align: top;" align="right"><code>item := </code></td>
+ * <td style="vertical-align: top;"><code>char | (char '-' char) | pattern-expr<br>
* </code></td>
* </tr>
- * <tr align="top">
- * <td nowrap valign="top" align="right"><code>pattern-expr := </code></td>
- * <td valign="top"><code>pattern | pattern-expr pattern |
+ * <tr style="vertical-align: top">
+ * <td style="white-space: nowrap; vertical-align: top;" align="right"><code>pattern-expr := </code></td>
+ * <td style="vertical-align: top;"><code>pattern | pattern-expr pattern |
* pattern-expr op pattern<br>
* </code></td>
* </tr>
- * <tr align="top">
- * <td nowrap valign="top" align="right"><code>op := </code></td>
- * <td valign="top"><code>'&' | '-'<br>
+ * <tr style="vertical-align: top">
+ * <td style="white-space: nowrap; vertical-align: top;" align="right"><code>op := </code></td>
+ * <td style="vertical-align: top;"><code>'&' | '-'<br>
* </code></td>
* </tr>
- * <tr align="top">
- * <td nowrap valign="top" align="right"><code>special := </code></td>
- * <td valign="top"><code>'[' | ']' | '-'<br>
+ * <tr style="vertical-align: top">
+ * <td style="white-space: nowrap; vertical-align: top;" align="right"><code>special := </code></td>
+ * <td style="vertical-align: top;"><code>'[' | ']' | '-'<br>
* </code></td>
* </tr>
- * <tr align="top">
- * <td nowrap valign="top" align="right"><code>char := </code></td>
- * <td valign="top"><em>any character that is not</em><code> special<br>
+ * <tr style="vertical-align: top">
+ * <td style="white-space: nowrap; vertical-align: top;" align="right"><code>char := </code></td>
+ * <td style="vertical-align: top;"><em>any character that is not</em><code> special<br>
* | ('\\' </code><em>any character</em><code>)<br>
* | ('\u' hex hex hex hex)<br>
* </code></td>
* </tr>
- * <tr align="top">
- * <td nowrap valign="top" align="right"><code>hex := </code></td>
- * <td valign="top"><em>any character for which
+ * <tr style="vertical-align: top">
+ * <td style="white-space: nowrap; vertical-align: top;" align="right"><code>hex := </code></td>
+ * <td style="vertical-align: top;"><em>any character for which
* </em><code>Character.digit(c, 16)</code><em>
* returns a non-negative result</em></td>
* </tr>
* <tr>
- * <td nowrap valign="top" align="right"><code>property := </code></td>
- * <td valign="top"><em>a Unicode property set pattern</td>
+ * <td style="white-space: nowrap; vertical-align: top;" align="right"><code>property := </code></td>
+ * <td style="vertical-align: top;"><em>a Unicode property set pattern</em></td>
* </tr>
* </table>
* <br>
* <tr>
* <td>Legend: <table>
* <tr>
- * <td nowrap valign="top"><code>a := b</code></td>
- * <td width="20" valign="top"> </td>
- * <td valign="top"><code>a</code> may be replaced by <code>b</code> </td>
+ * <td style="white-space: nowrap; vertical-align: top;"><code>a := b</code></td>
+ * <td style="width: 20; vertical-align: top;"> </td>
+ * <td style="vertical-align: top;"><code>a</code> may be replaced by <code>b</code> </td>
* </tr>
* <tr>
- * <td nowrap valign="top"><code>a?</code></td>
- * <td valign="top"></td>
- * <td valign="top">zero or one instance of <code>a</code><br>
+ * <td style="white-space: nowrap; vertical-align: top;"><code>a?</code></td>
+ * <td style="vertical-align: top;"></td>
+ * <td style="vertical-align: top;">zero or one instance of <code>a</code><br>
* </td>
* </tr>
* <tr>
- * <td nowrap valign="top"><code>a*</code></td>
- * <td valign="top"></td>
- * <td valign="top">one or more instances of <code>a</code><br>
+ * <td style="white-space: nowrap; vertical-align: top;"><code>a*</code></td>
+ * <td style="vertical-align: top;"></td>
+ * <td style="vertical-align: top;">one or more instances of <code>a</code><br>
* </td>
* </tr>
* <tr>
- * <td nowrap valign="top"><code>a | b</code></td>
- * <td valign="top"></td>
- * <td valign="top">either <code>a</code> or <code>b</code><br>
+ * <td style="white-space: nowrap; vertical-align: top;"><code>a | b</code></td>
+ * <td style="vertical-align: top;"></td>
+ * <td style="vertical-align: top;">either <code>a</code> or <code>b</code><br>
* </td>
* </tr>
* <tr>
- * <td nowrap valign="top"><code>'a'</code></td>
- * <td valign="top"></td>
- * <td valign="top">the literal string between the quotes </td>
+ * <td style="white-space: nowrap; vertical-align: top;"><code>'a'</code></td>
+ * <td style="vertical-align: top;"></td>
+ * <td style="vertical-align: top;">the literal string between the quotes </td>
* </tr>
* </table>
* </td>
}
/**
- * Constructs a set containing the given range. If <code>end >
+ * Constructs a set containing the given range. If <code>end >
* start</code> then an empty set is created.
*
* @param start first character, inclusive, of range
}
/**
- * Quickly constructs a set from a set of ranges <s0, e0, s1, e1, s2, e2, ..., sn, en>.
+ * Quickly constructs a set from a set of ranges <s0, e0, s1, e1, s2, e2, ..., sn, en>.
* There must be an even number of integers, and they must be all greater than zero,
* all less than or equal to Character.MAX_CODE_POINT.
- * In each pair (..., si, ei, ...) it must be true that si <= ei
- * Between adjacent pairs (...ei, sj...), it must be true that ei+1 < sj
+ * In each pair (..., si, ei, ...) it must be true that si <= ei
+ * Between adjacent pairs (...ei, sj...), it must be true that ei+1 < sj
* @param pairs pairs of character representing ranges
* @stable ICU 4.4
*/
/**
* Make this object represent the range <code>start - end</code>.
- * If <code>end > start</code> then this object is set to an
+ * If <code>end > start</code> then this object is set to an
* an empty range.
*
* @param start first character in the set, inclusive
/**
* Adds the specified range to this set if it is not already
* present. If this set already contains the specified range,
- * the call leaves this set unchanged. If <code>end > start</code>
+ * the call leaves this set unchanged. If <code>end > start</code>
* then an empty range is added, leaving the set unchanged.
*
* @param start first character, inclusive, of range to be added
* Adds the specified multicharacter to this set if it is not already
* present. If this set already contains the multicharacter,
* the call leaves this set unchanged.
- * Thus "ch" => {"ch"}
+ * Thus "ch" => {"ch"}
* <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
* @param s the source string
* @return this object, for chaining
}
/**
- * Adds each of the characters in this string to the set. Thus "ch" => {"c", "h"}
+ * Adds each of the characters in this string to the set. Thus "ch" => {"c", "h"}
* If this set already any particular character, it has no effect on that character.
* @param s the source string
* @return this object, for chaining
}
/**
- * Makes a set from a multicharacter string. Thus "ch" => {"ch"}
+ * Makes a set from a multicharacter string. Thus "ch" => {"ch"}
* <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
* @param s the source string
* @return a newly created set containing the given string
/**
- * Makes a set from each of the characters in the string. Thus "ch" => {"c", "h"}
+ * Makes a set from each of the characters in the string. Thus "ch" => {"c", "h"}
* @param s the source string
* @return a newly created set containing the given characters
* @stable ICU 2.0
/**
* Retain only the elements in this set that are contained in the
- * specified range. If <code>end > start</code> then an empty range is
+ * specified range. If <code>end > start</code> then an empty range is
* retained, leaving the set empty.
*
* @param start first character, inclusive, of range to be retained
/**
* Removes the specified range from this set if it is present.
* The set will not contain the specified range once the call
- * returns. If <code>end > start</code> then an empty range is
+ * returns. If <code>end > start</code> then an empty range is
* removed, leaving the set unchanged.
*
* @param start first character, inclusive, of range to be removed
/**
* Complements the specified range in this set. Any character in
* the range will be removed if it is in this set, or will be
- * added if it is not in this set. If <code>end > start</code>
+ * added if it is not in this set. If <code>end > start</code>
* then an empty range is complemented, leaving the set unchanged.
*
* @param start first character, inclusive, of range to be removed
* UCharacter.getIntPropertyMaxValue(prop), with one exception.
* If prop is UProperty.GENERAL_CATEGORY_MASK, then value should not be
* a UCharacter.getType() result, but rather a mask value produced
- * by logically ORing (1 << UCharacter.getType()) values together.
+ * by logically ORing (1 << UCharacter.getType()) values together.
* This allows grouped categories such as [:L:] to be represented.
*
* @return a reference to this set
* 2. For each string 'e' in the resulting set, if e !=
* foldCase(e), 'e' will be removed.
*
- * Example: [aq\u00DF{Bc}{bC}{Fi}] => [aAqQ\u00DF\uFB01{ss}{bc}{fi}]
+ * Example: [aq\u00DF{Bc}{bC}{Fi}] => [aAqQ\u00DF\uFB01{ss}{bc}{fi}]
*
* (Here foldCase(x) refers to the operation
* UCharacter.foldCase(x, true), and a == b actually denotes
/*
*******************************************************************************
- * Copyright (C) 2014-2015, International Business Machines Corporation and
+ * Copyright (C) 2014-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* An instance is immutable (and thus thread-safe) iff the source UnicodeSet is frozen.
* <p><b>Note:</b> The counting, deletion, and replacement depend on alternating a {@link SpanCondition} with
* its inverse. That is, the code spans, then spans for the inverse, then spans, and so on.
- * For the inverse, the following mapping is used:</p>
+ * For the inverse, the following mapping is used:
* <ul>
* <li>{@link UnicodeSet.SpanCondition#SIMPLE} → {@link UnicodeSet.SpanCondition#NOT_CONTAINED}</li>
* <li>{@link UnicodeSet.SpanCondition#CONTAINED} → {@link UnicodeSet.SpanCondition#NOT_CONTAINED}</li>
* </ul>
* These are actually not complete inverses. However, the alternating works because there are no gaps.
* For example, with [a{ab}{bc}], you get the following behavior when scanning forward:
- * <p>
+ *
* <table border="1">
* <tr><th>SIMPLE</th><td>xxx[ab]cyyy</td></tr>
* <tr><th>CONTAINED</th><td>xxx[abc]yyy</td></tr>
* <tr><th>NOT_CONTAINED</th><td>[xxx]ab[cyyy]</td></tr>
* </table>
* <p>So here is what happens when you alternate:
- * <p>
+ *
* <table border="1">
* <tr><th>start</th><td>|xxxabcyyy</td></tr>
* <tr><th>NOT_CONTAINED</th><td>xxx|abcyyy</td></tr>
* <tr><th>CONTAINED</th><td>xxxabc|yyy</td></tr>
* <tr><th>NOT_CONTAINED</th><td>xxxabcyyy|</td></tr>
* </table>
- * </p>The entire string is traversed.
+ * <p>The entire string is traversed.
*
* @stable ICU 54
*/
/**
*******************************************************************************
- * Copyright (C) 1996-2010, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
import com.ibm.icu.impl.Utility;
/**
- * <p>
* A simple utility class to wrap a byte array.
- * </p>
* <p>
* 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.
- * </p>
+ *
* @author syn wee
* @stable ICU 2.8
*/
* @param bytesToAdopt the byte array to adopt
* @param size the length of valid data in the byte array
* @throws IndexOutOfBoundsException if bytesToAdopt == null and size != 0, or
- * size < 0, or size > bytesToAdopt.length.
+ * size < 0, or size > bytesToAdopt.length.
* @stable ICU 3.2
*/
public ByteArrayWrapper(byte[] bytesToAdopt, int size) {
/**
* Compare this object to another ByteArrayWrapper, which must not be null.
* @param other the object to compare to.
- * @return a value <0, 0, or >0 as this compares less than, equal to, or
+ * @return a value <0, 0, or >0 as this compares less than, equal to, or
* greater than other.
* @throws ClassCastException if the other object is not a ByteArrayWrapper
* @stable ICU 4.4
/**
* Returns 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
+ * 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
+ * {@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
/**
* Returns 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
+ * 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,
+ * {@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.
* int m2 = cal.fieldDifference(date1, Calendar.MONTH);
* int d2 = cal.fieldDifference(date1, Calendar.DATE);</pre>
*
- * one might expect that <code>m1 == -m2 && d1 == -d2</code>.
+ * one might expect that <code>m1 == -m2 && d1 == -d2</code>.
* 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).
/**
* Returns a limit for a field.
- * @param field the field, from 0..</code>getFieldCount()-1</code>
+ * @param field the field, from 0..<code>getFieldCount()-1</code>
* @param limitType the type specifier for the limit
* @see #MINIMUM
* @see #GREATEST_MINIMUM
* Julian day. These values are not stored in fields, but in member
* variables gregorianXxx. They are used for time zone computations and by
* subclasses that are Gregorian derivatives. Subclasses may call this
- * method to perform a Gregorian calendar millis->fields computation.
- * To perform a Gregorian calendar fields->millis computation, call
+ * method to perform a Gregorian calendar millis->fields computation.
+ * To perform a Gregorian calendar fields->millis computation, call
* computeGregorianMonthStart().
* @see #computeGregorianMonthStart
* @stable ICU 2.0
/**
* 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().
+ * 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
* Divide two long integers, returning the floor of the quotient.
* <p>
* Unlike the built-in division, this is mathematically well-behaved.
- * E.g., <code>-1/4</code> => 0
- * but <code>floorDivide(-1,4)</code> => -1.
+ * E.g., <code>-1/4</code> => 0
+ * but <code>floorDivide(-1,4)</code> => -1.
* @param numerator the numerator
- * @param denominator a divisor which must be > 0
+ * @param denominator a divisor which must be > 0
* @return the floor of the quotient.
* @stable ICU 2.0
*/
* Divide two integers, returning the floor of the quotient.
* <p>
* Unlike the built-in division, this is mathematically well-behaved.
- * E.g., <code>-1/4</code> => 0
- * but <code>floorDivide(-1,4)</code> => -1.
+ * E.g., <code>-1/4</code> => 0
+ * but <code>floorDivide(-1,4)</code> => -1.
* @param numerator the numerator
- * @param denominator a divisor which must be > 0
+ * @param denominator a divisor which must be > 0
* @return the floor of the quotient.
* @stable ICU 2.0
*/
* the modulus remainder.
* <p>
* Unlike the built-in division, this is mathematically well-behaved.
- * E.g., <code>-1/4</code> => 0 and <code>-1%4</code> => -1,
- * but <code>floorDivide(-1,4)</code> => -1 with <code>remainder[0]</code> => 3.
+ * E.g., <code>-1/4</code> => 0 and <code>-1%4</code> => -1,
+ * but <code>floorDivide(-1,4)</code> => -1 with <code>remainder[0]</code> => 3.
* @param numerator the numerator
- * @param denominator a divisor which must be > 0
+ * @param denominator a divisor which must be > 0
* @param remainder an array of at least one element in which the value
* <code>numerator mod denominator</code> is returned. Unlike <code>numerator
* % denominator</code>, this will always be non-negative.
* the modulus remainder.
* <p>
* Unlike the built-in division, this is mathematically well-behaved.
- * E.g., <code>-1/4</code> => 0 and <code>-1%4</code> => -1,
- * but <code>floorDivide(-1,4)</code> => -1 with <code>remainder[0]</code> => 3.
+ * E.g., <code>-1/4</code> => 0 and <code>-1%4</code> => -1,
+ * but <code>floorDivide(-1,4)</code> => -1 with <code>remainder[0]</code> => 3.
* @param numerator the numerator
- * @param denominator a divisor which must be > 0
+ * @param denominator a divisor which must be > 0
* @param remainder an array of at least one element in which the value
* <code>numerator mod denominator</code> is returned. Unlike <code>numerator
* % denominator</code>, this will always be non-negative.
/**
* Returns if two digit representation of year in this calendar type
- * customarily implies a default century (i.e. 03 -> 2003).
+ * customarily implies a default century (i.e. 03 -> 2003).
* The default implementation returns <code>true</code>. A subclass may
* return <code>false</code> if such practice is not applicable (for example,
* Chinese calendar and Japanese calendar).
*
- * @return <code>true<code> if this calendar has a default century.
+ * @return <code>true</code> if this calendar has a default century.
* @internal
* @deprecated This API is ICU internal only.
*/
* @param text the text to parse
* @param type parse against currency type: LONG_NAME only or not
* @param pos input-output position; on input, the position within
- * text to match; must have 0 <= pos.getIndex() < text.length();
+ * text to match; must have 0 <= pos.getIndex() < text.length();
* on output, the position after the last matched character. If
* the parse fails, the position in unchanged upon output.
* @return the ISO 4217 code, as a string, of the best match, or
/*
******************************************************************************
- * Copyright (C) 2005-2014, International Business Machines Corporation and *
+ * Copyright (C) 2005-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
* </p>
*
* <pre>
- * public class A implements Freezable<A> {
+ * public class A implements Freezable<A> {
* ...
* public final boolean isFrozen() {return true;}
* public final A freeze() {return this;}
/*
*******************************************************************************
- * Copyright (C) 1996-2014, International Business Machines Corporation and
+ * Copyright (C) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* calendar, see one of the following references:
* <ul>
* <li>"<a href="http://www.amazon.com/exec/obidos/ASIN/0521564743">Calendrical Calculations</a>",
- * by Nachum Dershowitz & Edward Reingold, Cambridge University Press, 1997, pages 85-91.
+ * by Nachum Dershowitz & Edward Reingold, Cambridge University Press, 1997, pages 85-91.
*
* <li>Hebrew Calendar Science and Myths,
* <a href="http://web.archive.org/web/20090423084613/http://www.geocities.com/Athens/1584/">
/**
* EXType for {@link #getExemplarSet(int, int)}.
* Corresponds to the 'main' (aka 'standard') CLDR exemplars in
- * {@link "http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements"}.
+ * <a href="http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements">
+ * http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements</a>.
* @stable ICU 3.4
*/
public static final int ES_STANDARD = 0;
/**
* EXType for {@link #getExemplarSet(int, int)}.
* Corresponds to the 'auxiliary' CLDR exemplars in
- * {@link "http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements"}.
+ * <a href="http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements">
+ * http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements</a>.
* @stable ICU 3.4
*/
public static final int ES_AUXILIARY = 1;
/**
* EXType for {@link #getExemplarSet(int, int)}.
* Corresponds to the 'index' CLDR exemplars in
- * {@link "http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements"}.
+ * <a href="http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements">
+ * http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements</a>.
* @stable ICU 4.4
*/
public static final int ES_INDEX = 2;
/**
* EXType for {@link #getExemplarSet(int, int)}.
* Corresponds to the 'currencySymbol' CLDR exemplars in
- * {@link "http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements"}.
+ * <a href="http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements">
+ * http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements</a>.
* Note: This type is no longer supported.
* @deprecated ICU 51
*/
/**
* Corresponds to the 'punctuation' CLDR exemplars in
- * {@link "http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements"}.
+ * <a href="http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements">
+ * http://www.unicode.org/reports/tr35/tr35-general.html#Character_Elements</a>.
* EXType for {@link #getExemplarSet(int, int)}.
* @stable ICU 49
*/
/**
* Returns the size of paper used in the locale. The paper sizes returned are always in
- * <em> milli-meters<em>.
+ * <em>milli-meters</em>.
* @param locale The locale for which the measurement system to be retrieved.
* @return The paper size used in the locale
* @stable ICU 3.0
/*
****************************************************************************************
- * Copyright (C) 2009-2015, Google, Inc.; International Business Machines Corporation *
+ * Copyright (C) 2009-2016, Google, Inc.; International Business Machines Corporation *
* and others. All Rights Reserved. *
****************************************************************************************
*/
* LocaleMatcher matcher = new LocaleMatcher("fr, en-GB, en");
*
* // afterwards:
- * matcher.getBestMatch("en-US").toLanguageTag() => "en"
+ * matcher.getBestMatch("en-US").toLanguageTag() => "en"
* </pre>
*
* It takes into account when languages are close to one another, such as fil
/*
*******************************************************************************
- * Copyright (C) 2010-2014, Google, Inc.; International Business Machines *
+ * Copyright (C) 2010-2016, Google, Inc.; International Business Machines *
* Corporation and others. All Rights Reserved. *
*******************************************************************************
*/
/**
* Provides an immutable list of languages (locales) in priority order.
* The string format is based on the Accept-Language format
- * {@link "http://www.ietf.org/rfc/rfc2616.txt"}, such as
+ * <a href="http://www.ietf.org/rfc/rfc2616.txt">http://www.ietf.org/rfc/rfc2616.txt</a>, such as
* "af, en, fr;q=0.9". Syntactically it is slightly
* more lenient, in allowing extra whitespace between elements, extra commas,
* and more than 3 decimals (on input), and pins between 0 and 1.
/*
*******************************************************************************
- * Copyright (C) 2011-2012, International Business Machines Corporation and *
+ * Copyright (C) 2011-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
}
/**
- * Constructs an <code>Output</code> withe the given value.
+ * Constructs an <code>Output</code> with the given value.
* @param value the initial value
* @stable ICU 4.8
*/
/*
******************************************************************************
-* Copyright (C) 1996-2010, International Business Machines Corporation and *
+* Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
package com.ibm.icu.util;
/**
- * <p>Interface for enabling iteration over sets of <int index, int value>,
+ * <p>Interface for enabling iteration over sets of <int index, int value>,
* where index is the sorted integer index in ascending order and value, its
- * associated integer value.</p>
+ * associated integer value.
* <p>The result for each iteration is the consecutive range of
- * <int index, int value> with the same value. Result is represented by
- * <start, limit, value> where</p>
+ * <int index, int value> with the same value. Result is represented by
+ * <start, limit, value> where
* <ul>
* <li> start is the starting integer of the result range
* <li> limit is 1 after the maximum integer that follows start, such that
* Hence value(start) = value(start + 1) = .... = value(start + n) = .... =
* value(limit - 1). However value(start -1) != value(start) and
* value(limit) != value(start).
- * </p>
+ *
* <p>Most implementations will be created by factory methods, such as the
* character type iterator in UCharacter.getTypeIterator. See example below.
- * </p>
- * Example of use:<br>
+ *
+ * <p>Example of use:<br>
* <pre>
* RangeValueIterator iterator = UCharacter.getTypeIterator();
* RangeValueIterator.Element result = new RangeValueIterator.Element();
/**
* <p>Returns the next maximal result range with a common value and returns
- * true if we are not at the end of the iteration, false otherwise.</p>
+ * true if we are not at the end of the iteration, false otherwise.
* <p>If this returns a false, the contents of elements will not
- * be updated.</p>
+ * 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
/*
*******************************************************************************
- * Copyright (C) 1996-2010, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* @param dayOfWeek The day of the week on which this holiday occurs.
* The following values are legal: <ul>
* <li>dayOfWeek == 0 - use dayOfMonth only
- * <li>dayOfWeek < 0 - use last -dayOfWeek before or on dayOfMonth
- * <li>dayOfWeek > 0 - use first dayOfWeek after or on dayOfMonth
+ * <li>dayOfWeek < 0 - use last -dayOfWeek before or on dayOfMonth
+ * <li>dayOfWeek > 0 - use first dayOfWeek after or on dayOfMonth
* </ul>
*
* @param name The name of this holiday. This string is used as a key
/**
*******************************************************************************
-* Copyright (C) 1996-2014, International Business Machines Corporation and *
+* Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* into tokens by performing code point comparison.
* The <code>StringTokenizer</code> methods do not distinguish
* among identifiers, numbers, and quoted strings, nor do they recognize
- * and skip comments.</p>
+ * and skip comments.
* <p>
* The set of delimiters (the codepoints that separate tokens) may be
* specified either at creation time or on a per-token basis.
- * </p>
* <p>
* An instance of <code>StringTokenizer</code> behaves in one of three ways,
* depending on whether it was created with the <code>returnDelims</code>
* 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.
- * </p>
* <p>
* A <tt>StringTokenizer</tt> object internally maintains a current
* position within the string to be tokenized. Some operations advance this
* current position past the code point processed.
- * </p>
* <p>
* A token is returned by taking a substring of the string that was used to
* create the <tt>StringTokenizer</tt> object.
- * </p>
* <p>
* Example of the use of the default delimiter tokenizer.
* <blockquote><pre>
* println(st.nextToken());
* }
* </pre></blockquote>
- * </p>
* <p>
* prints the following output:
* <blockquote><pre>
* a
* test
* </pre></blockquote>
- * </p>
* <p>
* Example of the use of the tokenizer with user specified delimiter.
* <blockquote><pre>
* println(st.nextToken());
* }
* </pre></blockquote>
- * </p>
* <p>
* prints the following output:
* <blockquote><pre>
* \ud800
* \udc00
* </pre></blockquote>
- * </p>
+ *
* @author syn wee
* @stable ICU 2.4
*/
* characters in the delim argument are the delimiters for separating
* tokens.
* <p>If the returnDelims flag is false, the delimiter characters are
- * skipped and only serve as separators between tokens.</p>
+ * skipped and only serve as separators between tokens.
* <p>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.
* characters in the delim argument are the delimiters for separating
* tokens.
* <p>If the returnDelims flag is false, the delimiter characters are
- * skipped and only serve as separators between tokens.</p>
+ * skipped and only serve as separators between tokens.
* <p>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.</p>
+ * 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
* {@icu} Constructs a string tokenizer for the specified string. The
* characters in the delim argument are the delimiters for separating
* tokens.
- * <p>Delimiter characters themselves will not be treated as tokens.</p>
+ * <p>Delimiter characters themselves will not be treated as tokens.
* @param str a string to be parsed.
* @param delim the delimiters.
* @exception NullPointerException if str is null
/**
* <p>Constructs a string tokenizer for the specified string. All
* characters in the delim argument are the delimiters for separating
- * tokens.</p>
+ * tokens.
* <p>If the returnDelims flag is false, the delimiter characters are
- * skipped and only serve as separators between tokens.</p>
+ * skipped and only serve as separators between tokens.
* <p>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.
/**
* <p>Constructs a string tokenizer for the specified string. All
* characters in the delim argument are the delimiters for separating
- * tokens.</p>
+ * tokens.
* <p>If the returnDelims flag is false, the delimiter characters are
- * skipped and only serve as separators between tokens.</p>
+ * skipped and only serve as separators between tokens.
* <p>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.</p>
+ * 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
/**
* <p>Constructs a string tokenizer for the specified string. The
* characters in the delim argument are the delimiters for separating
- * tokens.</p>
- * <p>Delimiter characters themselves will not be treated as tokens.</p>
+ * tokens.
+ * <p>Delimiter characters themselves will not be treated as tokens.
* @param str a string to be parsed.
* @param delim the delimiters.
* @exception NullPointerException if str is null
* 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.</p>
- * <p>Delimiter characters themselves will not be treated as tokens.</p>
+ * carriage-return character, and the form-feed character.
+ * <p>Delimiter characters themselves will not be treated as tokens.
* @param str a string to be parsed
* @exception NullPointerException if str is null
* @stable ICU 2.4
* includes the given ID. An equivalency group contains zones
* that have the same GMT offset and rules.
*
- * <p>The returned count includes the given ID; it is always >= 1
+ * <p>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
* method returns <code>null</code>.
*
* <p>This implementation utilizes <a href="http://unicode.org/cldr/charts/supplemental/zone_tzid.html">
- * Zone-Tzid mapping data<a>. The mapping data is updated time to time. To get the latest changes,
+ * Zone-Tzid mapping data</a>. The mapping data is updated time to time. To get the latest changes,
* please read the ICU user guide section <a href="http://userguide.icu-project.org/datetime/timezone#TOC-Updating-the-Time-Zone-Data">
* Updating the Time Zone Data</a>.
*
* method returns <code>null</code>.
*
* <p>This implementation utilizes <a href="http://unicode.org/cldr/charts/supplemental/zone_tzid.html">
- * Zone-Tzid mapping data<a>. The mapping data is updated time to time. To get the latest changes,
+ * Zone-Tzid mapping data</a>. The mapping data is updated time to time. To get the latest changes,
* please read the ICU user guide section <a href="http://userguide.icu-project.org/datetime/timezone#TOC-Updating-the-Time-Zone-Data">
* Updating the Time Zone Data</a>.
*
/*
*******************************************************************************
- * Copyright (C) 2007-2010, International Business Machines Corporation and *
+ * Copyright (C) 2007-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
/**
* Returns if this <code>TimeZoneRule</code> has one or more start times.
*
- * @return true if this <TimeZoneRule</code> has one or more start times.
+ * @return true if this <code>TimeZoneRule</code> has one or more start times.
*
* @stable ICU 3.8
*/
* All ULocale constructors automatically normalize the locale id. To handle
* POSIX ids, <code>canonicalize</code> can be called to convert the id
* to canonical form, or the <code>canonicalInstance</code> factory method
- * can be called.</p>
+ * can be called.
*
* <p>This class provides selectors {@link #VALID_LOCALE} and {@link
* #ACTUAL_LOCALE} intended for use in methods named
* 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},
- * <a href="../text/Collator.html" title="class in com.ibm.icu.text"><code>Collator</code></a>,
+ * {@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,
+ * any. Once an object of one of these classes has been created,
* <tt>getLocale()</tt> may be called on it to determine the valid and
* actual locale arrived at during the object's construction.
*
/**
* Compares two ULocale for ordering.
- * <p><b>Note:</b> The order might change in future.</p>
+ * <p><b>Note:</b> The order might change in future.
*
* @param other the ULocale to be compared.
* @return a negative integer, zero, or a positive integer as this ULocale is less than, equal to, or greater
* to {@link ULocale.Builder#setLanguageTag} which throws an exception
* in this case.
*
- * <p>The following <b>conversions</b> are performed:<ul>
+ * <p>The following <b>conversions</b> are performed:
+ * <ul>
*
* <li>The language code "und" is mapped to language "".
*
* script to title case, country to upper case, variant to upper case,
* and extensions to lower case.
*
+ * </ul>
+ *
* <p>This implements the 'Language-Tag' production of BCP47, and
* so supports grandfathered (regular and irregular) as well as
* private use language tags. Stand alone private use tags are
/*
*******************************************************************************
- * Copyright (C) 2004-2015, International Business Machines Corporation and
+ * Copyright (C) 2004-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
* UResourceBundle.getBundleInstance("com.mycompany.resources.LocaleElements",
* "en_US", myClassLoader);
* </pre>
- * <note>
- * Please use pass a class loader for loading non-ICU resources. Java security does not
+ *
+ * <p>Note: Please use pass a class loader 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
- * </note>
+
* @stable ICU 3.0
* @author ram
*/
/*
*********************************************************************************
- * Copyright (C) 2004-2014, International Business Machines Corporation and *
+ * Copyright (C) 2004-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*********************************************************************************
*
* conversion back and forth between different systems.
*
* <p>Binary datetimes differ in a number of ways: the datatype, the unit,
- * and the epoch (origin). We refer to these as time scales.</p>
+ * and the epoch (origin). We refer to these as time scales.
*
* <p>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.</p>
+ * calculations involving dates around the present are safe.
*
* <p>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().)</p>
+ * 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.</p>
+ * datetime time scale.
*
* <p>For more details and background, see the
* <a href="http://www.icu-project.org/userguide/universalTimeScale.html">Universal Time Scale</a>
- * chapter in the ICU User Guide.</p>
+ * chapter in the ICU User Guide.
*
* @stable ICU 3.2
*/
/*
******************************************************************************
-* Copyright (C) 1996-2010, International Business Machines Corporation and *
+* Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
package com.ibm.icu.util;
/**
- * <p>Interface for enabling iteration over sets of <int, Object>, where
+ * <p>Interface for enabling iteration over sets of <int, Object>, where
* int is the sorted integer index in ascending order, and Object its
- * associated value.</p>
+ * associated value.
* <p>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.</p>
+ * range that is meaningful to its applications.
* <p>Most implementations will be created by factory methods, such as the
* character name iterator in UCharacter.getNameIterator. See example below.
- * </p>
+ *
* Example of use:<br>
* <pre>
* ValueIterator iterator = UCharacter.getNameIterator();
/**
* <p>The return result container of each iteration. Stores the next
- * integer index and its associated value Object.</p>
+ * integer index and its associated value Object.
* @stable ICU 2.6
*/
public static final class Element
/**
* <p>Returns the next result for this iteration and returns
- * true if we are not at the end of the iteration, false otherwise.</p>
+ * true if we are not at the end of the iteration, false otherwise.
* <p>If this returns a false, the contents of elements will not
- * be updated.</p>
+ * 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
/**
* <p>Resets the iterator to start iterating from the integer index
* Integer.MIN_VALUE or X if a setRange(X, Y) has been called previously.
- * </p>
+ *
* @stable ICU 2.6
*/
public void reset();
/**
* <p>Restricts the range of integers to iterate and resets the iteration
- * to begin at the index argument start.</p>
+ * to begin at the index argument start.
* <p>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.</p>
+ * Integer.MIN_VALUE and end at Integer.MAX_VALUE.
* <p>
* If this range is set outside the meaningful range specified by the
* implementation, next(element) will always return false.
- * </p>
+ *
* @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
+ * illegal range. E.g limit <= start
* @stable ICU 2.6
*/
public void setRange(int start, int limit);
* @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
+ * <= 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.
/**
* 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 IllegalArgumentException when either arguments are negative or > 255
+ * @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 IllegalArgumentException when either arguments are negative or > 255
* @stable ICU 2.6
*/
public static VersionInfo getInstance(int major, int minor, int milli,
/**
* 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.
+ * @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 IllegalArgumentException when either arguments are
- * negative or > 255
+ * negative or > 255
* @stable ICU 2.6
*/
public static VersionInfo getInstance(int major, int minor, int milli)
/**
* 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.
+ * @param major major version, non-negative number <= 255.
+ * @param minor minor version, non-negative number <= 255.
* @exception IllegalArgumentException when either arguments are
- * negative or > 255
+ * negative or > 255
* @stable ICU 2.6
*/
public static VersionInfo getInstance(int major, int minor)
/**
* Returns an instance of VersionInfo with the argument version.
* Equivalent to getInstance(major, 0, 0, 0).
- * @param major major version, non-negative number <= 255.
+ * @param major major version, non-negative number <= 255.
* @exception IllegalArgumentException when either arguments are
- * negative or > 255
+ * negative or > 255
* @stable ICU 2.6
*/
public static VersionInfo getInstance(int major)
/*
*******************************************************************************
- * Copyright (C) 1996-2014, International Business Machines Corporation and *
+ * Copyright (C) 1996-2016, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
* To include a literal semicolon, prefix it with a backslash ('\').
* Unicode Pattern_White_Space is ignored.
* If the first non-blank character on a line is '#',
- * the entire line is ignored as a comment. </p>
+ * the entire line is ignored as a comment.
*
* <p>Each set of rules consists of two groups, one forward, and one
* reverse. This is a convention that is not enforced; rules for one
* direction may be omitted, with the result that translations in
* that direction will not modify the source text. In addition,
* bidirectional forward-reverse rules may be specified for
- * symmetrical transformations.</p>
+ * symmetrical transformations.
*
- * <p><b>Rule syntax</b> </p>
+ * <p><b>Rule syntax</b>
*
- * <p>Rule statements take one of the following forms: </p>
+ * <p>Rule statements take one of the following forms:
*
* <dl>
* <dt><code>$alefmadda=\u0622;</code></dt>
* "<code>abc{def}</code>". Another example is "<code>{123}456</code>"
* (or "<code>123}456</code>") in which the literal
* pattern "<code>123</code>" must be followed by "<code>456</code>".
- * </p>
*
* <p>The output string of a forward or reverse rule consists of
* characters to replace the literal pattern characters. If the
* next replacement, if any, will be applied. The cursor is usually
* placed within the replacement text; however, it can actually be
* placed into the precending or following context by using the
- * special character '<code>@</code>'. Examples:</p>
+ * special character '<code>@</code>'. Examples:
*
* <blockquote>
* <p><code>a {foo} z > | @ bar; # foo -> bar, move cursor
* before a<br>
* {foo} xyz > bar @@|; # foo -> bar, cursor between
- * y and z</code></p>
+ * y and z</code>
* </blockquote>
*
- * <p><b>UnicodeSet</b></p>
+ * <p><b>UnicodeSet</b>
*
* <p><code>UnicodeSet</code> patterns may appear anywhere that
* makes sense. They may appear in variable definitions.
* Contrariwise, <code>UnicodeSet</code> patterns may themselves
* contain variable references, such as "<code>$a=[a-z];$not_a=[^$a]</code>",
- * or "<code>$range=a-z;$ll=[$range]</code>".</p>
+ * or "<code>$range=a-z;$ll=[$range]</code>".
*
* <p><code>UnicodeSet</code> patterns may also be embedded directly
- * into rule strings. Thus, the following two rules are equivalent:</p>
+ * into rule strings. Thus, the following two rules are equivalent:
*
* <blockquote>
* <p><code>$vowel=[aeiou]; $vowel>'*'; # One way to do this<br>
* [aeiou]>'*';
* #
- * Another way</code></p>
+ * Another way</code>
* </blockquote>
*
- * <p>See {@link UnicodeSet} for more documentation and examples.</p>
+ * <p>See {@link UnicodeSet} for more documentation and examples.
*
- * <p><b>Segments</b></p>
+ * <p><b>Segments</b>
*
* <p>Segments of the input string can be matched and copied to the
* output string. This makes certain sets of rules simpler and more
- * general, and makes reordering possible. For example:</p>
+ * general, and makes reordering possible. For example:
*
* <blockquote>
* <p><code>([a-z]) > $1 $1;
* #
* double lowercase letters<br>
- * ([:Lu:]) ([:Ll:]) > $2 $1; # reverse order of Lu-Ll pairs</code></p>
+ * ([:Lu:]) ([:Ll:]) > $2 $1; # reverse order of Lu-Ll pairs</code>
* </blockquote>
*
* <p>The segment of the input string to be copied is delimited by
* nine segments may be defined. Segments may not overlap. In the
* output string, "<code>$1</code>" through "<code>$9</code>"
* represent the input string segments, in left-to-right order of
- * definition.</p>
+ * definition.
*
- * <p><b>Anchors</b></p>
+ * <p><b>Anchors</b>
*
* <p>Patterns can be anchored to the beginning or the end of the text. This is done with the
- * special characters '<code>^</code>' and '<code>$</code>'. For example:</p>
+ * special characters '<code>^</code>' and '<code>$</code>'. For example:
*
* <blockquote>
* <p><code>^ a > 'BEG_A'; # match 'a' at start of text<br>
* of 'a'<br>
* z $ > 'END_Z'; # match 'z' at end of text<br>
* z > 'Z'; # match other instances
- * of 'z'</code></p>
+ * of 'z'</code>
* </blockquote>
*
* <p>It is also possible to match the beginning or the end of the text using a <code>UnicodeSet</code>.
* This is done by including a virtual anchor character '<code>$</code>' at the end of the
* set pattern. Although this is usually the match chafacter for the end anchor, the set will
* match either the beginning or the end of the text, depending on its placement. For
- * example:</p>
+ * example:
*
* <blockquote>
* <p><code>$x = [a-z$]; # match 'a' through 'z' OR anchor<br>
* $x 1 > 2; # match '1' after a-z or at the start<br>
- * 3 $x > 4; # match '3' before a-z or at the end</code></p>
+ * 3 $x > 4; # match '3' before a-z or at the end</code>
* </blockquote>
*
- * <p><b>Example</b> </p>
+ * <p><b>Example</b>
*
* <p>The following example rules illustrate many of the features of
- * the rule language. </p>
+ * the rule language.
*
* <table border="0" cellpadding="4">
* <tr>
- * <td valign="top">Rule 1.</td>
- * <td valign="top" nowrap><code>abc{def}>x|y</code></td>
+ * <td style="vertical-align: top;">Rule 1.</td>
+ * <td style="vertical-align: top; write-space: nowrap;"><code>abc{def}>x|y</code></td>
* </tr>
* <tr>
- * <td valign="top">Rule 2.</td>
- * <td valign="top" nowrap><code>xyz>r</code></td>
+ * <td style="vertical-align: top;">Rule 2.</td>
+ * <td style="vertical-align: top; write-space: nowrap;"><code>xyz>r</code></td>
* </tr>
* <tr>
- * <td valign="top">Rule 3.</td>
- * <td valign="top" nowrap><code>yz>q</code></td>
+ * <td style="vertical-align: top;">Rule 3.</td>
+ * <td style="vertical-align: top; write-space: nowrap;"><code>yz>q</code></td>
* </tr>
* </table>
*
* <p>Applying these rules to the string "<code>adefabcdefz</code>"
- * yields the following results: </p>
+ * yields the following results:
*
* <table border="0" cellpadding="4">
* <tr>
- * <td valign="top" nowrap><code>|adefabcdefz</code></td>
- * <td valign="top">Initial state, no rules match. Advance
+ * <td style="vertical-align: top; write-space: nowrap;"><code>|adefabcdefz</code></td>
+ * <td style="vertical-align: top;">Initial state, no rules match. Advance
* cursor.</td>
* </tr>
* <tr>
- * <td valign="top" nowrap><code>a|defabcdefz</code></td>
- * <td valign="top">Still no match. Rule 1 does not match
+ * <td style="vertical-align: top; write-space: nowrap;"><code>a|defabcdefz</code></td>
+ * <td style="vertical-align: top;">Still no match. Rule 1 does not match
* because the preceding context is not present.</td>
* </tr>
* <tr>
- * <td valign="top" nowrap><code>ad|efabcdefz</code></td>
- * <td valign="top">Still no match. Keep advancing until
+ * <td style="vertical-align: top; write-space: nowrap;"><code>ad|efabcdefz</code></td>
+ * <td style="vertical-align: top;">Still no match. Keep advancing until
* there is a match...</td>
* </tr>
* <tr>
- * <td valign="top" nowrap><code>ade|fabcdefz</code></td>
- * <td valign="top">...</td>
+ * <td style="vertical-align: top; write-space: nowrap;"><code>ade|fabcdefz</code></td>
+ * <td style="vertical-align: top;">...</td>
* </tr>
* <tr>
- * <td valign="top" nowrap><code>adef|abcdefz</code></td>
- * <td valign="top">...</td>
+ * <td style="vertical-align: top; write-space: nowrap;"><code>adef|abcdefz</code></td>
+ * <td style="vertical-align: top;">...</td>
* </tr>
* <tr>
- * <td valign="top" nowrap><code>adefa|bcdefz</code></td>
- * <td valign="top">...</td>
+ * <td style="vertical-align: top; write-space: nowrap;"><code>adefa|bcdefz</code></td>
+ * <td style="vertical-align: top;">...</td>
* </tr>
* <tr>
- * <td valign="top" nowrap><code>adefab|cdefz</code></td>
- * <td valign="top">...</td>
+ * <td style="vertical-align: top; write-space: nowrap;"><code>adefab|cdefz</code></td>
+ * <td style="vertical-align: top;">...</td>
* </tr>
* <tr>
- * <td valign="top" nowrap><code>adefabc|defz</code></td>
- * <td valign="top">Rule 1 matches; replace "<code>def</code>"
+ * <td style="vertical-align: top; write-space: nowrap;"><code>adefabc|defz</code></td>
+ * <td style="vertical-align: top;">Rule 1 matches; replace "<code>def</code>"
* with "<code>xy</code>" and back up the cursor
* to before the '<code>y</code>'.</td>
* </tr>
* <tr>
- * <td valign="top" nowrap><code>adefabcx|yz</code></td>
- * <td valign="top">Although "<code>xyz</code>" is
+ * <td style="vertical-align: top; write-space: nowrap;"><code>adefabcx|yz</code></td>
+ * <td style="vertical-align: top;">Although "<code>xyz</code>" is
* present, rule 2 does not match because the cursor is
* before the '<code>y</code>', not before the '<code>x</code>'.
* Rule 3 does match. Replace "<code>yz</code>"
* with "<code>q</code>".</td>
* </tr>
* <tr>
- * <td valign="top" nowrap><code>adefabcxq|</code></td>
- * <td valign="top">The cursor is at the end;
+ * <td style="vertical-align: top; write-space: nowrap;"><code>adefabcxq|</code></td>
+ * <td style="vertical-align: top;">The cursor is at the end;
* transliteration is complete.</td>
* </tr>
* </table>
*
* <p>The order of rules is significant. If multiple rules may match
- * at some point, the first matching rule is applied. </p>
+ * at some point, the first matching rule is applied.
*
* <p>Forward and reverse rules may have an empty output string.
* Otherwise, an empty left or right hand side of any statement is a
- * syntax error. </p>
+ * syntax error.
*
* <p>Single quotes are used to quote any character other than a
* digit or letter. To specify a single quote itself, inside or
* outside of quotes, use two single quotes in a row. For example,
* the rule "<code>'>'>o''clock</code>" changes the
* string "<code>></code>" to the string "<code>o'clock</code>".
- * </p>
*
- * <p><b>Notes</b> </p>
+ * <p><b>Notes</b>
*
* <p>While a RuleBasedTransliterator is being built, it checks that
* the rules are added in proper order. For example, if the rule
* then the second rule will throw an exception. The reason is that
* the second rule can never be triggered, since the first rule
* always matches anything it matches. In other words, the first
- * rule <em>masks</em> the second rule. </p>
+ * rule <em>masks</em> the second rule.
*
- * <p>Copyright (c) IBM Corporation 1999-2000. All rights reserved.</p>
+ * <p>Copyright (c) IBM Corporation 1999-2000. All rights reserved.
*
* @author Alan Liu
* @internal
*
* <p>
* Pairs of transliterators may be inverses of one another. For example, if transliterator <b>A</b> transliterates
- * characters by incrementing their Unicode value (so "abc" -> "def"), and transliterator <b>B</b> decrements character
+ * characters by incrementing their Unicode value (so "abc" -> "def"), and transliterator <b>B</b> decrements character
* values, then <b>A</b> is an inverse of <b>B</b> and vice versa. If we compose <b>A</b> with <b>B</b> in a compound
* transliterator, the result is the indentity transliterator, that is, a transliterator that does not change its input
* text.
* two transliterators: <b>AB</b>, which transliterates the character 'A' to 'B', and <b>BA</b>, which transliterates
* 'B' to 'A'. It might seem that these are exact inverses, since
*
- * <blockquote>"A" x <b>AB</b> -> "B"<br>
- * "B" x <b>BA</b> -> "A"</blockquote>
+ * <blockquote>"A" x <b>AB</b> -> "B"<br>
+ * "B" x <b>BA</b> -> "A"</blockquote>
*
* where 'x' represents transliteration. However,
*
- * <blockquote>"ABCD" x <b>AB</b> -> "BBCD"<br>
- * "BBCD" x <b>BA</b> -> "AACD"</blockquote>
+ * <blockquote>"ABCD" x <b>AB</b> -> "BBCD"<br>
+ * "BBCD" x <b>BA</b> -> "AACD"</blockquote>
*
* so <b>AB</b> composed with <b>BA</b> is not the identity. Nonetheless, <b>BA</b> may be usefully considered to be
* <b>AB</b>'s inverse, and it is on this basis that <b>AB</b><code>.getInverse()</code> could legitimately return
* structure will be modified. See the field descriptions for
* details.
*
- * <p>contextStart <= start <= limit <= contextLimit
+ * <p>contextStart <= start <= limit <= contextLimit
*
* <p>Note: All index values in this structure must be at code point
* boundaries. That is, none of them may occur between two code units
* Transliterates a segment of a string, with optional filtering.
*
* @param text the string to be transliterated
- * @param start the beginning index, inclusive; <code>0 <= start
- * <= limit</code>.
- * @param limit the ending index, exclusive; <code>start <= limit
- * <= text.length()</code>.
+ * @param start the beginning index, inclusive; <code>0 <= start
+ * <= limit</code>.
+ * @param limit the ending index, exclusive; <code>start <= limit
+ * <= text.length()</code>.
* @return The new limit index. The text previously occupying <code>[start,
* limit)</code> has been transliterated, possibly to a string of a different
* length, at <code>[start, </code><em>new-limit</em><code>)</code>, where
* Returns a rule string for this transliterator. This is
* a non-overrideable base class implementation that subclasses
* may call. It simply munges the ID into the correct format,
- * that is, "foo" => "::foo".
+ * that is, "foo" => "::foo".
* @param escapeUnprintable if true, then unprintable characters
* will be converted to escape form backslash-'u' or
* backslash-'U'.
* <p>Warning. You might expect an empty filter to always produce an empty target.
* However, consider the following:
* <pre>
- * [Pp]{}[\u03A3\u03C2\u03C3\u03F7\u03F8\u03FA\u03FB] > \';
+ * [Pp]{}[\u03A3\u03C2\u03C3\u03F7\u03F8\u03FA\u03FB] > \';
* </pre>
* With a filter of [], you still get some elements in the target set, because this rule will still match. It could
* be recast to the following if it were important.
* <pre>
- * [Pp]{([\u03A3\u03C2\u03C3\u03F7\u03F8\u03FA\u03FB])} > \' | $1;
+ * [Pp]{([\u03A3\u03C2\u03C3\u03F7\u03F8\u03FA\u03FB])} > \' | $1;
* </pre>
* @see #getTargetSet
* @stable ICU 2.2
* For example, suppose we have:
* <pre>
* Global FILTER = [ax]
- * a > b;
+ * a > b;
* :: NULL;
- * b > c;
- * x > d;
+ * b > c;
+ * x > d;
* </pre>
* While the filter just allows a and x, b is an intermediate result, which could produce c. So the source and target sets
* cannot be gathered independently. What we have to do is filter the sources for the first transliterator according to
* <p>There is another complication:
* <pre>
* Global FILTER = [ax]
- * a > |b;
- * b > c;
+ * a >|b;
+ * b >c;
* </pre>
* Even though b would be filtered from the input, whenever we have a backup, it could be part of the input. So ideally we will
* change the global filter as we go.
}
/**
- * Register a Transliterator object with the given ID.
+ * Register a Transliterator object.
*
* <p>Because ICU may choose to cache Transliterator objects internally, this must
* be called at application startup, prior to any calls to
* Transliterator.getInstance to avoid undefined behavior.
*
- * @param ID the ID of this transliterator
* @param trans the Transliterator object
*/
static void registerInstance(Transliterator trans, boolean visible) {
* example, calling registerSpecialInverse("NFC", "NFD", true) causes
* Transliterator to form the following inverse relationships:
*
- * <pre>NFC => NFD
- * Any-NFC => Any-NFD
- * NFD => NFC
- * Any-NFD => Any-NFC</pre>
+ * <pre>NFC => NFD
+ * Any-NFC => Any-NFD
+ * NFD => NFC
+ * Any-NFD => Any-NFC</pre>
*
* (Without the special inverse registration, the inverse of NFC
* would be NFC-Any.) Note that NFD is shorthand for Any-NFD, but
* factories or classes.
*
* <p>Only the targets are specified. Special inverses always
- * have the form Any-Target1 <=> Any-Target2. The target should
+ * have the form Any-Target1 <=> Any-Target2. The target should
* have canonical casing (the casing desired to be produced when
* an inverse is formed) and should contain no whitespace or other
* extraneous characters.
*
* @param target the target against which to register the inverse
* @param inverseTarget the inverse of target, that is
- * Any-target.getInverse() => Any-inverseTarget
+ * Any-target.getInverse() => Any-inverseTarget
* @param bidirectional if true, register the reverse relation
- * as well, that is, Any-inverseTarget.getInverse() => Any-target
+ * as well, that is, Any-inverseTarget.getInverse() => Any-target
*/
static void registerSpecialInverse(String target,
String inverseTarget,
projects / icu / commitdiff