alphaindex.h

Go to the documentation of this file.

/*
*******************************************************************************
*
*   Copyright (C) 2011-2012 International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*/
 
#ifndef INDEXCHARS_H
#define INDEXCHARS_H
 
#include "unicode/utypes.h"
#include "unicode/uobject.h"
#include "unicode/locid.h"
 
 
#if !UCONFIG_NO_COLLATION && !UCONFIG_NO_NORMALIZATION

 
U_CDECL_BEGIN

typedef enum UAlphabeticIndexLabelType {
    U_ALPHAINDEX_NORMAL    = 0,

    U_ALPHAINDEX_UNDERFLOW = 1,

    U_ALPHAINDEX_INFLOW    = 2,

    U_ALPHAINDEX_OVERFLOW  = 3
} UAlphabeticIndexLabelType;
 
 
struct UHashtable;
U_CDECL_END
 
U_NAMESPACE_BEGIN
 
// Forward Declarations
 
class Collator;
class RuleBasedCollator;
class StringEnumeration;
class UnicodeSet;
class UVector;
 
 

 
 
class U_I18N_API AlphabeticIndex: public UObject {
 
  public:

     AlphabeticIndex(const Locale &locale, UErrorCode &status);
 
 

     virtual AlphabeticIndex &addLabels(const UnicodeSet &additions, UErrorCode &status);

     virtual AlphabeticIndex &addLabels(const Locale &locale, UErrorCode &status);

     virtual ~AlphabeticIndex();
 

    virtual const RuleBasedCollator &getCollator() const;
 

    virtual const UnicodeString &getInflowLabel() const;

    virtual AlphabeticIndex &setInflowLabel(const UnicodeString &inflowLabel, UErrorCode &status);
 
 

    virtual const UnicodeString &getOverflowLabel() const;
 

    virtual AlphabeticIndex &setOverflowLabel(const UnicodeString &overflowLabel, UErrorCode &status);

    virtual const UnicodeString &getUnderflowLabel() const;

    virtual AlphabeticIndex &setUnderflowLabel(const UnicodeString &underflowLabel, UErrorCode &status);
 

    virtual int32_t getMaxLabelCount() const;

    virtual AlphabeticIndex &setMaxLabelCount(int32_t maxLabelCount, UErrorCode &status);
 

    virtual const UnicodeString &getOverflowComparisonString(const UnicodeString &lowerLimit,
                                                             UErrorCode &status);
 

    virtual AlphabeticIndex &addRecord(const UnicodeString &name, const void *data, UErrorCode &status);

    virtual AlphabeticIndex &clearRecords(UErrorCode &status);
 

    virtual int32_t  getBucketCount(UErrorCode &status);
 

    virtual int32_t  getRecordCount(UErrorCode &status);
 
 

    virtual int32_t  getBucketIndex(const UnicodeString &itemName, UErrorCode &status);
 

    virtual int32_t  getBucketIndex() const;
 

    virtual UBool nextBucket(UErrorCode &status);

    virtual const UnicodeString &getBucketLabel() const;

    virtual UAlphabeticIndexLabelType getBucketLabelType() const;

    virtual int32_t getBucketRecordCount() const;
 

    virtual AlphabeticIndex &resetBucketIterator(UErrorCode &status);

    virtual UBool nextRecord(UErrorCode &status);

    virtual const UnicodeString &getRecordName() const;
 

    virtual const void *getRecordData() const;
 

    virtual AlphabeticIndex &resetRecordIterator();
 
private:
    // No ICU "poor man's RTTI" for this class nor its subclasses.
    virtual UClassID getDynamicClassID() const;

     AlphabeticIndex(const AlphabeticIndex &other);

     AlphabeticIndex &operator =(const AlphabeticIndex & /*other*/) { return *this;};

     virtual UBool operator==(const AlphabeticIndex& other) const;

     virtual UBool operator!=(const AlphabeticIndex& other) const;
 
     // Common initialization, for use from all constructors.
     void init(UErrorCode &status);
 
     // Initialize & destruct static constants used by this class.
     static void staticInit(UErrorCode &status);
 
     // Pinyin stuff.  If the input name is Chinese, add the Pinyin prefix to the dest string.
     void hackName(UnicodeString &dest, const UnicodeString &name, const Collator *coll);
     void initPinyinBounds(const Collator *coll, UErrorCode &status);
 
   public:
#ifndef U_HIDE_INTERNAL_API
     static void staticCleanup();
#endif  /* U_HIDE_INTERNAL_API */
   private:
 
     // Add index characters from the specified locale to the dest set.
     // Does not remove any previous contents from dest.
     static void getIndexExemplars(UnicodeSet &dest, const Locale &locale, UErrorCode &status);
 
     UVector *firstStringsInScript(UErrorCode &status);
 
     static UnicodeString separated(const UnicodeString &item);
 
     static UnicodeSet *getScriptSet(UnicodeSet &dest, const UnicodeString &codePoint, UErrorCode &status);
 
     void buildIndex(UErrorCode &status);
     void buildBucketList(UErrorCode &status);
     void bucketRecords(UErrorCode &status);
 
 
  public:
 
    //  The following internal items are declared public only to allow access from
    //  implementation code written in plain C.  They are not intended for
    //  public use.
 
#ifndef U_HIDE_INTERNAL_API
     struct Record: public UMemory {
         AlphabeticIndex     *alphaIndex_;
         const UnicodeString  name_;
         UnicodeString        sortingName_;  // Usually the same as name_; different for Pinyin.
         const void           *data_;
         int32_t              serialNumber_;  // Defines sorting order for names that compare equal.
         Record(AlphabeticIndex *alphaIndex, const UnicodeString &name, const void *data);
         ~Record();
     };
#endif  /* U_HIDE_INTERNAL_API */

     UVector  *inputRecords_;

     struct Bucket: public UMemory {
         UnicodeString     label_;
         UnicodeString     lowerBoundary_;
         UAlphabeticIndexLabelType labelType_;
         UVector           *records_; // Records are owned by inputRecords_ vector.
 
         Bucket(const UnicodeString &label,   // Parameter strings are copied.
                const UnicodeString &lowerBoundary,
                UAlphabeticIndexLabelType type, UErrorCode &status);
         ~Bucket();
     };
 
  public:

    enum ELangType {
        kNormal,
        kSimplified,
        kTraditional
    };

    static ELangType  langTypeFromLocale(const Locale &loc);
 
 
   private:
 
     // Holds the contents of this index, buckets of user items.
     // UVector elements are of type (Bucket *)
     UVector *bucketList_;
 
     int32_t  labelsIterIndex_;      // Index of next item to return.
     int32_t  itemsIterIndex_;
     Bucket   *currentBucket_;       // While an iteration of the index in underway,
                                     //   point to the bucket for the current label.
                                     // NULL when no iteration underway.
 
     UBool    indexBuildRequired_;   //  Caller has made changes to the index that
                                     //  require rebuilding & bucketing before the
                                     //  contents can be iterated.
 
     int32_t    maxLabelCount_;      // Limit on # of labels permitted in the index.
 
     UHashtable *alreadyIn_;         // Key=UnicodeString, value=UnicodeSet
 
     UnicodeSet *initialLabels_;     // Initial (unprocessed) set of Labels.  Union
                                     //   of those explicitly set by the user plus
                                     //   those from locales.  Raw values, before
                                     //   crunching into bucket labels.
 
     UVector    *labels_;            // List of Labels, after processing, sorting.
                                     //   Contents are (UnicodeString *)
 
     UnicodeSet *noDistinctSorting_; // As the set of labels is built, strings may 
                                     // be discarded from the exemplars. This contains 
                                     // some of the discards, and is
                                     // intended for debugging.
 
     UnicodeSet *notAlphabetic_;     // As the set of labels is built, strings may 
                                     // be discarded from the exemplars. This contains 
                                     // some of the discards, and is
                                     // intended for debugging.
 
 
     UVector    *firstScriptCharacters_;  // The first character from each script,
                                          //   in collation order.
 
     Locale    locale_;
     Collator  *collator_;
     Collator  *collatorPrimaryOnly_;
 
     UnicodeString  inflowLabel_;
     UnicodeString  overflowLabel_;
     UnicodeString  underflowLabel_;
     UnicodeString  overflowComparisonString_;
 
     ELangType      langType_;        // The language type, simplified Chinese, Traditional Chinese,
                                      //  or not Chinese (Normal).  Part of the Pinyin support
 
     typedef const UChar PinyinLookup[24][3];
     static PinyinLookup   HACK_PINYIN_LOOKUP_SHORT;
     static PinyinLookup   HACK_PINYIN_LOOKUP_LONG;
     
     // These will be lazily set to the short or long tables based on which
     //   Chinese collation has been configured into the ICU library.
     static PinyinLookup   *HACK_PINYIN_LOOKUP;
     static const UChar    *PINYIN_LOWER_BOUNDS;
 
 
 
     int32_t    recordCounter_;         // Counts Records created.  For minting record serial numbers.
 
// Constants.  Lazily initialized the first time an AlphabeticIndex object is created.
 
     static UnicodeSet *ALPHABETIC;
     static UnicodeSet *CORE_LATIN;
     static UnicodeSet *ETHIOPIC;
     static UnicodeSet *HANGUL;
     static UnicodeSet *IGNORE_SCRIPTS;
     static UnicodeSet *TO_TRY;
     static UnicodeSet *UNIHAN;
     static const UnicodeString *EMPTY_STRING;
 
};
 
U_NAMESPACE_END
 
#endif /* UCONFIG_NO_COLLATION / UCONFIG_NO_NORMALIZATION */
#endif