ICU 60.2  60.2
alphaindex.h
Go to the documentation of this file.
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 
28 
42 
49 
59 
67 
68 
69 struct UHashtable;
71 
73 
74 // Forward Declarations
75 
76 class BucketList;
77 class Collator;
78 class RuleBasedCollator;
79 class StringEnumeration;
80 class UnicodeSet;
81 class UVector;
82 
190 public:
199  class U_I18N_API Bucket : public UObject {
200  public:
205  virtual ~Bucket();
206 
213  const UnicodeString &getLabel() const { return label_; }
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,
236  };
237 
249  public:
254  virtual ~ImmutableIndex();
255 
262  int32_t getBucketCount() const;
263 
272  int32_t getBucketIndex(const UnicodeString &name, UErrorCode &errorCode) const;
273 
281  const Bucket *getBucket(int32_t index) const;
282 
283  private:
284  friend class AlphabeticIndex;
285 
286  ImmutableIndex(BucketList *bucketList, Collator *collatorPrimaryOnly)
287  : buckets_(bucketList), collatorPrimaryOnly_(collatorPrimaryOnly) {}
288 
289  BucketList *buckets_;
290  Collator *collatorPrimaryOnly_;
291  };
292 
305  AlphabeticIndex(const Locale &locale, UErrorCode &status);
306 
321  AlphabeticIndex(RuleBasedCollator *collator, UErrorCode &status);
322 
333  virtual AlphabeticIndex &addLabels(const UnicodeSet &additions, UErrorCode &status);
334 
348  virtual AlphabeticIndex &addLabels(const Locale &locale, UErrorCode &status);
349 
354  virtual ~AlphabeticIndex();
355 
362  ImmutableIndex *buildImmutableIndex(UErrorCode &errorCode);
363 
376  virtual const RuleBasedCollator &getCollator() const;
377 
378 
387  virtual const UnicodeString &getInflowLabel() const;
388 
400  virtual AlphabeticIndex &setInflowLabel(const UnicodeString &inflowLabel, UErrorCode &status);
401 
402 
410  virtual const UnicodeString &getOverflowLabel() const;
411 
412 
422  virtual AlphabeticIndex &setOverflowLabel(const UnicodeString &overflowLabel, UErrorCode &status);
423 
431  virtual const UnicodeString &getUnderflowLabel() const;
432 
442  virtual AlphabeticIndex &setUnderflowLabel(const UnicodeString &underflowLabel, UErrorCode &status);
443 
444 
452  virtual int32_t getMaxLabelCount() const;
453 
466  virtual AlphabeticIndex &setMaxLabelCount(int32_t maxLabelCount, UErrorCode &status);
467 
468 
485  virtual AlphabeticIndex &addRecord(const UnicodeString &name, const void *data, UErrorCode &status);
486 
495  virtual AlphabeticIndex &clearRecords(UErrorCode &status);
496 
497 
506  virtual int32_t getBucketCount(UErrorCode &status);
507 
508 
517  virtual int32_t getRecordCount(UErrorCode &status);
518 
519 
520 
533  virtual int32_t getBucketIndex(const UnicodeString &itemName, UErrorCode &status);
534 
535 
542  virtual int32_t getBucketIndex() const;
543 
544 
556  virtual UBool nextBucket(UErrorCode &status);
557 
566  virtual const UnicodeString &getBucketLabel() const;
567 
575  virtual UAlphabeticIndexLabelType getBucketLabelType() const;
576 
585  virtual int32_t getBucketRecordCount() const;
586 
587 
596  virtual AlphabeticIndex &resetBucketIterator(UErrorCode &status);
597 
609  virtual UBool nextRecord(UErrorCode &status);
610 
619  virtual const UnicodeString &getRecordName() const;
620 
621 
630  virtual const void *getRecordData() const;
631 
632 
639  virtual AlphabeticIndex &resetRecordIterator();
640 
641 private:
646  AlphabeticIndex(const AlphabeticIndex &other);
647 
651  AlphabeticIndex &operator =(const AlphabeticIndex & /*other*/) { return *this;};
652 
657  virtual UBool operator==(const AlphabeticIndex& other) const;
658 
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 
672  void addIndexExemplars(const Locale &locale, UErrorCode &status);
676  UBool addChineseIndexCharacters(UErrorCode &errorCode);
677 
678  UVector *firstStringsInScript(UErrorCode &status);
679 
680  static UnicodeString separated(const UnicodeString &item);
681 
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 
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 
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 
753 
754 #endif // !UCONFIG_NO_COLLATION
755 #endif
The Collator class performs locale-sensitive string comparison.
Definition: coll.h:165
const UnicodeString & getLabel() const
Returns the label string.
Definition: alphaindex.h:213
C++ API: Unicode String.
U_EXPORT UBool operator==(const StringPiece &x, const StringPiece &y)
Global operator == for StringPiece.
Inflow Label.
Definition: alphaindex.h:58
Normal Label, typically the starting letter of the names in the bucket with this label.
Definition: alphaindex.h:41
#define U_CDECL_BEGIN
This is used to begin a declaration of a library private ICU C API.
Definition: umachine.h:84
#define U_I18N_API
Set to export library symbols from inside the i18n library, and to import them from outside...
Definition: utypes.h:360
An index "bucket" with a label string and type.
Definition: alphaindex.h:199
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:131
The RuleBasedCollator class provides the implementation of Collator, using data-driven tables...
Definition: tblcoll.h:113
Immutable, thread-safe version of AlphabeticIndex.
Definition: alphaindex.h:248
UBool operator!=(const StringPiece &x, const StringPiece &y)
Global operator != for StringPiece.
Definition: stringpiece.h:218
A mutable set of Unicode characters and multicharacter strings.
Definition: uniset.h:278
A (name, data) pair, to be sorted by name into one of the index buckets.
Definition: alphaindex.h:705
C++ API: Common ICU base class UObject.
#define U_CDECL_END
This is used to end a declaration of a library private ICU C API.
Definition: umachine.h:85
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:132
AlphabeticIndex supports the creation of a UI index appropriate for a given language.
Definition: alphaindex.h:189
UErrorCode
Error code to replace exception handling, so that the code is compatible with all C++ compilers...
Definition: utypes.h:396
Overflow Label.
Definition: alphaindex.h:65
C++ API: Locale ID object.
Basic definitions for ICU, for both C and C++ APIs.
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:286
UAlphabeticIndexLabelType getLabelType() const
Returns whether this bucket is a normal, underflow, overflow, or inflow bucket.
Definition: alphaindex.h:220
Undeflow Label.
Definition: alphaindex.h:48
UObject is the common ICU "boilerplate" class.
Definition: uobject.h:223
UMemory is the common ICU base class.
Definition: uobject.h:112
int8_t UBool
The ICU boolean type.
Definition: umachine.h:236
A Locale object represents a specific geographical, political, or cultural region.
Definition: locid.h:188
UAlphabeticIndexLabelType
Constants for Alphabetic Index Label Types.
Definition: alphaindex.h:35