Line data Source code
1 : // © 2016 and later: Unicode, Inc. and others.
2 : // License & terms of use: http://www.unicode.org/copyright.html
3 : /*
4 : *******************************************************************************
5 : *
6 : * Copyright (C) 2011-2014 International Business Machines
7 : * Corporation and others. All Rights Reserved.
8 : *
9 : *******************************************************************************
10 : */
11 :
12 : #ifndef INDEXCHARS_H
13 : #define INDEXCHARS_H
14 :
15 : #include "unicode/utypes.h"
16 : #include "unicode/uobject.h"
17 : #include "unicode/locid.h"
18 : #include "unicode/unistr.h"
19 :
20 : #if !UCONFIG_NO_COLLATION
21 :
22 : /**
23 : * \file
24 : * \brief C++ API: Index Characters
25 : */
26 :
27 : U_CDECL_BEGIN
28 :
29 : /**
30 : * Constants for Alphabetic Index Label Types.
31 : * The form of these enum constants anticipates having a plain C API
32 : * for Alphabetic Indexes that will also use them.
33 : * @stable ICU 4.8
34 : */
35 : typedef enum UAlphabeticIndexLabelType {
36 : /**
37 : * Normal Label, typically the starting letter of the names
38 : * in the bucket with this label.
39 : * @stable ICU 4.8
40 : */
41 : U_ALPHAINDEX_NORMAL = 0,
42 :
43 : /**
44 : * Undeflow Label. The bucket with this label contains names
45 : * in scripts that sort before any of the bucket labels in this index.
46 : * @stable ICU 4.8
47 : */
48 : U_ALPHAINDEX_UNDERFLOW = 1,
49 :
50 : /**
51 : * Inflow Label. The bucket with this label contains names
52 : * in scripts that sort between two of the bucket labels in this index.
53 : * Inflow labels are created when an index contains normal labels for
54 : * multiple scripts, and skips other scripts that sort between some of the
55 : * included scripts.
56 : * @stable ICU 4.8
57 : */
58 : U_ALPHAINDEX_INFLOW = 2,
59 :
60 : /**
61 : * Overflow Label. Te bucket with this label contains names in scripts
62 : * that sort after all of the bucket labels in this index.
63 : * @stable ICU 4.8
64 : */
65 : U_ALPHAINDEX_OVERFLOW = 3
66 : } UAlphabeticIndexLabelType;
67 :
68 :
69 : struct UHashtable;
70 : U_CDECL_END
71 :
72 : U_NAMESPACE_BEGIN
73 :
74 : // Forward Declarations
75 :
76 : class BucketList;
77 : class Collator;
78 : class RuleBasedCollator;
79 : class StringEnumeration;
80 : class UnicodeSet;
81 : class UVector;
82 :
83 : /**
84 : * AlphabeticIndex supports the creation of a UI index appropriate for a given language.
85 : * It can support either direct use, or use with a client that doesn't support localized collation.
86 : * The following is an example of what an index might look like in a UI:
87 : *
88 : * <pre>
89 : * <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>
90 : *
91 : * <b>A</b>
92 : * Addison
93 : * Albertson
94 : * Azensky
95 : * <b>B</b>
96 : * Baker
97 : * ...
98 : * </pre>
99 : *
100 : * The class can generate a list of labels for use as a UI "index", that is, a list of
101 : * clickable characters (or character sequences) that allow the user to see a segment
102 : * (bucket) of a larger "target" list. That is, each label corresponds to a bucket in
103 : * the target list, where everything in the bucket is greater than or equal to the character
104 : * (according to the locale's collation). Strings can be added to the index;
105 : * they will be in sorted order in the right bucket.
106 : * <p>
107 : * The class also supports having buckets for strings before the first (underflow),
108 : * after the last (overflow), and between scripts (inflow). For example, if the index
109 : * is constructed with labels for Russian and English, Greek characters would fall
110 : * into an inflow bucket between the other two scripts.
111 : * <p>
112 : * The AlphabeticIndex class is not intended for public subclassing.
113 : *
114 : * <p><em>Note:</em> If you expect to have a lot of ASCII or Latin characters
115 : * as well as characters from the user's language,
116 : * then it is a good idea to call addLabels(Locale::getEnglish(), status).</p>
117 : *
118 : * <h2>Direct Use</h2>
119 : * <p>The following shows an example of building an index directly.
120 : * The "show..." methods below are just to illustrate usage.
121 : *
122 : * <pre>
123 : * // Create a simple index. "Item" is assumed to be an application
124 : * // defined type that the application's UI and other processing knows about,
125 : * // and that has a name.
126 : *
127 : * UErrorCode status = U_ZERO_ERROR;
128 : * AlphabeticIndex index = new AlphabeticIndex(desiredLocale, status);
129 : * index->addLabels(additionalLocale, status);
130 : * for (Item *item in some source of Items ) {
131 : * index->addRecord(item->name(), item, status);
132 : * }
133 : * ...
134 : * // Show index at top. We could skip or gray out empty buckets
135 : *
136 : * while (index->nextBucket(status)) {
137 : * if (showAll || index->getBucketRecordCount() != 0) {
138 : * showLabelAtTop(UI, index->getBucketLabel());
139 : * }
140 : * }
141 : * ...
142 : * // Show the buckets with their contents, skipping empty buckets
143 : *
144 : * index->resetBucketIterator(status);
145 : * while (index->nextBucket(status)) {
146 : * if (index->getBucketRecordCount() != 0) {
147 : * showLabelInList(UI, index->getBucketLabel());
148 : * while (index->nextRecord(status)) {
149 : * showIndexedItem(UI, static_cast<Item *>(index->getRecordData()))
150 : * </pre>
151 : *
152 : * The caller can build different UIs using this class.
153 : * For example, an index character could be omitted or grayed-out
154 : * if its bucket is empty. Small buckets could also be combined based on size, such as:
155 : *
156 : * <pre>
157 : * <b>... A-F G-N O-Z ...</b>
158 : * </pre>
159 : *
160 : * <h2>Client Support</h2>
161 : * <p>Callers can also use the AlphabeticIndex::ImmutableIndex, or the AlphabeticIndex itself,
162 : * to support sorting on a client that doesn't support AlphabeticIndex functionality.
163 : *
164 : * <p>The ImmutableIndex is both immutable and thread-safe.
165 : * The corresponding AlphabeticIndex methods are not thread-safe because
166 : * they "lazily" build the index buckets.
167 : * <ul>
168 : * <li>ImmutableIndex.getBucket(index) provides random access to all
169 : * buckets and their labels and label types.
170 : * <li>The AlphabeticIndex bucket iterator or ImmutableIndex.getBucket(0..getBucketCount-1)
171 : * can be used to get a list of the labels,
172 : * such as "...", "A", "B",..., and send that list to the client.
173 : * <li>When the client has a new name, it sends that name to the server.
174 : * The server needs to call the following methods,
175 : * and communicate the bucketIndex and collationKey back to the client.
176 : *
177 : * <pre>
178 : * int32_t bucketIndex = index.getBucketIndex(name, status);
179 : * const UnicodeString &label = immutableIndex.getBucket(bucketIndex)->getLabel(); // optional
180 : * int32_t skLength = collator.getSortKey(name, sk, skCapacity);
181 : * </pre>
182 : *
183 : * <li>The client would put the name (and associated information) into its bucket for bucketIndex. The sort key sk is a
184 : * sequence of bytes that can be compared with a binary compare, and produce the right localized result.</li>
185 : * </ul>
186 : *
187 : * @stable ICU 4.8
188 : */
189 : class U_I18N_API AlphabeticIndex: public UObject {
190 : public:
191 : /**
192 : * An index "bucket" with a label string and type.
193 : * It is referenced by getBucketIndex(),
194 : * and returned by ImmutableIndex.getBucket().
195 : *
196 : * The Bucket class is not intended for public subclassing.
197 : * @stable ICU 51
198 : */
199 : class U_I18N_API Bucket : public UObject {
200 : public:
201 : /**
202 : * Destructor.
203 : * @stable ICU 51
204 : */
205 : virtual ~Bucket();
206 :
207 : /**
208 : * Returns the label string.
209 : *
210 : * @return the label string for the bucket
211 : * @stable ICU 51
212 : */
213 : const UnicodeString &getLabel() const { return label_; }
214 : /**
215 : * Returns whether this bucket is a normal, underflow, overflow, or inflow bucket.
216 : *
217 : * @return the bucket label type
218 : * @stable ICU 51
219 : */
220 : UAlphabeticIndexLabelType getLabelType() const { return labelType_; }
221 :
222 : private:
223 : friend class AlphabeticIndex;
224 : friend class BucketList;
225 :
226 : UnicodeString label_;
227 : UnicodeString lowerBoundary_;
228 : UAlphabeticIndexLabelType labelType_;
229 : Bucket *displayBucket_;
230 : int32_t displayIndex_;
231 : UVector *records_; // Records are owned by the inputList_ vector.
232 :
233 : Bucket(const UnicodeString &label, // Parameter strings are copied.
234 : const UnicodeString &lowerBoundary,
235 : UAlphabeticIndexLabelType type);
236 : };
237 :
238 : /**
239 : * Immutable, thread-safe version of AlphabeticIndex.
240 : * This class provides thread-safe methods for bucketing,
241 : * and random access to buckets and their properties,
242 : * but does not offer adding records to the index.
243 : *
244 : * The ImmutableIndex class is not intended for public subclassing.
245 : *
246 : * @stable ICU 51
247 : */
248 : class U_I18N_API ImmutableIndex : public UObject {
249 : public:
250 : /**
251 : * Destructor.
252 : * @stable ICU 51
253 : */
254 : virtual ~ImmutableIndex();
255 :
256 : /**
257 : * Returns the number of index buckets and labels, including underflow/inflow/overflow.
258 : *
259 : * @return the number of index buckets
260 : * @stable ICU 51
261 : */
262 : int32_t getBucketCount() const;
263 :
264 : /**
265 : * Finds the index bucket for the given name and returns the number of that bucket.
266 : * Use getBucket() to get the bucket's properties.
267 : *
268 : * @param name the string to be sorted into an index bucket
269 : * @return the bucket number for the name
270 : * @stable ICU 51
271 : */
272 : int32_t getBucketIndex(const UnicodeString &name, UErrorCode &errorCode) const;
273 :
274 : /**
275 : * Returns the index-th bucket. Returns NULL if the index is out of range.
276 : *
277 : * @param index bucket number
278 : * @return the index-th bucket
279 : * @stable ICU 51
280 : */
281 : const Bucket *getBucket(int32_t index) const;
282 :
283 : private:
284 : friend class AlphabeticIndex;
285 :
286 0 : ImmutableIndex(BucketList *bucketList, Collator *collatorPrimaryOnly)
287 0 : : buckets_(bucketList), collatorPrimaryOnly_(collatorPrimaryOnly) {}
288 :
289 : BucketList *buckets_;
290 : Collator *collatorPrimaryOnly_;
291 : };
292 :
293 : /**
294 : * Construct an AlphabeticIndex object for the specified locale. If the locale's
295 : * data does not include index characters, a set of them will be
296 : * synthesized based on the locale's exemplar characters. The locale
297 : * determines the sorting order for both the index characters and the
298 : * user item names appearing under each Index character.
299 : *
300 : * @param locale the desired locale.
301 : * @param status Error code, will be set with the reason if the construction
302 : * of the AlphabeticIndex object fails.
303 : * @stable ICU 4.8
304 : */
305 : AlphabeticIndex(const Locale &locale, UErrorCode &status);
306 :
307 : /**
308 : * Construct an AlphabeticIndex that uses a specific collator.
309 : *
310 : * The index will be created with no labels; the addLabels() function must be called
311 : * after creation to add the desired labels to the index.
312 : *
313 : * The index adopts the collator, and is responsible for deleting it.
314 : * The caller should make no further use of the collator after creating the index.
315 : *
316 : * @param collator The collator to use to order the contents of this index.
317 : * @param status Error code, will be set with the reason if the
318 : * operation fails.
319 : * @stable ICU 51
320 : */
321 : AlphabeticIndex(RuleBasedCollator *collator, UErrorCode &status);
322 :
323 : /**
324 : * Add Labels to this Index. The labels are additions to those
325 : * that are already in the index; they do not replace the existing
326 : * ones.
327 : * @param additions The additional characters to add to the index, such as A-Z.
328 : * @param status Error code, will be set with the reason if the
329 : * operation fails.
330 : * @return this, for chaining
331 : * @stable ICU 4.8
332 : */
333 : virtual AlphabeticIndex &addLabels(const UnicodeSet &additions, UErrorCode &status);
334 :
335 : /**
336 : * Add the index characters from a Locale to the index. The labels
337 : * are added to those that are already in the index; they do not replace the
338 : * existing index characters. The collation order for this index is not
339 : * changed; it remains that of the locale that was originally specified
340 : * when creating this Index.
341 : *
342 : * @param locale The locale whose index characters are to be added.
343 : * @param status Error code, will be set with the reason if the
344 : * operation fails.
345 : * @return this, for chaining
346 : * @stable ICU 4.8
347 : */
348 : virtual AlphabeticIndex &addLabels(const Locale &locale, UErrorCode &status);
349 :
350 : /**
351 : * Destructor
352 : * @stable ICU 4.8
353 : */
354 : virtual ~AlphabeticIndex();
355 :
356 : /**
357 : * Builds an immutable, thread-safe version of this instance, without data records.
358 : *
359 : * @return an immutable index instance
360 : * @stable ICU 51
361 : */
362 : ImmutableIndex *buildImmutableIndex(UErrorCode &errorCode);
363 :
364 : /**
365 : * Get the Collator that establishes the ordering of the items in this index.
366 : * Ownership of the collator remains with the AlphabeticIndex instance.
367 : *
368 : * The returned collator is a reference to the internal collator used by this
369 : * index. It may be safely used to compare the names of items or to get
370 : * sort keys for names. However if any settings need to be changed,
371 : * or other non-const methods called, a cloned copy must be made first.
372 : *
373 : * @return The collator
374 : * @stable ICU 4.8
375 : */
376 : virtual const RuleBasedCollator &getCollator() const;
377 :
378 :
379 : /**
380 : * Get the default label used for abbreviated buckets <i>between</i> other index characters.
381 : * For example, consider the labels when Latin and Greek are used:
382 : * X Y Z ... Α Β Γ.
383 : *
384 : * @return inflow label
385 : * @stable ICU 4.8
386 : */
387 : virtual const UnicodeString &getInflowLabel() const;
388 :
389 : /**
390 : * Set the default label used for abbreviated buckets <i>between</i> other index characters.
391 : * An inflow label will be automatically inserted if two otherwise-adjacent label characters
392 : * are from different scripts, e.g. Latin and Cyrillic, and a third script, e.g. Greek,
393 : * sorts between the two. The default inflow character is an ellipsis (...)
394 : *
395 : * @param inflowLabel the new Inflow label.
396 : * @param status Error code, will be set with the reason if the operation fails.
397 : * @return this
398 : * @stable ICU 4.8
399 : */
400 : virtual AlphabeticIndex &setInflowLabel(const UnicodeString &inflowLabel, UErrorCode &status);
401 :
402 :
403 : /**
404 : * Get the special label used for items that sort after the last normal label,
405 : * and that would not otherwise have an appropriate label.
406 : *
407 : * @return the overflow label
408 : * @stable ICU 4.8
409 : */
410 : virtual const UnicodeString &getOverflowLabel() const;
411 :
412 :
413 : /**
414 : * Set the label used for items that sort after the last normal label,
415 : * and that would not otherwise have an appropriate label.
416 : *
417 : * @param overflowLabel the new overflow label.
418 : * @param status Error code, will be set with the reason if the operation fails.
419 : * @return this
420 : * @stable ICU 4.8
421 : */
422 : virtual AlphabeticIndex &setOverflowLabel(const UnicodeString &overflowLabel, UErrorCode &status);
423 :
424 : /**
425 : * Get the special label used for items that sort before the first normal label,
426 : * and that would not otherwise have an appropriate label.
427 : *
428 : * @return underflow label
429 : * @stable ICU 4.8
430 : */
431 : virtual const UnicodeString &getUnderflowLabel() const;
432 :
433 : /**
434 : * Set the label used for items that sort before the first normal label,
435 : * and that would not otherwise have an appropriate label.
436 : *
437 : * @param underflowLabel the new underflow label.
438 : * @param status Error code, will be set with the reason if the operation fails.
439 : * @return this
440 : * @stable ICU 4.8
441 : */
442 : virtual AlphabeticIndex &setUnderflowLabel(const UnicodeString &underflowLabel, UErrorCode &status);
443 :
444 :
445 : /**
446 : * Get the limit on the number of labels permitted in the index.
447 : * The number does not include over, under and inflow labels.
448 : *
449 : * @return maxLabelCount maximum number of labels.
450 : * @stable ICU 4.8
451 : */
452 : virtual int32_t getMaxLabelCount() const;
453 :
454 : /**
455 : * Set a limit on the number of labels permitted in the index.
456 : * The number does not include over, under and inflow labels.
457 : * Currently, if the number is exceeded, then every
458 : * nth item is removed to bring the count down.
459 : * A more sophisticated mechanism may be available in the future.
460 : *
461 : * @param maxLabelCount the maximum number of labels.
462 : * @param status error code
463 : * @return This, for chaining
464 : * @stable ICU 4.8
465 : */
466 : virtual AlphabeticIndex &setMaxLabelCount(int32_t maxLabelCount, UErrorCode &status);
467 :
468 :
469 : /**
470 : * Add a record to the index. Each record will be associated with an index Bucket
471 : * based on the record's name. The list of records for each bucket will be sorted
472 : * based on the collation ordering of the names in the index's locale.
473 : * Records with duplicate names are permitted; they will be kept in the order
474 : * that they were added.
475 : *
476 : * @param name The display name for the Record. The Record will be placed in
477 : * a bucket based on this name.
478 : * @param data An optional pointer to user data associated with this
479 : * item. When iterating the contents of a bucket, both the
480 : * data pointer the name will be available for each Record.
481 : * @param status Error code, will be set with the reason if the operation fails.
482 : * @return This, for chaining.
483 : * @stable ICU 4.8
484 : */
485 : virtual AlphabeticIndex &addRecord(const UnicodeString &name, const void *data, UErrorCode &status);
486 :
487 : /**
488 : * Remove all Records from the Index. The set of Buckets, which define the headings under
489 : * which records are classified, is not altered.
490 : *
491 : * @param status Error code, will be set with the reason if the operation fails.
492 : * @return This, for chaining.
493 : * @stable ICU 4.8
494 : */
495 : virtual AlphabeticIndex &clearRecords(UErrorCode &status);
496 :
497 :
498 : /** Get the number of labels in this index.
499 : * Note: may trigger lazy index construction.
500 : *
501 : * @param status Error code, will be set with the reason if the operation fails.
502 : * @return The number of labels in this index, including any under, over or
503 : * in-flow labels.
504 : * @stable ICU 4.8
505 : */
506 : virtual int32_t getBucketCount(UErrorCode &status);
507 :
508 :
509 : /** Get the total number of Records in this index, that is, the number
510 : * of <name, data> pairs added.
511 : *
512 : * @param status Error code, will be set with the reason if the operation fails.
513 : * @return The number of records in this index, that is, the total number
514 : * of (name, data) items added with addRecord().
515 : * @stable ICU 4.8
516 : */
517 : virtual int32_t getRecordCount(UErrorCode &status);
518 :
519 :
520 :
521 : /**
522 : * Given the name of a record, return the zero-based index of the Bucket
523 : * in which the item should appear. The name need not be in the index.
524 : * A Record will not be added to the index by this function.
525 : * Bucket numbers are zero-based, in Bucket iteration order.
526 : *
527 : * @param itemName The name whose bucket position in the index is to be determined.
528 : * @param status Error code, will be set with the reason if the operation fails.
529 : * @return The bucket number for this name.
530 : * @stable ICU 4.8
531 : *
532 : */
533 : virtual int32_t getBucketIndex(const UnicodeString &itemName, UErrorCode &status);
534 :
535 :
536 : /**
537 : * Get the zero based index of the current Bucket from an iteration
538 : * over the Buckets of this index. Return -1 if no iteration is in process.
539 : * @return the index of the current Bucket
540 : * @stable ICU 4.8
541 : */
542 : virtual int32_t getBucketIndex() const;
543 :
544 :
545 : /**
546 : * Advance the iteration over the Buckets of this index. Return FALSE if
547 : * there are no more Buckets.
548 : *
549 : * @param status Error code, will be set with the reason if the operation fails.
550 : * U_ENUM_OUT_OF_SYNC_ERROR will be reported if the index is modified while
551 : * an enumeration of its contents are in process.
552 : *
553 : * @return TRUE if success, FALSE if at end of iteration
554 : * @stable ICU 4.8
555 : */
556 : virtual UBool nextBucket(UErrorCode &status);
557 :
558 : /**
559 : * Return the name of the Label of the current bucket from an iteration over the buckets.
560 : * If the iteration is before the first Bucket (nextBucket() has not been called),
561 : * or after the last, return an empty string.
562 : *
563 : * @return the bucket label.
564 : * @stable ICU 4.8
565 : */
566 : virtual const UnicodeString &getBucketLabel() const;
567 :
568 : /**
569 : * Return the type of the label for the current Bucket (selected by the
570 : * iteration over Buckets.)
571 : *
572 : * @return the label type.
573 : * @stable ICU 4.8
574 : */
575 : virtual UAlphabeticIndexLabelType getBucketLabelType() const;
576 :
577 : /**
578 : * Get the number of <name, data> Records in the current Bucket.
579 : * If the current bucket iteration position is before the first label or after the
580 : * last, return 0.
581 : *
582 : * @return the number of Records.
583 : * @stable ICU 4.8
584 : */
585 : virtual int32_t getBucketRecordCount() const;
586 :
587 :
588 : /**
589 : * Reset the Bucket iteration for this index. The next call to nextBucket()
590 : * will restart the iteration at the first label.
591 : *
592 : * @param status Error code, will be set with the reason if the operation fails.
593 : * @return this, for chaining.
594 : * @stable ICU 4.8
595 : */
596 : virtual AlphabeticIndex &resetBucketIterator(UErrorCode &status);
597 :
598 : /**
599 : * Advance to the next record in the current Bucket.
600 : * When nextBucket() is called, Record iteration is reset to just before the
601 : * first Record in the new Bucket.
602 : *
603 : * @param status Error code, will be set with the reason if the operation fails.
604 : * U_ENUM_OUT_OF_SYNC_ERROR will be reported if the index is modified while
605 : * an enumeration of its contents are in process.
606 : * @return TRUE if successful, FALSE when the iteration advances past the last item.
607 : * @stable ICU 4.8
608 : */
609 : virtual UBool nextRecord(UErrorCode &status);
610 :
611 : /**
612 : * Get the name of the current Record.
613 : * Return an empty string if the Record iteration position is before first
614 : * or after the last.
615 : *
616 : * @return The name of the current index item.
617 : * @stable ICU 4.8
618 : */
619 : virtual const UnicodeString &getRecordName() const;
620 :
621 :
622 : /**
623 : * Return the data pointer of the Record currently being iterated over.
624 : * Return NULL if the current iteration position before the first item in this Bucket,
625 : * or after the last.
626 : *
627 : * @return The current Record's data pointer.
628 : * @stable ICU 4.8
629 : */
630 : virtual const void *getRecordData() const;
631 :
632 :
633 : /**
634 : * Reset the Record iterator position to before the first Record in the current Bucket.
635 : *
636 : * @return This, for chaining.
637 : * @stable ICU 4.8
638 : */
639 : virtual AlphabeticIndex &resetRecordIterator();
640 :
641 : private:
642 : /**
643 : * No Copy constructor.
644 : * @internal
645 : */
646 : AlphabeticIndex(const AlphabeticIndex &other);
647 :
648 : /**
649 : * No assignment.
650 : */
651 : AlphabeticIndex &operator =(const AlphabeticIndex & /*other*/) { return *this;};
652 :
653 : /**
654 : * No Equality operators.
655 : * @internal
656 : */
657 : virtual UBool operator==(const AlphabeticIndex& other) const;
658 :
659 : /**
660 : * Inequality operator.
661 : * @internal
662 : */
663 : virtual UBool operator!=(const AlphabeticIndex& other) const;
664 :
665 : // Common initialization, for use from all constructors.
666 : void init(const Locale *locale, UErrorCode &status);
667 :
668 : /**
669 : * This method is called to get the index exemplars. Normally these come from the locale directly,
670 : * but if they aren't available, we have to synthesize them.
671 : */
672 : void addIndexExemplars(const Locale &locale, UErrorCode &status);
673 : /**
674 : * Add Chinese index characters from the tailoring.
675 : */
676 : UBool addChineseIndexCharacters(UErrorCode &errorCode);
677 :
678 : UVector *firstStringsInScript(UErrorCode &status);
679 :
680 : static UnicodeString separated(const UnicodeString &item);
681 :
682 : /**
683 : * Determine the best labels to use.
684 : * This is based on the exemplars, but we also process to make sure that they are unique,
685 : * and sort differently, and that the overall list is small enough.
686 : */
687 : void initLabels(UVector &indexCharacters, UErrorCode &errorCode) const;
688 : BucketList *createBucketList(UErrorCode &errorCode) const;
689 : void initBuckets(UErrorCode &errorCode);
690 : void clearBuckets();
691 : void internalResetBucketIterator();
692 :
693 : public:
694 :
695 : // The Record is declared public only to allow access from
696 : // implementation code written in plain C.
697 : // It is not intended for public use.
698 :
699 : #ifndef U_HIDE_INTERNAL_API
700 : /**
701 : * A (name, data) pair, to be sorted by name into one of the index buckets.
702 : * The user data is not used by the index implementation.
703 : * @internal
704 : */
705 : struct Record: public UMemory {
706 : const UnicodeString name_;
707 : const void *data_;
708 : Record(const UnicodeString &name, const void *data);
709 : ~Record();
710 : };
711 : #endif /* U_HIDE_INTERNAL_API */
712 :
713 : private:
714 :
715 : /**
716 : * Holds all user records before they are distributed into buckets.
717 : * Type of contents is (Record *)
718 : * @internal
719 : */
720 : UVector *inputList_;
721 :
722 : int32_t labelsIterIndex_; // Index of next item to return.
723 : int32_t itemsIterIndex_;
724 : Bucket *currentBucket_; // While an iteration of the index in underway,
725 : // point to the bucket for the current label.
726 : // NULL when no iteration underway.
727 :
728 : int32_t maxLabelCount_; // Limit on # of labels permitted in the index.
729 :
730 : UnicodeSet *initialLabels_; // Initial (unprocessed) set of Labels. Union
731 : // of those explicitly set by the user plus
732 : // those from locales. Raw values, before
733 : // crunching into bucket labels.
734 :
735 : UVector *firstCharsInScripts_; // The first character from each script,
736 : // in collation order.
737 :
738 : RuleBasedCollator *collator_;
739 : RuleBasedCollator *collatorPrimaryOnly_;
740 :
741 : // Lazy evaluated: null means that we have not built yet.
742 : BucketList *buckets_;
743 :
744 : UnicodeString inflowLabel_;
745 : UnicodeString overflowLabel_;
746 : UnicodeString underflowLabel_;
747 : UnicodeString overflowComparisonString_;
748 :
749 : UnicodeString emptyString_;
750 : };
751 :
752 : U_NAMESPACE_END
753 :
754 : #endif // !UCONFIG_NO_COLLATION
755 : #endif
|
