| /** |
| ******************************************************************************* |
| * Copyright (C) 1996-2001, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| * |
| * $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/text/Attic/UCharacterNameDB.java,v $ |
| * $Date: 2001/03/23 19:51:38 $ |
| * $Revision: 1.3 $ |
| * |
| ******************************************************************************* |
| */ |
| |
| package com.ibm.text; |
| |
| import java.io.InputStream; |
| import java.io.DataInputStream; |
| import java.io.BufferedInputStream; |
| import java.io.IOException; |
| |
| /** |
| * Internal class used for Unicode character name database. |
| * Database classes store binary data read from uprops.dat and unames for use. |
| * It does not have the capability to parse the data into more high-level |
| * information. It only returns bytes of information when required. |
| * Due to the form most commonly used for retrieval, array of char is used |
| * to store the binary data |
| * UCharacterNameDB also contains indexes to significant points in the binary |
| * data. |
| * Responsibility for molding the binary data into more meaning form lies on |
| * <a href=UCharacterPpty.html>UCharacterPpty</a> and |
| * <a href=UCharacterName.html>UCharacterName</a>. |
| * Data populated by <a href=UGenNameReader.html>UGenNameReader</a> |
| * @author Syn Wee Quek |
| * @since oct2700 |
| * @see com.ibm.text.UGenReader |
| */ |
| |
| final class UCharacterNameDB extends UCharacterDB |
| { |
| // private variable ============================================= |
| |
| /** |
| * Data used in unames.dat |
| */ |
| private char m_tokentable_[]; |
| private byte m_tokenstring_[]; |
| private char m_groupinfo_[]; |
| private byte m_groupstring_[]; |
| private AlgorithmName m_algorithm_[]; |
| |
| /** |
| * Number of group sets |
| */ |
| private int m_groupcount_ = 0; |
| private int m_groupsize_ = 0; |
| |
| /** |
| * Default name of the name datafile |
| */ |
| private static final String NAME_FILE_NAME_ = "unames.dat"; |
| |
| /** |
| * Default buffer size of datafile |
| */ |
| private static final int NAME_BUFFER_SIZE_ = 100000; |
| |
| /** |
| * Shift count to retrieve group information |
| */ |
| private static final int GROUP_SHIFT_ = 5; |
| |
| /** |
| * Number of lines per group |
| */ |
| private static final int LINES_PER_GROUP_ = 1 << GROUP_SHIFT_; |
| |
| /** |
| * Mask to retrieve the offset for a particular character within a group |
| */ |
| private static final int GROUP_MASK_ = LINES_PER_GROUP_ - 1; |
| |
| /** |
| * Position of offsethigh in group information array |
| */ |
| private static final int OFFSET_HIGH_OFFSET_ = 1; |
| |
| /** |
| * Position of offsetlow in group information array |
| */ |
| private static final int OFFSET_LOW_OFFSET_ = 2; |
| |
| /** |
| * Indicator of if Unicode 1.0 names are available |
| */ |
| private static boolean UNICODE_1_; |
| |
| /** |
| * Double nibble indicator, any nibble > this number has to be combined |
| * with its following nibble |
| */ |
| private static final int SINGLE_NIBBLE_MAX_ = 11; |
| |
| // constructor ==================================================== |
| |
| /** |
| * protected constructor |
| * @exception thrown when data reading fails or when data has been corrupted |
| */ |
| protected UCharacterNameDB() throws IOException |
| { |
| UGenNameReader reader = new UGenNameReader(); |
| InputStream i = getClass().getResourceAsStream(NAME_FILE_NAME_); |
| BufferedInputStream b = new BufferedInputStream(i, NAME_BUFFER_SIZE_); |
| DataInputStream d = new DataInputStream(b); |
| reader.read(d, this); |
| d.close(); |
| UNICODE_1_ = (';' >= m_tokentable_.length) || |
| (m_tokentable_[(int)';'] == 0xFFFF); |
| } |
| |
| // public method ================================================== |
| |
| /** |
| * toString method for printing |
| */ |
| public String toString() |
| { |
| StringBuffer result = new StringBuffer("names content \n"); |
| /*result.append(super.toString()); |
| result.append('\n'); |
| result.append("token string offset "); |
| result.append(m_tokenstringoffset_); |
| result.append("\n"); |
| result.append("group offset "); |
| result.append(m_groupsoffset_); |
| result.append("\n"); |
| result.append("group string offset "); |
| result.append(m_groupstringoffset_); |
| result.append("\n"); |
| result.append("alg names offset "); |
| result.append(m_algnamesoffset_); |
| result.append("\n"); |
| */ |
| return result.toString(); |
| } |
| |
| // protected methods =============================================== |
| |
| /** |
| * Sets the token data |
| * @param token array of tokens |
| * @param tokenstring array of string values of the tokens |
| * @return false if there is a data error |
| */ |
| protected boolean setToken(char token[], byte tokenstring[]) |
| { |
| if (token != null && tokenstring != null && token.length > 0 && |
| tokenstring.length > 0) { |
| m_tokentable_ = token; |
| m_tokenstring_ = tokenstring; |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Sets the number of group and size of each group in number of char |
| * @param count number of groups |
| * @param size size of group in char |
| * @return true if group size is set correctly |
| */ |
| protected boolean setGroupCountSize(int count, int size) |
| { |
| if (count <= 0 || size <= 0) { |
| return false; |
| } |
| m_groupcount_ = count; |
| m_groupsize_ = size; |
| return true; |
| } |
| |
| /** |
| * Sets the group name data |
| * @param group index information array |
| * @param groupstring name information array |
| * @return false if there is a data error |
| */ |
| protected boolean setGroup(char group[], byte groupstring[]) |
| { |
| if (group != null && groupstring != null && group.length > 0 && |
| groupstring.length > 0) { |
| m_groupinfo_ = group; |
| m_groupstring_ = groupstring; |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Binary search for the group strings set that contains the argument Unicode |
| * code point's most significant bits. |
| * The return value is always a valid group string set that contain msb. |
| * If group string set is not found, -1 is returned |
| * @param ch the code point to look for |
| * @return group string set index in datatable otherwise -1 is returned if |
| * group string set is not found |
| */ |
| protected int getGroupStringIndex(int ch) |
| { |
| // gets the msb |
| int msb = ch >> GROUP_SHIFT_, |
| end = m_groupcount_, |
| start, |
| gindex = 0; |
| |
| // binary search for the group of names that contains the one for code |
| for (start = 0; start < end - 1;) { |
| gindex = (start + end) >> 1; |
| if (msb < getGroupMSB(gindex)) { |
| end = gindex; |
| } |
| else { |
| start = gindex; |
| } |
| } |
| |
| // return this if it is an exact match |
| if (msb == getGroupMSB(start)) { |
| start = start * m_groupsize_; |
| return UCharacterUtil.toInt(m_groupinfo_[start + OFFSET_HIGH_OFFSET_], |
| m_groupinfo_[start + OFFSET_LOW_OFFSET_]); |
| } |
| return -1; |
| } |
| |
| /** |
| * Returns the number of the group information object |
| * @return number of group information object |
| */ |
| protected int countGroup() |
| { |
| return m_groupcount_; |
| } |
| |
| /** |
| * Gets the group name of the character |
| * @param ch character to get the group name |
| * @param choice name choice selector to choose a unicode 1.0 or newer name |
| */ |
| protected String getGroupName(int ch, int choice) |
| { |
| if (choice != UCharacterNameChoice.U_UNICODE_CHAR_NAME && !UNICODE_1_) { |
| // if not modern name requested and semicolon byte value is a character, |
| // not a token number, otherwise since only modern names are stored in |
| // unames.dat and there is no such requested Unicode 1.0 name here |
| return null; |
| } |
| |
| // gets the msb |
| int msb = ch >> GROUP_SHIFT_, |
| end = m_groupcount_, |
| start, |
| gindex = 0; |
| |
| // binary search for the group of names that contains the one for code |
| for (start = 0; start < end - 1;) { |
| gindex = (start + end) >> 1; |
| if (msb < getGroupMSB(gindex)) { |
| end = gindex; |
| } |
| else { |
| start = gindex; |
| } |
| } |
| |
| // return this if it is an exact match |
| if (msb == getGroupMSB(start)) { |
| char offsets[] = new char[LINES_PER_GROUP_ + 1]; |
| char lengths[] = new char[LINES_PER_GROUP_ + 1]; |
| |
| int index = getGroupLengths(start, offsets, lengths); |
| int offset = ch & GROUP_MASK_; |
| return getGroupName(index + offsets[offset], lengths[offset], choice); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Getting the character with the tokenized argument name |
| * @param index of the group to check |
| * @param name of the character |
| * @param choice of Unicode version used |
| * @return character with the tokenized argument name or -1 if character is |
| * not found |
| */ |
| protected int getGroupChar(int index, String name, int choice) |
| { |
| if (choice != UCharacterNameChoice.U_UNICODE_CHAR_NAME && |
| !UNICODE_1_) { |
| // semicolon byte value is a token number , therefore only modern |
| // names are stored in unames.dat and there is no such requested |
| // Unicode 1.0 name here |
| return -1; |
| } |
| |
| // populating the data set of grouptable |
| char offsets[] = new char[LINES_PER_GROUP_ + 1]; |
| char lengths[] = new char[LINES_PER_GROUP_ + 1]; |
| int startgpstrindex = getGroupLengths(index, offsets, lengths); |
| |
| // shift out to function |
| int result = getGroupChar(startgpstrindex, lengths, name, choice); |
| if (result != -1) { |
| return (getGroupMSB(index) << GROUP_SHIFT_) | result; |
| } |
| return -1; |
| } |
| |
| /** |
| * Set the algorithm name information array |
| * @param algorithm information array |
| * @return true if the group string offset has been set correctly |
| */ |
| protected boolean setAlgorithm(AlgorithmName alg[]) |
| { |
| if (alg != null && alg.length != 0) { |
| m_algorithm_ = alg; |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Get the number of algorithm name groups |
| * @return number of algorithm name groups |
| */ |
| protected int countAlgorithm() |
| { |
| if (m_algorithm_ == null) { |
| return 0; |
| } |
| return m_algorithm_.length; |
| } |
| |
| /** |
| * Gets the index of the Algorithm object the argument code point lies |
| * @param ch code point |
| * @return index of the Algorithm object the argument code point lies, |
| * otherwise -1 if code point is not found in Algorithm objects |
| */ |
| protected int getAlgorithmIndex(int ch) |
| { |
| for (int index = m_algorithm_.length - 1; index >= 0; index --) { |
| if (m_algorithm_[index].contains(ch)) { |
| return index; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Appends algorithm name of code point into StringBuffer. |
| * Note this method does not check for validity of code point in Algorithm, |
| * result is undefined if code point does not belong in Algorithm. |
| * @param index of Algorithm object in array |
| * @param ch code point |
| * @param str StringBuffer to append to |
| */ |
| protected void appendAlgorithmName(int index, int ch, StringBuffer str) |
| { |
| m_algorithm_[index].appendName(ch, str); |
| } |
| |
| /** |
| * Get algorithm code point for the argument name at index. If name is not |
| * found in algorithm, -1 is returned. |
| * @param index algorithm index |
| * @param name code point name |
| * @param code point in algorithm that matches name, -1 otherwise |
| */ |
| protected int getAlgorithmChar(int index, String name) |
| { |
| return m_algorithm_[index].getAlgorithmChar(name); |
| } |
| |
| // private methods ================================================= |
| |
| /** |
| * Gets the most significant bits representation in the argument group |
| * @param index the indexth group in datatable |
| * @return most significant bits representation of group |
| */ |
| private char getGroupMSB(int index) |
| { |
| return m_groupinfo_[index * m_groupsize_]; |
| } |
| |
| /** |
| * Reads a block of compressed lengths of 32 strings and expands them into |
| * offsets and lengths for each string. Lengths are stored with a |
| * variable-width encoding in consecutive nibbles: |
| * If a nibble<0xc, then it is the length itself (0 = empty string). |
| * If a nibble>=0xc, then it forms a length value with the following nibble. |
| * The offsets and lengths arrays must be at least 33 (one more) long because |
| * there is no check here at the end if the last nibble is still used. |
| * @param index of group string object in array |
| * @param offsets array to store the value of the string offsets |
| * @param lengths array to store the value of the string length |
| * @return next index of the data string immediately after the lengths |
| * in terms of byte address |
| */ |
| private int getGroupLengths(int index, char offsets[], char lengths[]) |
| { |
| char length = 0xffff; |
| byte b = 0, |
| n = 0; |
| int shift; |
| index = index * m_groupsize_; // byte count offsets of group strings |
| int stringoffset = UCharacterUtil.toInt( |
| m_groupinfo_[index + OFFSET_HIGH_OFFSET_], |
| m_groupinfo_[index + OFFSET_LOW_OFFSET_]); |
| |
| offsets[0] = 0; |
| |
| // all 32 lengths must be read to get the offset of the first group string |
| for (int i = 0; i < LINES_PER_GROUP_; stringoffset ++) { |
| b = m_groupstring_[stringoffset]; |
| shift = 4; |
| |
| while (shift >= 0) { |
| // getting nibble |
| n = (byte)((b >> shift) & 0x0F); |
| if (length == 0xffff && n > SINGLE_NIBBLE_MAX_) { |
| length = (char)((n - 12) << 4); |
| } |
| else { |
| if (length != 0xffff) { |
| lengths[i] = (char)((length | n) + 12); |
| } |
| else { |
| lengths[i] = (char)n; |
| } |
| |
| if (i < LINES_PER_GROUP_) { |
| offsets[i + 1] = (char)(offsets[i] + lengths[i]); |
| } |
| |
| length = 0xffff; |
| i ++; |
| } |
| |
| shift -= 4; |
| } |
| } |
| return stringoffset; |
| } |
| |
| /** |
| * Gets the name of the argument group index |
| * @param index of the group name string in byte count |
| * @param length of the group name string |
| * @param choice of Unicode 1.0 name or the most current name |
| * @return name of the group |
| */ |
| private String getGroupName(int index, int length, int choice) |
| { |
| if (choice != UCharacterNameChoice.U_UNICODE_CHAR_NAME) { |
| int oldindex = index; |
| index += UCharacterUtil.skipByteSubString(m_groupstring_, index, length, |
| (byte)';'); |
| length -= (index - oldindex); |
| } |
| |
| StringBuffer s = new StringBuffer(); |
| byte b; |
| char token; |
| for (int i = 0; i < length;) { |
| b = m_groupstring_[index + i]; |
| i ++; |
| |
| if (b >= m_tokentable_.length) { |
| if (b == ';') { |
| break; |
| } |
| s.append(b); // implicit letter |
| } |
| else { |
| token = m_tokentable_[b & 0x00ff]; |
| if (token == 0xFFFE) { |
| // this is a lead byte for a double-byte token |
| token = m_tokentable_[b << 8 | (m_groupstring_[index + i] & 0x00ff)]; |
| i ++; |
| } |
| if (token == 0xFFFF) { |
| if (b == ';') { |
| break; |
| } |
| s.append((char)(b & 0x00ff)); // explicit letter |
| } |
| else { // write token word |
| UCharacterUtil.getNullTermByteSubString(s, m_tokenstring_, token); |
| } |
| } |
| } |
| |
| if (s.length() == 0) { |
| return null; |
| } |
| return s.toString(); |
| } |
| |
| /** |
| * Compares and retrieve character if name is found within the argument |
| * group |
| * @param index index where the set of names reside in the group block |
| * @param length list of lengths of the strings |
| * @param name character name to search for |
| * @param choice of either 1.0 or the most current unicode name |
| * @return relative character in the group which matches name, otherwise if |
| * not found, -1 will be returned |
| */ |
| private int getGroupChar(int index, char length[], String name, int choice) |
| { |
| byte b = 0; |
| char token; |
| int len; |
| int namelen = name.length(); |
| int nindex; |
| int count; |
| |
| for (int result = 0; result <= LINES_PER_GROUP_; result ++) { |
| nindex = 0; |
| len = length[result]; |
| |
| if (choice != UCharacterNameChoice.U_UNICODE_CHAR_NAME) { |
| int oldindex = index; |
| index += UCharacterUtil.skipByteSubString(m_groupstring_, index, len, |
| (byte)';'); |
| len -= (index - oldindex); |
| } |
| |
| // number of tokens is > the length of the name |
| // write each letter directly, and write a token word per token |
| for (count = 0; count < len && nindex != -1 && nindex < namelen;) { |
| b = m_groupstring_[index + count]; |
| count ++; |
| |
| if (b >= m_tokentable_.length) { |
| if (name.charAt(nindex ++) != (b & 0xFF)) { |
| nindex = -1; |
| } |
| } |
| else { |
| token = m_tokentable_[b & 0xFF]; |
| if (token == 0xFFFE) { |
| // this is a lead byte for a double-byte token |
| token = m_tokentable_[b << 8 | |
| (m_groupstring_[index + count] & 0x00ff)]; |
| count ++; |
| } |
| if (token == 0xFFFF) { |
| if (name.charAt(nindex ++) != (b & 0xFF)) { |
| nindex = -1; |
| } |
| } |
| else { |
| // compare token with name |
| nindex = UCharacterUtil.compareNullTermByteSubString(name, |
| m_tokenstring_, nindex, token); |
| } |
| } |
| } |
| |
| if (namelen == nindex && |
| (count == len || m_groupstring_[index + count] == ';')) { |
| return result; |
| } |
| |
| index += len; |
| } |
| return -1; |
| } |
| |
| // protected inner class =========================================== |
| |
| /** |
| * Algorithmic name class |
| */ |
| static final class AlgorithmName |
| { |
| // protected variables =========================================== |
| |
| /** |
| * Constant type value of the different AlgorithmName |
| */ |
| protected static final int TYPE_0_ = 0; |
| protected static final int TYPE_1_ = 1; |
| |
| // private variables ============================================= |
| |
| /** |
| * Algorithmic data information |
| */ |
| private int m_rangestart_; |
| private int m_rangeend_; |
| private byte m_type_; |
| private byte m_variant_; |
| private char m_factor_[]; |
| private String m_prefix_; |
| private byte m_factorstring_[]; |
| |
| // constructor =================================================== |
| |
| /** |
| * Constructor |
| */ |
| protected AlgorithmName() |
| { |
| } |
| |
| // protected methods ============================================= |
| |
| /** |
| * Sets the information for accessing the algorithmic names |
| * @param rangestart starting code point that lies within this name group |
| * @param rangeend end code point that lies within this name group |
| * @param type algorithm type. There's 2 kinds of algorithmic type. First |
| * which uses code point as part of its name and the other uses |
| * variant postfix strings |
| * @param variant algorithmic variant |
| * @return true if values are valid |
| */ |
| protected boolean setInfo(int rangestart, int rangeend, byte type, |
| byte variant) |
| { |
| if (rangestart >= UCharacter.MIN_VALUE && rangestart <= rangeend && |
| rangeend <= UCharacter.MAX_VALUE && |
| (type == TYPE_0_ || type == TYPE_1_)) { |
| m_rangestart_ = rangestart; |
| m_rangeend_ = rangeend; |
| m_type_ = type; |
| m_variant_ = variant; |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Sets the factor data |
| * @param array of factor |
| * @return true if factors are valid |
| */ |
| protected boolean setFactor(char factor[]) |
| { |
| if (factor.length == m_variant_) { |
| m_factor_ = factor; |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Sets the name prefix |
| * @param prefix |
| * @return true if prefix is set |
| */ |
| protected boolean setPrefix(String prefix) |
| { |
| if (prefix != null && prefix.length() > 0) { |
| m_prefix_ = prefix; |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Sets the variant factorized name data |
| * @param string variant factorized name data |
| * @return true if values are set |
| */ |
| protected boolean setFactorString(byte string[]) |
| { |
| // factor and variant string can be empty for things like hanggul code |
| // points |
| m_factorstring_ = string; |
| return true; |
| } |
| |
| /** |
| * Checks if code point lies in Algorithm object at index |
| * @param ch code point |
| */ |
| protected boolean contains(int ch) |
| { |
| return m_rangestart_ <= ch && ch <= m_rangeend_; |
| } |
| |
| /** |
| * Appends algorithm name of code point into StringBuffer. |
| * Note this method does not check for validity of code point in Algorithm, |
| * result is undefined if code point does not belong in Algorithm. |
| * @param ch code point |
| * @param str StringBuffer to append to |
| */ |
| protected void appendName(int ch, StringBuffer str) |
| { |
| str.append(m_prefix_); |
| switch (m_type_) |
| { |
| case TYPE_0_: |
| // prefix followed by hex digits indicating variants |
| str.append(Integer.toHexString(ch)); |
| break; |
| case TYPE_1_: |
| // prefix followed by factorized-elements |
| int offset = ch - m_rangestart_; |
| int indexes[] = new int[m_variant_]; |
| int factor; |
| |
| // write elements according to the factors |
| // the factorized elements are determined by modulo arithmetic |
| for (int i = m_variant_ - 1; i > 0; i --) |
| { |
| factor = m_factor_[i] & 0x00FF; |
| indexes[i] = offset % factor; |
| offset /= factor; |
| } |
| |
| // we don't need to calculate the last modulus because |
| // start <= code <= end guarantees here that code <= factors[0] |
| indexes[0] = offset; |
| |
| // joining up the factorized strings |
| String s[] = getFactorString(indexes); |
| if (s != null && s.length > 0) |
| { |
| int size = s.length; |
| for (int i = 0; i < size; i ++) |
| str.append(s[i]); |
| } |
| break; |
| } |
| } |
| |
| /** |
| * Gets the character for the argument algorithmic name |
| * @return the algorithmic char or -1 otherwise. |
| */ |
| protected int getAlgorithmChar(String name) |
| { |
| int prefixlen = m_prefix_.length(); |
| if (name.length() < prefixlen || |
| !m_prefix_.equals(name.substring(0, prefixlen))) { |
| return -1; |
| } |
| |
| switch (m_type_) |
| { |
| case TYPE_0_ : |
| try |
| { |
| int result = Integer.parseInt(name.substring(prefixlen), 16); |
| // does it fit into the range? |
| if (m_rangestart_ <= result && result <= m_rangeend_) { |
| return result; |
| } |
| } |
| catch (NumberFormatException e) |
| { |
| } |
| break; |
| case TYPE_1_ : |
| // repetitative suffix name comparison done here |
| // offset is the character code - start |
| for (int ch = m_rangestart_; ch <= m_rangeend_; ch ++) |
| { |
| int offset = ch - m_rangestart_; |
| int indexes[] = new int[m_variant_]; |
| int factor; |
| |
| // write elements according to the factors |
| // the factorized elements are determined by modulo arithmetic |
| for (int i = m_variant_ - 1; i > 0; i --) |
| { |
| factor = m_factor_[i] & 0x00FF; |
| indexes[i] = offset % factor; |
| offset /= factor; |
| } |
| |
| // we don't need to calculate the last modulus because |
| // start <= code <= end guarantees here that code <= factors[0] |
| indexes[0] = offset; |
| |
| // joining up the factorized strings |
| if (compareFactorString(indexes, name.substring(prefixlen))) { |
| return ch; |
| } |
| } |
| } |
| |
| return -1; |
| } |
| |
| // private methods ================================================ |
| |
| /** |
| * Gets the indexth string in each of the argument factor block |
| * @param index array with each index corresponding to each factor block |
| * @return array of indexth factor string in factor block |
| */ |
| private String[] getFactorString(int index[]) |
| { |
| int size = m_factor_.length; |
| if (index == null || index.length != size) { |
| return null; |
| } |
| |
| String result[] = new String[size]; |
| StringBuffer str = new StringBuffer(); |
| int count = 0; |
| int factor; |
| size --; |
| for (int i = 0; i <= size; i ++) { |
| factor = m_factor_[i]; |
| count = UCharacterUtil.skipNullTermByteSubString(m_factorstring_, |
| count, index[i]); |
| count = UCharacterUtil.getNullTermByteSubString(str, m_factorstring_, |
| count); |
| if (i != size) { |
| count = UCharacterUtil.skipNullTermByteSubString(m_factorstring_, |
| count, factor - index[i] - 1); |
| } |
| result[i] = str.toString(); |
| str.delete(0, str.length()); |
| } |
| return result; |
| } |
| |
| /** |
| * Compares the indexth string in each of the argument factor block with |
| * the argument string |
| * @param index array with each index corresponding to each factor block |
| * @param str string to compare with |
| * @return true if string matches |
| */ |
| private boolean compareFactorString(int index[], String str) |
| { |
| int size = m_factor_.length; |
| if (index == null || index.length != size) |
| return false; |
| |
| int count = 0; |
| int strcount = 0; |
| int factor; |
| size --; |
| for (int i = 0; i <= size; i ++) |
| { |
| factor = m_factor_[i]; |
| count = UCharacterUtil.skipNullTermByteSubString(m_factorstring_, |
| count, index[i]); |
| strcount = UCharacterUtil.compareNullTermByteSubString(str, |
| m_factorstring_, strcount, count); |
| if (strcount < 0) { |
| return false; |
| } |
| |
| if (i != size) { |
| count = UCharacterUtil.skipNullTermByteSubString(m_factorstring_, |
| count, factor - index[i]); |
| } |
| } |
| if (strcount != str.length()) { |
| return false; |
| } |
| return true; |
| } |
| } |
| } |
| |
