| /* GENERATED SOURCE. DO NOT MODIFY. */ |
| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /** |
| ******************************************************************************* |
| * Copyright (C) 1996-2016, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ******************************************************************************* |
| */ |
| package android.icu.text; |
| |
| import android.icu.impl.coll.Collation; |
| |
| /** |
| * 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>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>Both the method |
| * <code>CollationKey.compareTo(CollationKey)</code> and the method |
| * <code>Collator.compare(String, String)</code> compare two strings |
| * and returns their relative order. The performance characteristics |
| * 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>During the construction of a <code>CollationKey</code>, the |
| * entire source string is examined and processed into a series of |
| * bits terminated by a null, that are stored in the <code>CollationKey</code>. |
| * When <code>CollationKey.compareTo(CollationKey)</code> executes, it |
| * performs bitwise comparison on the bit sequences. This can incurs |
| * 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>On the other hand, implementations of |
| * <code>Collator.compare(String, String)</code> can examine and |
| * process the strings only until the first characters differing in |
| * order. This approach is recommended if the strings are to be |
| * compared only once.</p> |
| * |
| * <p>More information about the composition of the bit sequence can |
| * be found in the |
| * <a href="https://unicode-org.github.io/icu/userguide/collation/architecture"> |
| * user guide</a>.</p> |
| * |
| * <p>The following example shows how <code>CollationKey</code>s can be used |
| * to sort a list of <code>String</code>s.</p> |
| * <blockquote> |
| * <pre> |
| * // Create an array of CollationKeys for the Strings to be sorted. |
| * Collator myCollator = Collator.getInstance(); |
| * CollationKey[] keys = new CollationKey[3]; |
| * keys[0] = myCollator.getCollationKey("Tom"); |
| * keys[1] = myCollator.getCollationKey("Dick"); |
| * keys[2] = myCollator.getCollationKey("Harry"); |
| * sort( keys ); |
| * <br> |
| * //... |
| * <br> |
| * // Inside body of sort routine, compare keys this way |
| * if( keys[i].compareTo( keys[j] ) > 0 ) |
| * // swap keys[i] and keys[j] |
| * <br> |
| * //... |
| * <br> |
| * // Finally, when we've returned from sort. |
| * System.out.println( keys[0].getSourceString() ); |
| * System.out.println( keys[1].getSourceString() ); |
| * System.out.println( keys[2].getSourceString() ); |
| * </pre> |
| * </blockquote> |
| * <p> |
| * This class is not subclassable |
| * @see Collator |
| * @see RuleBasedCollator |
| * @author Syn Wee Quek |
| */ |
| public final class CollationKey implements Comparable<CollationKey> |
| { |
| // public inner classes ------------------------------------------------- |
| |
| /** |
| * Options that used in the API CollationKey.getBound() for getting a |
| * CollationKey based on the bound mode requested. |
| */ |
| public static final class BoundMode |
| { |
| /* |
| * do not change the values assigned to the members of this enum. |
| * Underlying code depends on them having these numbers |
| */ |
| |
| /** |
| * Lower bound |
| */ |
| public static final int LOWER = 0; |
| |
| /** |
| * Upper bound that will match strings of exact size |
| */ |
| public static final int UPPER = 1; |
| |
| /** |
| * Upper bound that will match all the strings that have the same |
| * initial substring as the given string |
| */ |
| public static final int UPPER_LONG = 2; |
| |
| /** |
| * One more than the highest normal BoundMode value. |
| * @deprecated ICU 58 The numeric value may change over time, see ICU ticket #12420. |
| * @hide unsupported on Android |
| */ |
| @Deprecated |
| public static final int COUNT = 3; |
| |
| /** |
| * Private Constructor |
| */ |
| ///CLOVER:OFF |
| private BoundMode(){} |
| ///CLOVER:ON |
| } |
| |
| // public constructor --------------------------------------------------- |
| |
| /** |
| * CollationKey constructor. |
| * This constructor is given public access, unlike the JDK version, to |
| * allow access to users extending the Collator class. See |
| * {@link Collator#getCollationKey(String)}. |
| * @param source string this CollationKey is to represent |
| * @param key array of bytes that represent the collation order of argument |
| * source terminated by a null |
| * @see Collator |
| */ |
| public CollationKey(String source, byte key[]) |
| { |
| this(source, key, -1); |
| } |
| |
| /** |
| * Private constructor, takes a length argument so it need not be lazy-evaluated. |
| * There must be a 00 byte at key[length] and none before. |
| */ |
| private CollationKey(String source, byte key[], int length) |
| { |
| m_source_ = source; |
| m_key_ = key; |
| m_hashCode_ = 0; |
| m_length_ = length; |
| } |
| |
| /** |
| * CollationKey constructor that forces key to release its internal byte |
| * array for adoption. key will have a null byte array after this |
| * construction. |
| * @param source string this CollationKey is to represent |
| * @param key RawCollationKey object that represents the collation order of |
| * argument source. |
| * @see Collator |
| * @see RawCollationKey |
| * @hide unsupported on Android |
| */ |
| public CollationKey(String source, RawCollationKey key) |
| { |
| m_source_ = source; |
| m_length_ = key.size - 1; |
| m_key_ = key.releaseBytes(); |
| assert m_key_[m_length_] == 0; |
| m_hashCode_ = 0; |
| } |
| |
| // public getters ------------------------------------------------------- |
| |
| /** |
| * Return the source string that this CollationKey represents. |
| * @return source string that this CollationKey represents |
| */ |
| public String getSourceString() |
| { |
| return m_source_; |
| } |
| |
| /** |
| * 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. |
| * <pre> |
| * byte key1[] = collationkey1.toByteArray(); |
| * byte key2[] = collationkey2.toByteArray(); |
| * int key, targetkey; |
| * int i = 0; |
| * do { |
| * key = key1[i] & 0xFF; |
| * targetkey = key2[i] & 0xFF; |
| * if (key < targetkey) { |
| * System.out.println("String 1 is less than string 2"); |
| * return; |
| * } |
| * if (targetkey < key) { |
| * System.out.println("String 1 is more than string 2"); |
| * } |
| * i ++; |
| * } while (key != 0 && targetKey != 0); |
| * |
| * System.out.println("Strings are equal."); |
| * </pre> |
| * |
| * @return CollationKey value in a sequence of big-endian byte bytes |
| * terminated by a null. |
| */ |
| public byte[] toByteArray() |
| { |
| int length = getLength() + 1; |
| byte result[] = new byte[length]; |
| System.arraycopy(m_key_, 0, result, 0, length); |
| return result; |
| } |
| |
| // public other methods ------------------------------------------------- |
| |
| /** |
| * Compare this CollationKey to another CollationKey. The |
| * collation rules of the Collator that created this key are |
| * applied. |
| * |
| * <p><strong>Note:</strong> Comparison between CollationKeys |
| * created by different Collators might return incorrect |
| * results. See class documentation. |
| * |
| * @param target target CollationKey |
| * @return an integer value. If the value is less than zero this CollationKey |
| * is less than than target, if the value is zero they are equal, and |
| * if the value is greater than zero this CollationKey is greater |
| * than target. |
| * @exception NullPointerException is thrown if argument is null. |
| * @see Collator#compare(String, String) |
| */ |
| @Override |
| public int compareTo(CollationKey target) |
| { |
| for (int i = 0;; ++i) { |
| int l = m_key_[i]&0xff; |
| int r = target.m_key_[i]&0xff; |
| if (l < r) { |
| return -1; |
| } else if (l > r) { |
| return 1; |
| } else if (l == 0) { |
| return 0; |
| } |
| } |
| } |
| |
| /** |
| * Compare this CollationKey and the specified Object for |
| * equality. The collation rules of the Collator that created |
| * this key are applied. |
| * |
| * <p>See note in compareTo(CollationKey) for warnings about |
| * possible incorrect results. |
| * |
| * @param target the object to compare to. |
| * @return true if the two keys compare as equal, false otherwise. |
| * @see #compareTo(CollationKey) |
| * @exception ClassCastException is thrown when the argument is not |
| * a CollationKey. NullPointerException is thrown when the argument |
| * is null. |
| */ |
| @Override |
| public boolean equals(Object target) |
| { |
| if (!(target instanceof CollationKey)) { |
| return false; |
| } |
| |
| return equals((CollationKey)target); |
| } |
| |
| /** |
| * Compare this CollationKey and the argument target CollationKey for |
| * equality. |
| * The collation |
| * rules of the Collator object which created these objects are applied. |
| * <p> |
| * See note in compareTo(CollationKey) for warnings of incorrect results |
| * |
| * @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. |
| */ |
| public boolean equals(CollationKey target) |
| { |
| if (this == target) { |
| return true; |
| } |
| if (target == null) { |
| return false; |
| } |
| CollationKey other = target; |
| int i = 0; |
| while (true) { |
| if (m_key_[i] != other.m_key_[i]) { |
| return false; |
| } |
| if (m_key_[i] == 0) { |
| break; |
| } |
| i ++; |
| } |
| return true; |
| } |
| |
| /** |
| * 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. |
| * |
| * @return the hash value. |
| */ |
| @Override |
| public int hashCode() |
| { |
| if (m_hashCode_ == 0) { |
| if (m_key_ == null) { |
| m_hashCode_ = 1; |
| } |
| else { |
| int size = m_key_.length >> 1; |
| StringBuilder key = new StringBuilder(size); |
| int i = 0; |
| while (m_key_[i] != 0 && m_key_[i + 1] != 0) { |
| key.append((char)((m_key_[i] << 8) | (0xff & m_key_[i + 1]))); |
| i += 2; |
| } |
| if (m_key_[i] != 0) { |
| key.append((char)(m_key_[i] << 8)); |
| } |
| m_hashCode_ = key.toString().hashCode(); |
| } |
| } |
| return m_hashCode_; |
| } |
| |
| /** |
| * 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> |
| * 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> |
| * 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> |
| * For more on usage, see example in test procedure |
| * <a href="https://github.com/unicode-org/icu/blob/main/icu4j/main/collate/src/test/java/com/ibm/icu/dev/test/collator/CollationAPITest.java"> |
| * src/com/ibm/icu/dev/test/collator/CollationAPITest/TestBounds. |
| * </a> |
| * <p> |
| * Collation keys produced may be compared using the <TT>compare</TT> API. |
| * @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 |
| * have the same starting substring as the source string. |
| * @param noOfLevels Strength levels required in the resulting bound |
| * (for most uses, the recommended value is PRIMARY). This |
| * strength should be less than the maximum strength of |
| * this CollationKey. |
| * See users guide for explanation on the strength levels a |
| * collation key can have. |
| * @return the result bounded CollationKey with a valid sort order but |
| * a null String representation. |
| * @exception IllegalArgumentException thrown when the strength level |
| * requested is higher than or equal to the strength in this |
| * CollationKey. |
| * In the case of an Exception, information |
| * about the maximum strength to use will be returned in the |
| * Exception. The user can then call getBound() again with the |
| * appropriate strength. |
| * @see CollationKey |
| * @see CollationKey.BoundMode |
| * @see Collator#PRIMARY |
| * @see Collator#SECONDARY |
| * @see Collator#TERTIARY |
| * @see Collator#QUATERNARY |
| * @see Collator#IDENTICAL |
| */ |
| public CollationKey getBound(int boundType, int noOfLevels) |
| { |
| // Scan the string until we skip enough of the key OR reach the end of |
| // the key |
| int offset = 0; |
| int keystrength = Collator.PRIMARY; |
| |
| if (noOfLevels > Collator.PRIMARY) { |
| while (offset < m_key_.length && m_key_[offset] != 0) { |
| if (m_key_[offset ++] |
| == Collation.LEVEL_SEPARATOR_BYTE) { |
| keystrength ++; |
| noOfLevels --; |
| if (noOfLevels == Collator.PRIMARY |
| || offset == m_key_.length || m_key_[offset] == 0) { |
| offset --; |
| break; |
| } |
| } |
| } |
| } |
| |
| if (noOfLevels > 0) { |
| throw new IllegalArgumentException( |
| "Source collation key has only " |
| + keystrength |
| + " strength level. Call getBound() again " |
| + " with noOfLevels < " + keystrength); |
| } |
| |
| // READ ME: this code assumes that the values for BoundMode variables |
| // will not change. They are set so that the enum value corresponds to |
| // the number of extra bytes each bound type needs. |
| byte resultkey[] = new byte[offset + boundType + 1]; |
| System.arraycopy(m_key_, 0, resultkey, 0, offset); |
| switch (boundType) { |
| case BoundMode.LOWER: // = 0 |
| // Lower bound just gets terminated. No extra bytes |
| break; |
| case BoundMode.UPPER: // = 1 |
| // Upper bound needs one extra byte |
| resultkey[offset ++] = 2; |
| break; |
| case BoundMode.UPPER_LONG: // = 2 |
| // Upper long bound needs two extra bytes |
| resultkey[offset ++] = (byte)0xFF; |
| resultkey[offset ++] = (byte)0xFF; |
| break; |
| default: |
| throw new IllegalArgumentException( |
| "Illegal boundType argument"); |
| } |
| resultkey[offset] = 0; |
| return new CollationKey(null, resultkey, offset); |
| } |
| |
| |
| /** |
| * Merges this CollationKey with another. |
| * The levels are merged with their corresponding counterparts |
| * (primaries with primaries, secondaries with secondaries etc.). |
| * Between the values from the same level a separator is inserted. |
| * |
| * <p>This is useful, for example, for combining sort keys from first and last names |
| * to sort such pairs. |
| * See http://www.unicode.org/reports/tr10/#Merging_Sort_Keys |
| * |
| * <p>The recommended way to achieve "merged" sorting is by |
| * concatenating strings with U+FFFE between them. |
| * The concatenation has the same sort order as the merged sort keys, |
| * but merge(getSortKey(str1), getSortKey(str2)) may differ from getSortKey(str1 + '\uFFFE' + str2). |
| * Using strings with U+FFFE may yield shorter sort keys. |
| * |
| * <p>For details about Sort Key Features see |
| * https://unicode-org.github.io/icu/userguide/collation/api#sort-key-features |
| * |
| * <p>It is possible to merge multiple sort keys by consecutively merging |
| * another one with the intermediate result. |
| * |
| * <p>Only the sort key bytes of the CollationKeys are merged. |
| * This API does not attempt to merge the |
| * String representations of the CollationKeys, hence null will be returned |
| * as the result's String representation. |
| * |
| * <p>Example (uncompressed): |
| * <pre>191B1D 01 050505 01 910505 00 |
| * 1F2123 01 050505 01 910505 00</pre> |
| * will be merged as |
| * <pre>191B1D 02 1F2123 01 050505 02 050505 01 910505 02 910505 00</pre> |
| * |
| * @param source CollationKey to merge with |
| * @return a CollationKey that contains the valid merged sort keys |
| * with a null String representation, |
| * i.e. <tt>new CollationKey(null, merged_sort_keys)</tt> |
| * @exception IllegalArgumentException thrown if source CollationKey |
| * argument is null or of 0 length. |
| */ |
| public CollationKey merge(CollationKey source) |
| { |
| // check arguments |
| if (source == null || source.getLength() == 0) { |
| throw new IllegalArgumentException( |
| "CollationKey argument can not be null or of 0 length"); |
| } |
| |
| // 1 byte extra for the 02 separator at the end of the copy of this sort key, |
| // and 1 more for the terminating 00. |
| byte result[] = new byte[getLength() + source.getLength() + 2]; |
| |
| // merge the sort keys with the same number of levels |
| int rindex = 0; |
| int index = 0; |
| int sourceindex = 0; |
| while (true) { |
| // copy level from src1 not including 00 or 01 |
| // unsigned issues |
| while (m_key_[index] < 0 || m_key_[index] >= MERGE_SEPERATOR_) { |
| result[rindex++] = m_key_[index++]; |
| } |
| |
| // add a 02 merge separator |
| result[rindex++] = MERGE_SEPERATOR_; |
| |
| // copy level from src2 not including 00 or 01 |
| while (source.m_key_[sourceindex] < 0 |
| || source.m_key_[sourceindex] >= MERGE_SEPERATOR_) { |
| result[rindex++] = source.m_key_[sourceindex++]; |
| } |
| |
| // if both sort keys have another level, then add a 01 level |
| // separator and continue |
| if (m_key_[index] == Collation.LEVEL_SEPARATOR_BYTE |
| && source.m_key_[sourceindex] |
| == Collation.LEVEL_SEPARATOR_BYTE) { |
| ++index; |
| ++sourceindex; |
| result[rindex++] = Collation.LEVEL_SEPARATOR_BYTE; |
| } |
| else { |
| break; |
| } |
| } |
| |
| // here, at least one sort key is finished now, but the other one |
| // might have some contents left from containing more levels; |
| // that contents is just appended to the result |
| int remainingLength; |
| if ((remainingLength = m_length_ - index) > 0) { |
| System.arraycopy(m_key_, index, result, rindex, remainingLength); |
| rindex += remainingLength; |
| } |
| else if ((remainingLength = source.m_length_ - sourceindex) > 0) { |
| System.arraycopy(source.m_key_, sourceindex, result, rindex, remainingLength); |
| rindex += remainingLength; |
| } |
| result[rindex] = 0; |
| |
| assert rindex == result.length - 1; |
| return new CollationKey(null, result, rindex); |
| } |
| |
| // private data members ------------------------------------------------- |
| |
| /** |
| * Sequence of bytes that represents the sort key |
| */ |
| private byte m_key_[]; |
| |
| /** |
| * Source string this CollationKey represents |
| */ |
| private String m_source_; |
| |
| /** |
| * Hash code for the key |
| */ |
| private int m_hashCode_; |
| /** |
| * Gets the length of this CollationKey |
| */ |
| private int m_length_; |
| /** |
| * Collation key merge seperator |
| */ |
| private static final int MERGE_SEPERATOR_ = 2; |
| |
| // private methods ------------------------------------------------------ |
| |
| /** |
| * Gets the length of the CollationKey |
| * @return length of the CollationKey |
| */ |
| private int getLength() |
| { |
| if (m_length_ >= 0) { |
| return m_length_; |
| } |
| int length = m_key_.length; |
| for (int index = 0; index < length; index ++) { |
| if (m_key_[index] == 0) { |
| length = index; |
| break; |
| } |
| } |
| m_length_ = length; |
| return m_length_; |
| } |
| } |
