|
||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object | +--com.ibm.icu.text.Normalizer
Unicode Normalization
normalize
transforms Unicode text into an equivalent composed or
decomposed form, allowing for easier sorting and searching of text.
normalize
supports the standard normalization forms described in
Unicode Standard Annex #15 — Unicode Normalization Forms.
Characters with accents or other adornments can be encoded in
several different ways in Unicode. For example, take the character A-acute.
In Unicode, this can be encoded as a single character (the
"composed" form):
00C1 LATIN CAPITAL LETTER A WITH ACUTE
or as two separate characters (the "decomposed" form):0041 LATIN CAPITAL LETTER A 0301 COMBINING ACUTE ACCENT
To a user of your program, however, both of these sequences should be treated as the same "user-level" character "A with acute accent". When you are searching or comparing text, you must ensure that these two sequences are treated equivalently. In addition, you must handle characters with more than one accent. Sometimes the order of a character's combining accents is significant, while in other cases accent sequences in different orders are really equivalent. Similarly, the string "ffi" can be encoded as three separate letters:0066 LATIN SMALL LETTER F 0066 LATIN SMALL LETTER F 0069 LATIN SMALL LETTER I <\p> or as the single character
FB03 LATIN SMALL LIGATURE FFI
<\p>
The ffi ligature is not a distinct semantic character, and strictly speaking
it shouldn't be in Unicode at all, but it was included for compatibility
with existing character sets that already provided it. The Unicode standard
identifies such characters by giving them "compatibility" decompositions
into the corresponding semantic characters. When sorting and searching, you
will often want to use these mappings.
normalize
helps solve these problems by transforming text into the
canonical composed and decomposed forms as shown in the first example above.
In addition, you can have it perform compatibility decompositions so that
you can treat compatibility characters the same as their equivalents.
Finally, normalize
rearranges accents into the proper canonical
order, so that you do not have to worry about accent rearrangement on your
own.
Form FCD, "Fast C or D", is also designed for collation.
It allows to work on strings that are not necessarily normalized
with an algorithm (like in collation) that works under "canonical closure", i.e., it treats precomposed
characters and their decomposed equivalents the same.
It is not a normalization form because it does not provide for uniqueness of representation. Multiple strings
may be canonically equivalent (their NFDs are identical) and may all conform to FCD without being identical
themselves.
The form is defined such that the "raw decomposition", the recursive canonical decomposition of each character,
results in a string that is canonically ordered. This means that precomposed characters are allowed for as long
as their decompositions do not need canonical reordering.
Its advantage for a process like collation is that all NFD and most NFC texts - and many unnormalized texts -
already conform to FCD and do not need to be normalized (NFD) for such a process. The FCD quick check will
return YES for most strings in practice.
normalize(FCD) may be implemented with NFD.
For more details on FCD see the collation design document:
http://oss.software.ibm.com/cvs/icu/~checkout~/icuhtml/design/collation/ICU_collation_design.htm
ICU collation performs either NFD or FCD normalization automatically if normalization
is turned on for the collator object.
Beyond collation and string search, normalized strings may be useful for string equivalence comparisons,
transliteration/transcription, unique representations, etc.
The W3C generally recommends to exchange texts in NFC.
Note also that most legacy character encodings use only precomposed forms and often do not
encode any combining marks by themselves. For conversion to such character encodings the
Unicode text needs to be normalized to NFC.
For more usage examples, see the Unicode Standard Annex.
Inner Class Summary | |
static class |
Normalizer.Mode
Constants for normalization modes. |
static class |
Normalizer.QuickCheckResult
Result values for quickCheck(). |
Field Summary | |
static int |
COMPARE_CODE_POINT_ORDER
Option bit for compare: Compare strings in code point order instead of code unit order. |
static int |
COMPARE_IGNORE_CASE
Option bit for compare: Perform case-insensitive comparison. |
static Normalizer.Mode |
COMPOSE
Deprecated. To be removed after 2003-Aug-31. Use Normalier.NFC |
static Normalizer.Mode |
COMPOSE_COMPAT
Deprecated. To be removed after 2003-Aug-31. Use Normalizer.NFKC |
static Normalizer.Mode |
DECOMP
Deprecated. To be removed after 2003-Aug-31.Use Normalizer.NFD |
static Normalizer.Mode |
DECOMP_COMPAT
Deprecated. To be removed after 2003-Aug-31. Use Normalizer.NFKD |
static Normalizer.Mode |
DEFAULT
Default normalization. |
static int |
DONE
Constant indicating that the end of the iteration has been reached. |
static Normalizer.Mode |
FCD
"Fast C or D" form. |
static int |
FOLD_CASE_DEFAULT
Option bit for compare: Case sensitively compare the strings |
static int |
FOLD_CASE_EXCLUDE_SPECIAL_I
Option value for case folding: exclude the mappings for dotted I and dotless i marked with 'I' in CaseFolding.txt. |
static int |
IGNORE_HANGUL
Deprecated. To be removed after 2003-Aug-31. |
static int |
INPUT_IS_FCD
Option bit for compare: Both input strings are assumed to fulfill FCD conditions. |
static Normalizer.QuickCheckResult |
MAYBE
Indicates it cannot be determined if string is in the normalized format without further thorough checks. |
static Normalizer.Mode |
NFC
Canonical decomposition followed by canonical composition. |
static Normalizer.Mode |
NFD
Canonical decomposition. |
static Normalizer.Mode |
NFKC
Compatibility decomposition followed by canonical composition. |
static Normalizer.Mode |
NFKD
Compatibility decomposition. |
static Normalizer.QuickCheckResult |
NO
Indicates that string is not in the normalized format |
static Normalizer.Mode |
NO_OP
Deprecated. To be removed after 2003-Aug-31. Use Nomalizer.NONE |
static Normalizer.Mode |
NONE
No decomposition/composition. |
static Normalizer.QuickCheckResult |
YES
Indicates that string is in the normalized format |
Constructor Summary | |
Normalizer(java.text.CharacterIterator iter,
Normalizer.Mode mode)
Creates a new Normalizer object for iterating over the normalized form of the given text. |
|
Normalizer(java.text.CharacterIterator iter,
Normalizer.Mode mode,
int opt)
Deprecated. To be removed after 2003-Aug-31. Use Normalizer(CharacterIterator iter, Mode mode). |
|
Normalizer(java.lang.String str,
Normalizer.Mode mode)
Creates a new Normalizer object for iterating over the normalized form of a given string. |
|
Normalizer(java.lang.String str,
Normalizer.Mode mode,
int opt)
Deprecated. To be removed after 2003-Aug-31. Use Normalizer( String str, Mode mode). |
|
Normalizer(com.ibm.icu.impl.UCharacterIterator iter,
Normalizer.Mode mode)
Creates a new Normalizer object for iterating over the normalized form of the given text. |
Method Summary | |
java.lang.Object |
clone()
Clones this Normalizer object. |
static int |
compare(char[] s1,
char[] s2,
int options)
Compare two strings for canonical equivalence. |
static int |
compare(char[] s1,
int s1Start,
int s1Limit,
char[] s2,
int s2Start,
int s2Limit,
int options)
Compare two strings for canonical equivalence. |
static int |
compare(int char32a,
int char32b,
int options)
Convenience method that can have faster implementation by not allocating buffers. |
static int |
compare(int charA,
java.lang.String str2,
int options)
Convenience method that can have faster implementation by not allocating buffers. |
static int |
compare(java.lang.String s1,
java.lang.String s2,
int options)
Compare two strings for canonical equivalence. |
static int |
compose(char[] source,
char[] target,
boolean compat)
Compose a string. |
static int |
compose(char[] src,
int srcStart,
int srcLimit,
char[] dest,
int destStart,
int destLimit,
boolean compat)
Compose a string. |
static java.lang.String |
compose(java.lang.String str,
boolean compat)
Compose a string. |
static java.lang.String |
compose(java.lang.String str,
boolean compat,
int options)
Deprecated. To be removed after 2003-Aug-31. Use compose(String str, boolean compat). |
static java.lang.String |
concatenate(char[] left,
char[] right,
Normalizer.Mode mode)
Concatenate normalized strings, making sure that the result is normalized as well. |
static int |
concatenate(char[] left,
int leftStart,
int leftLimit,
char[] right,
int rightStart,
int rightLimit,
char[] dest,
int destStart,
int destLimit,
Normalizer.Mode mode)
Concatenate normalized strings, making sure that the result is normalized as well. |
static java.lang.String |
concatenate(java.lang.String left,
java.lang.String right,
Normalizer.Mode mode)
Concatenate normalized strings, making sure that the result is normalized as well. |
int |
current()
Return the current character in the normalized text-> |
static int |
decompose(char[] source,
char[] target,
boolean compat)
Decompose a string. |
static int |
decompose(char[] src,
int srcStart,
int srcLimit,
char[] dest,
int destStart,
int destLimit,
boolean compat)
Decompose a string. |
static java.lang.String |
decompose(java.lang.String str,
boolean compat)
Decompose a string. |
static java.lang.String |
decompose(java.lang.String str,
boolean compat,
int options)
Deprecated. To be removed after 2003-Aug-31. Use decompose(String str, boolean compat). |
int |
endIndex()
Retrieve the index of the end of the input text-> This is the end index of the CharacterIterator or the length of the String over which this Normalizer is iterating |
int |
first()
Return the first character in the normalized text-> This resets the Normalizer's position to the beginning of the text-> |
int |
getBeginIndex()
Deprecated. To be removed after 2003-aug-31. Use startIndex() instead. |
int |
getEndIndex()
Deprecated. To be removed after 2003-aug-31. Use endIndex() instead. |
int |
getIndex()
Retrieve the current iteration position in the input text that is being normalized. |
int |
getLength()
Gets the length of underlying text storage |
Normalizer.Mode |
getMode()
Return the basic operation performed by this Normalizer |
int |
getOption(int option)
Deprecated. To be removed after 2003-Aug-31. |
java.lang.String |
getText()
Returns the text under iteration as a string |
int |
getText(char[] fillIn)
Gets the underlying text storage |
static boolean |
isNormalized(char[] src,
int start,
int limit,
Normalizer.Mode mode)
Test if a string is in a given normalization form. |
static boolean |
isNormalized(int char32,
Normalizer.Mode mode)
Convenience Method |
static boolean |
isNormalized(java.lang.String str,
Normalizer.Mode mode)
Convenience Method |
int |
last()
Return the last character in the normalized text-> This resets the Normalizer's position to be just before the the input text corresponding to that normalized character. |
int |
next()
Return the next character in the normalized text and advance the iteration position by one. |
static int |
normalize(char[] source,
char[] target,
Normalizer.Mode mode)
Normalize a string. |
static int |
normalize(char[] src,
int srcStart,
int srcLimit,
char[] dest,
int destStart,
int destLimit,
Normalizer.Mode mode)
Normalize a string. |
static java.lang.String |
normalize(int char32,
Normalizer.Mode mode)
Normalize a codepoint accoding to the given mode |
static java.lang.String |
normalize(java.lang.String src,
Normalizer.Mode mode)
Normalize a string. |
static java.lang.String |
normalize(java.lang.String str,
Normalizer.Mode mode,
int options)
Deprecated. To be removed after 2003-Aug-31. Use normalize(String str, Mode mode). |
int |
previous()
Return the previous character in the normalized text and decrement the iteration position by one. |
static Normalizer.QuickCheckResult |
quickCheck(char[] source,
int start,
int limit,
Normalizer.Mode mode)
Performing quick check on a string, to quickly determine if the string is in a particular normalization format. |
static Normalizer.QuickCheckResult |
quickCheck(char[] source,
Normalizer.Mode mode)
Convenience method. |
static Normalizer.QuickCheckResult |
quickCheck(java.lang.String source,
Normalizer.Mode mode)
Convenience method. |
void |
reset()
Reset the index to the beginning of the text. |
int |
setIndex(int index)
Set the iteration position in the input text that is being normalized and return the first normalized character at that position. |
void |
setIndexOnly(int index)
Set the iteration position in the input text that is being normalized, without any immediate normalization. |
void |
setMode(Normalizer.Mode newMode)
Set the normalization mode for this object. |
void |
setOption(int option,
boolean value)
Deprecated. To be removed after 2003-Aug-31. |
void |
setText(char[] newText)
Set the input text over which this Normalizer will iterate. |
void |
setText(java.text.CharacterIterator newText)
Set the input text over which this Normalizer will iterate. |
void |
setText(java.lang.String newText)
Set the input text over which this Normalizer will iterate. |
void |
setText(java.lang.StringBuffer newText)
Set the input text over which this Normalizer will iterate. |
void |
setText(com.ibm.icu.impl.UCharacterIterator newText)
Set the input text over which this Normalizer will iterate. |
int |
startIndex()
Retrieve the index of the start of the input text-> This is the begin index of the CharacterIterator or the start (i.e. |
Methods inherited from class java.lang.Object |
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
public static final int DONE
UForwardCharacterIterator.DONE
.public static final Normalizer.Mode NONE
public static final Normalizer.Mode NFD
public static final Normalizer.Mode NFKD
public static final Normalizer.Mode NFC
public static final Normalizer.Mode DEFAULT
public static final Normalizer.Mode NFKC
public static final Normalizer.Mode FCD
public static final Normalizer.Mode NO_OP
constructors
and the static normalize
method. This value tells
the Normalizer to do nothing but return unprocessed characters
from the underlying String or CharacterIterator. If you have code which
requires raw text at some times and normalized text at others, you can
use NO_OP for the cases where you want raw text, rather
than having a separate code path that bypasses Normalizer
altogether.
setMode(com.ibm.icu.text.Normalizer.Mode)
,
NONE
public static final Normalizer.Mode COMPOSE
constructors
and the static normalize
method to determine the operation to be performed.
If all optional features (e.g. IGNORE_HANGUL
) are turned
off, this operation produces output that is in
Unicode Canonical Form
C.
setMode(com.ibm.icu.text.Normalizer.Mode)
,
NFC
public static final Normalizer.Mode COMPOSE_COMPAT
constructors
and the static
normalize
method to determine the operation to be performed.
If all optional features (e.g. IGNORE_HANGUL
) are turned
off, this operation produces output that is in
Unicode Canonical Form
KC.
setMode(com.ibm.icu.text.Normalizer.Mode)
,
NFKC
public static final Normalizer.Mode DECOMP
constructors
and the static normalize
method to determine the operation to be performed.
If all optional features (e.g. IGNORE_HANGUL
) are turned
off, this operation produces output that is in
Unicode Canonical Form
D.
setMode(com.ibm.icu.text.Normalizer.Mode)
,
NFD
public static final Normalizer.Mode DECOMP_COMPAT
constructors
and the static normalize
method to determine the operation to be performed.
If all optional features (e.g. IGNORE_HANGUL
) are turned
off, this operation produces output that is in
Unicode Canonical Form
KD.
setMode(com.ibm.icu.text.Normalizer.Mode)
,
NFKD
public static final int IGNORE_HANGUL
The Unicode standard treates Hangul to Jamo conversion as a canonical decomposition, so this option must be turned off if you wish to transform strings into one of the standard Unicode Normalization Forms.
setOption(int, boolean)
public static final Normalizer.QuickCheckResult NO
public static final Normalizer.QuickCheckResult YES
public static final Normalizer.QuickCheckResult MAYBE
public static final int FOLD_CASE_DEFAULT
public static final int INPUT_IS_FCD
public static final int COMPARE_IGNORE_CASE
public static final int COMPARE_CODE_POINT_ORDER
public static final int FOLD_CASE_EXCLUDE_SPECIAL_I
Constructor Detail |
public Normalizer(java.lang.String str, Normalizer.Mode mode)
str
- The string to be normalized. The normalization
will start at the beginning of the string.mode
- The normalization mode.public Normalizer(java.lang.String str, Normalizer.Mode mode, int opt)
The options parameter specifies which optional Normalizer features are to be enabled for this object.
str
- The string to be normalized. The normalization
will start at the beginning of the string.mode
- The normalization mode.opt
- Any optional features to be enabled.
Currently the only available option is IGNORE_HANGUL
.
If you want the default behavior corresponding to one of the
standard Unicode Normalization Forms, use 0 for this argument.public Normalizer(java.text.CharacterIterator iter, Normalizer.Mode mode)
iter
- The input text to be normalized. The normalization
will start at the beginning of the string.mode
- The normalization mode.public Normalizer(java.text.CharacterIterator iter, Normalizer.Mode mode, int opt)
iter
- The input text to be normalized. The normalization
will start at the beginning of the string.mode
- The normalization mode.opt
- Any optional features to be enabled.
Currently the only available option is IGNORE_HANGUL
.
If you want the default behavior corresponding to one of the
standard Unicode Normalization Forms, use 0 for this argument.public Normalizer(com.ibm.icu.impl.UCharacterIterator iter, Normalizer.Mode mode)
iter
- The input text to be normalized. The normalization
will start at the beginning of the string.mode
- The normalization mode.Method Detail |
public java.lang.Object clone()
CharacterIterator
that was passed in to the constructor
or to setText
.
However, the text storage underlying
the CharacterIterator is not duplicated unless the
iterator's clone method does so.clone
in class java.lang.Object
public static java.lang.String compose(java.lang.String str, boolean compat)
str
- The string to compose.compat
- If true the string will be composed accoding to
NFKC rules and if false will be composed according to
NFC rules.public static java.lang.String compose(java.lang.String str, boolean compat, int options)
str
- The string to compose.compat
- If true the string will be composed accoding to
NFKC rules and if false will be composed according to
NFC rules.options
- The only recognized option is IGNORE_HANGULpublic static int compose(char[] source, char[] target, boolean compat)
source
- The char array to compose.target
- A char buffer to receive the normalized text.compat
- If true the char array will be composed accoding to
NFKC rules and if false will be composed according to
NFC rules.java.lang.IndexOutOfBoundsException
- if target.length is less than the
required lengthpublic static int compose(char[] src, int srcStart, int srcLimit, char[] dest, int destStart, int destLimit, boolean compat)
src
- The char array to compose.srcStart
- Start index of the sourcesrcLimit
- Limit index of the sourcedest
- The char buffer to fill indestStart
- Start index of the destination bufferdestLimit
- End index of the destination buffercompat
- If true the char array will be composed accoding to
NFKC rules and if false will be composed according to
NFC rules.java.lang.IndexOutOfBoundsException
- if target.length is less than the
required lengthpublic static java.lang.String decompose(java.lang.String str, boolean compat)
str
- The string to decompose.compat
- If true the string will be decomposed accoding to NFKD rules
and if false will be decomposed according to NFD rules.public static java.lang.String decompose(java.lang.String str, boolean compat, int options)
str
- The string to decompose.compat
- If true the string will be decomposed accoding to NFKD rules
and if false will be decomposed according to NFD rules.public static int decompose(char[] source, char[] target, boolean compat)
source
- The char array to decompose.target
- A char buffer to receive the normalized text.compat
- If true the char array will be decomposed accoding to NFKD
rules and if false will be decomposed according to
NFD rules.java.lang.IndexOutOfBoundsException
- if the target capacity is less than
the required lengthpublic static int decompose(char[] src, int srcStart, int srcLimit, char[] dest, int destStart, int destLimit, boolean compat)
src
- The char array to compose.srcStart
- Start index of the sourcesrcLimit
- Limit index of the sourcedest
- The char buffer to fill indestStart
- Start index of the destination bufferdestLimit
- End index of the destination buffercompat
- If true the char array will be decomposed accoding to NFKD
rules and if false will be decomposed according to
NFD rules.java.lang.IndexOutOfBoundsException
- if the target capacity is less than
the required lengthpublic static java.lang.String normalize(java.lang.String str, Normalizer.Mode mode, int options)
The options parameter specifies which optional
Normalizer features are to be enabled for this operation.
Currently the only available option is IGNORE_HANGUL
.
If you want the default behavior corresponding to one of the standard
Unicode Normalization Forms, use 0 for this argument.
str
- the input string to be normalized.aMode
- the normalization modeoptions
- the optional features to be enabled.public static java.lang.String normalize(java.lang.String src, Normalizer.Mode mode)
source
- The string to normalize.mode
- The normalization mode; one of Normalizer.NONE,
Normalizer.NFD, Normalizer.NFC, Normalizer.NFKC,
Normalizer.NFKD, Normalizer.DEFAULTpublic static int normalize(char[] source, char[] target, Normalizer.Mode mode)
source
- The char array to normalize.target
- A char buffer to receive the normalized text.mode
- The normalization mode; one of Normalizer.NONE,
Normalizer.NFD, Normalizer.NFC, Normalizer.NFKC,
Normalizer.NFKD, Normalizer.DEFAULTjava.lang.IndexOutOfBoundsException
- if the target capacity is less than
the required lengthpublic static int normalize(char[] src, int srcStart, int srcLimit, char[] dest, int destStart, int destLimit, Normalizer.Mode mode)
src
- The char array to compose.srcStart
- Start index of the sourcesrcLimit
- Limit index of the sourcedest
- The char buffer to fill indestStart
- Start index of the destination bufferdestLimit
- End index of the destination buffermode
- The normalization mode; one of Normalizer.NONE,
Normalizer.NFD, Normalizer.NFC, Normalizer.NFKC,
Normalizer.NFKD, Normalizer.DEFAULTjava.lang.IndexOutOfBoundsException
- if the target capacity is less than
the required lengthpublic static java.lang.String normalize(int char32, Normalizer.Mode mode)
char32
- The input string to be normalized.aMode
- The normalization modepublic static Normalizer.QuickCheckResult quickCheck(java.lang.String source, Normalizer.Mode mode)
source
- string for determining if it is in a normalized formatmode
- normalization format (Normalizer.NFC,Normalizer.NFD,
Normalizer.NFKC,Normalizer.NFKD)public static Normalizer.QuickCheckResult quickCheck(char[] source, Normalizer.Mode mode)
source
- Array of characters for determining if it is in a normalized formatmode
- normalization format (Normalizer.NFC,Normalizer.NFD,
Normalizer.NFKC,Normalizer.NFKD)public static Normalizer.QuickCheckResult quickCheck(char[] source, int start, int limit, Normalizer.Mode mode)
source
- string for determining if it is in a normalized formatstart
- the start index of the sourcelimit
- the limit index of the source it is equal to the lengthmode
- normalization format (Normalizer.NFC,Normalizer.NFD,
Normalizer.NFKC,Normalizer.NFKD)public static boolean isNormalized(char[] src, int start, int limit, Normalizer.Mode mode)
src
- The input array of characters to be checked to see if
it is normalizedstart
- The strart index in the sourcelimit
- The limit index in the sourceaMode
- the normalization modepublic static boolean isNormalized(java.lang.String str, Normalizer.Mode mode)
str
- the input string to be checked to see if it is normalizedaMode
- the normalization modeisNormalized(char[], int, int, com.ibm.icu.text.Normalizer.Mode)
public static boolean isNormalized(int char32, Normalizer.Mode mode)
char32
- the input code point to be checked to see if it is normalizedaMode
- the normalization modeisNormalized(char[], int, int, com.ibm.icu.text.Normalizer.Mode)
public static int compare(char[] s1, int s1Start, int s1Limit, char[] s2, int s2Start, int s2Limit, int options)
s1
- First source character array.s1Start
- start index of sources1Limit
- limit of the sources2
- Second source character array.s2Start
- start index of the sources2Limit
- limit of the sourceoptions
- A bit set of options:
- FOLD_CASE_DEFAULT or 0 is used for default options:
Case-sensitive comparison in code unit order, and the input strings
are quick-checked for FCD.
- INPUT_IS_FCD
Set if the caller knows that both s1 and s2 fulfill the FCD conditions.
If not set, the function will quickCheck for FCD
and normalize if necessary.
- COMPARE_CODE_POINT_ORDER
Set to choose code point order instead of code unit order
- COMPARE_IGNORE_CASE
Set to compare strings case-insensitively using case folding,
instead of case-sensitively.
If set, then the following case folding options are used.normalize(java.lang.String, com.ibm.icu.text.Normalizer.Mode, int)
,
FCD
public static int compare(java.lang.String s1, java.lang.String s2, int options)
s1
- First source string.s2
- Second source string.options
- A bit set of options:
- FOLD_CASE_DEFAULT or 0 is used for default options:
Case-sensitive comparison in code unit order, and the input strings
are quick-checked for FCD.
- INPUT_IS_FCD
Set if the caller knows that both s1 and s2 fulfill the FCD conditions.
If not set, the function will quickCheck for FCD
and normalize if necessary.
- COMPARE_CODE_POINT_ORDER
Set to choose code point order instead of code unit order
- COMPARE_IGNORE_CASE
Set to compare strings case-insensitively using case folding,
instead of case-sensitively.
If set, then the following case folding options are used.normalize(java.lang.String, com.ibm.icu.text.Normalizer.Mode, int)
,
FCD
public static int compare(char[] s1, char[] s2, int options)
s1
- First source string.s2
- Second source string.options
- A bit set of options:
- FOLD_CASE_DEFAULT or 0 is used for default options:
Case-sensitive comparison in code unit order, and the input strings
are quick-checked for FCD.
- INPUT_IS_FCD
Set if the caller knows that both s1 and s2 fulfill the FCD conditions.
If not set, the function will quickCheck for FCD
and normalize if necessary.
- COMPARE_CODE_POINT_ORDER
Set to choose code point order instead of code unit order
- COMPARE_IGNORE_CASE
Set to compare strings case-insensitively using case folding,
instead of case-sensitively.
If set, then the following case folding options are used.normalize(java.lang.String, com.ibm.icu.text.Normalizer.Mode, int)
,
FCD
public static int compare(int char32a, int char32b, int options)
char32a
- the first code point to be checked against thechar32b
- the second code pointaMode
- the normalization modepublic static int compare(int charA, java.lang.String str2, int options)
char32a
- the first code point to be checked against thestr2
- the second stringaMode
- the normalization modepublic static int concatenate(char[] left, int leftStart, int leftLimit, char[] right, int rightStart, int rightLimit, char[] dest, int destStart, int destLimit, Normalizer.Mode mode)
left
- Left source array, may be same as dest.leftStart
- start index of the left array.leftLimit
- end index of the left array (==length)right
- Right source array.rightStart
- start index of the right array.leftLimit
- end index of the right array (==length)dest
- The output buffer; can be null if destStart==destLimit==0
for pure preflighting.destStart
- start index of the destination arraymode
- The normalization mode.java.lang.IndexOutOfBoundsException
- whose message has the string
representation of destination capacity required.java.lang.IndexOutOfBoundsException
- if target capacity is less than the
required lengthnormalize(java.lang.String, com.ibm.icu.text.Normalizer.Mode, int)
,
next()
,
previous()
public static java.lang.String concatenate(char[] left, char[] right, Normalizer.Mode mode)
dest=normalize(left+right, mode)
For details see concatenateleft
- Left source string.right
- Right source string.mode
- The normalization mode.concatenate(char[], int, int, char[], int, int, char[], int, int, com.ibm.icu.text.Normalizer.Mode)
,
normalize(java.lang.String, com.ibm.icu.text.Normalizer.Mode, int)
,
next()
,
previous()
,
concatenate(char[], int, int, char[], int, int, char[], int, int, com.ibm.icu.text.Normalizer.Mode)
public static java.lang.String concatenate(java.lang.String left, java.lang.String right, Normalizer.Mode mode)
dest=normalize(left+right, mode)
For details see concatenateleft
- Left source string.right
- Right source string.mode
- The normalization mode.concatenate(char[], int, int, char[], int, int, char[], int, int, com.ibm.icu.text.Normalizer.Mode)
,
normalize(java.lang.String, com.ibm.icu.text.Normalizer.Mode, int)
,
next()
,
previous()
,
concatenate(char[], int, int, char[], int, int, char[], int, int, com.ibm.icu.text.Normalizer.Mode)
public int current()
public int next()
DONE
is returned.public int previous()
DONE
is returned.public void reset()
public void setIndexOnly(int index)
index
- the desired index in the input text.public int setIndex(int index)
Note: This method sets the position in the input text,
while next()
and previous()
iterate through characters
in the normalized output. This means that there is not
necessarily a one-to-one correspondence between characters returned
by next and previous and the indices passed to and
returned from setIndex and getIndex()
.
index
- the desired index in the input text->java.lang.IllegalArgumentException
- if the given index is less than
getBeginIndex()
or greater than getEndIndex()
.public int getBeginIndex()
startIndex()
public int getEndIndex()
endIndex()
public int first()
public int last()
public int getIndex()
Note: This method sets the position in the input, while
next()
and previous()
iterate through characters in the
output. This means that there is not necessarily a one-to-one
correspondence between characters returned by next and
previous and the indices passed to and returned from
setIndex and getIndex()
.
public int startIndex()
public int endIndex()
public void setMode(Normalizer.Mode newMode)
Note:If the normalization mode is changed while iterating
over a string, calls to next()
and previous()
may
return previously buffers characters in the old normalization mode
until the iteration is able to re-sync at the next base character.
It is safest to call setText()
, first()
,
last()
, etc. after calling setMode.
newMode
- the new mode for this Normalizer.
The supported modes are:
COMPOSE
- Unicode canonical decompositiion
followed by canonical composition.
COMPOSE_COMPAT
- Unicode compatibility decompositiion
follwed by canonical composition.
DECOMP
- Unicode canonical decomposition
DECOMP_COMPAT
- Unicode compatibility decomposition.
NO_OP
- Do nothing but return characters
from the underlying input text.
getMode()
public Normalizer.Mode getMode()
setMode(com.ibm.icu.text.Normalizer.Mode)
public void setOption(int option, boolean value)
IGNORE_HANGUL
- Do not decompose Hangul syllables into the Jamo alphabet
and vice-versa. This option is off by default (i.e. Hangul processing
is enabled) since the Unicode standard specifies that Hangul to Jamo
is a canonical decomposition. For any of the standard Unicode Normalization
Forms, you should leave this option off.
option
- the option whose value is to be set.value
- the new setting for the option. Use true to
turn the option on and false to turn it off.getOption(int)
public int getOption(int option)
setOption(int, boolean)
public int getText(char[] fillIn)
fillIn
- the char buffer to fill the UTF-16 units.
The length of the buffer should be equal to the length of the
underlying text storagejava.lang.IndexOutOfBoundsException
- getLength()
public int getLength()
public java.lang.String getText()
result
- a copy of the text under iteration.public void setText(java.lang.StringBuffer newText)
newText
- The new string to be normalized.public void setText(char[] newText)
newText
- The new string to be normalized.public void setText(java.lang.String newText)
newText
- The new string to be normalized.public void setText(java.text.CharacterIterator newText)
newText
- The new string to be normalized.public void setText(com.ibm.icu.impl.UCharacterIterator newText)
newText
- The new string to be normalized.
|
||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |