// © 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /* ******************************************************************************* * * Copyright (C) 2011-2014 International Business Machines * Corporation and others. All Rights Reserved. * ******************************************************************************* */ #ifndef INDEXCHARS_H #define INDEXCHARS_H #include "unicode/utypes.h" #if U_SHOW_CPLUSPLUS_API #include "unicode/uobject.h" #include "unicode/locid.h" #include "unicode/unistr.h" #if !UCONFIG_NO_COLLATION /** * \file * \brief C++ API: Index Characters */ U_CDECL_BEGIN /** * Constants for Alphabetic Index Label Types. * The form of these enum constants anticipates having a plain C API * for Alphabetic Indexes that will also use them. * @stable ICU 4.8 */ UAlphabeticIndexLabelType; struct UHashtable; U_CDECL_END U_NAMESPACE_BEGIN // Forward Declarations class BucketList; class Collator; class RuleBasedCollator; class StringEnumeration; class UnicodeSet; class UVector; /** * AlphabeticIndex supports the creation of a UI index appropriate for a given language. * It can support either direct use, or use with a client that doesn't support localized collation. * The following is an example of what an index might look like in a UI: * * <pre> * <b>... A B C D E F G H I J K L M N O P Q R S T U V W X Y Z ...</b> * * <b>A</b> * Addison * Albertson * Azensky * <b>B</b> * Baker * ... * </pre> * * The class can generate a list of labels for use as a UI "index", that is, a list of * clickable characters (or character sequences) that allow the user to see a segment * (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> * 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> * The AlphabeticIndex class is not intended for public subclassing. * * <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(Locale::getEnglish(), status).</p> * * <h2>Direct Use</h2> * <p>The following shows an example of building an index directly. * The "show..." methods below are just to illustrate usage. * * <pre> * // Create a simple index. "Item" is assumed to be an application * // defined type that the application's UI and other processing knows about, * // and that has a name. * * UErrorCode status = U_ZERO_ERROR; * AlphabeticIndex index = new AlphabeticIndex(desiredLocale, status); * index->addLabels(additionalLocale, status); * for (Item *item in some source of Items ) { * index->addRecord(item->name(), item, status); * } * ... * // Show index at top. We could skip or gray out empty buckets * * while (index->nextBucket(status)) { * if (showAll || index->getBucketRecordCount() != 0) { * showLabelAtTop(UI, index->getBucketLabel()); * } * } * ... * // Show the buckets with their contents, skipping empty buckets * * index->resetBucketIterator(status); * while (index->nextBucket(status)) { * if (index->getBucketRecordCount() != 0) { * showLabelInList(UI, index->getBucketLabel()); * while (index->nextRecord(status)) { * showIndexedItem(UI, static_cast<Item *>(index->getRecordData())) * </pre> * * The caller can build different UIs using this class. * For example, an index character could be omitted or grayed-out * if its bucket is empty. Small buckets could also be combined based on size, such as: * * <pre> * <b>... A-F G-N O-Z ...</b> * </pre> * * <h2>Client Support</h2> * <p>Callers can also use the AlphabeticIndex::ImmutableIndex, or the AlphabeticIndex itself, * to support sorting on a client that doesn't support AlphabeticIndex functionality. * * <p>The ImmutableIndex is both immutable and thread-safe. * The corresponding AlphabeticIndex methods are not thread-safe because * they "lazily" build the index buckets. * <ul> * <li>ImmutableIndex.getBucket(index) provides random access to all * buckets and their labels and label types. * <li>The AlphabeticIndex bucket iterator or ImmutableIndex.getBucket(0..getBucketCount-1) * can be used to get a list of the labels, * such as "...", "A", "B",..., and send that list to the client. * <li>When the client has a new name, it sends that name to the server. * The server needs to call the following methods, * and communicate the bucketIndex and collationKey back to the client. * * <pre> * int32_t bucketIndex = index.getBucketIndex(name, status); * const UnicodeString &label = immutableIndex.getBucket(bucketIndex)->getLabel(); // optional * int32_t skLength = collator.getSortKey(name, sk, skCapacity); * </pre> * * <li>The client would put the name (and associated information) into its bucket for bucketIndex. The sort key sk is a * sequence of bytes that can be compared with a binary compare, and produce the right localized result.</li> * </ul> * * @stable ICU 4.8 */ class U_I18N_API AlphabeticIndex: public UObject { … }; U_NAMESPACE_END #endif // !UCONFIG_NO_COLLATION #endif /* U_SHOW_CPLUSPLUS_API */ #endif