alphaindex.h

Go to the documentation of this file.

/*
*******************************************************************************
*
*   Copyright (C) 2011-2014 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
 
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 BucketList;
class Collator;
class RuleBasedCollator;
class StringEnumeration;
class UnicodeSet;
class UVector;
 
class U_I18N_API AlphabeticIndex: public UObject {
public:
     class U_I18N_API Bucket : public UObject {
     public:
        virtual ~Bucket();
 
        const UnicodeString &getLabel() const { return label_; }
        UAlphabeticIndexLabelType getLabelType() const { return labelType_; }
 
     private:
        friend class AlphabeticIndex;
        friend class BucketList;
 
        UnicodeString label_;
        UnicodeString lowerBoundary_;
        UAlphabeticIndexLabelType labelType_;
        Bucket *displayBucket_;
        int32_t displayIndex_;
        UVector *records_;  // Records are owned by the inputList_ vector.
 
        Bucket(const UnicodeString &label,   // Parameter strings are copied.
               const UnicodeString &lowerBoundary,
               UAlphabeticIndexLabelType type);
     };
 
    class U_I18N_API ImmutableIndex : public UObject {
    public:
        virtual ~ImmutableIndex();
 
        int32_t getBucketCount() const;
 
        int32_t getBucketIndex(const UnicodeString &name, UErrorCode &errorCode) const;
 
        const Bucket *getBucket(int32_t index) const;
 
    private:
        friend class AlphabeticIndex;
 
        ImmutableIndex(BucketList *bucketList, Collator *collatorPrimaryOnly)
                : buckets_(bucketList), collatorPrimaryOnly_(collatorPrimaryOnly) {}
 
        BucketList *buckets_;
        Collator *collatorPrimaryOnly_;
    };
 
     AlphabeticIndex(const Locale &locale, UErrorCode &status);
 
    AlphabeticIndex(RuleBasedCollator *collator, UErrorCode &status);
 
    virtual AlphabeticIndex &addLabels(const UnicodeSet &additions, UErrorCode &status);
 
    virtual AlphabeticIndex &addLabels(const Locale &locale, UErrorCode &status);
 
    virtual ~AlphabeticIndex();
 
    ImmutableIndex *buildImmutableIndex(UErrorCode &errorCode);
 
    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 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:
     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(const Locale *locale, UErrorCode &status);
 
    void addIndexExemplars(const Locale &locale, UErrorCode &status);
    UBool addChineseIndexCharacters(UErrorCode &errorCode);
 
    UVector *firstStringsInScript(UErrorCode &status);
 
    static UnicodeString separated(const UnicodeString &item);
 
    void initLabels(UVector &indexCharacters, UErrorCode &errorCode) const;
    BucketList *createBucketList(UErrorCode &errorCode) const;
    void initBuckets(UErrorCode &errorCode);
    void clearBuckets();
    void internalResetBucketIterator();
 
public:
 
    //  The Record is declared public only to allow access from
    //  implementation code written in plain C.
    //  It is not intended for public use.
 
#ifndef U_HIDE_INTERNAL_API
    struct Record: public UMemory {
        const UnicodeString  name_;
        const void           *data_;
        Record(const UnicodeString &name, const void *data);
        ~Record();
    };
#endif  /* U_HIDE_INTERNAL_API */
 
private:
 
    UVector  *inputList_;
 
    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.
 
    int32_t    maxLabelCount_;        // Limit on # of labels permitted in the index.
 
    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 *firstCharsInScripts_;    // The first character from each script,
                                      //   in collation order.
 
    RuleBasedCollator *collator_;
    RuleBasedCollator *collatorPrimaryOnly_;
 
    // Lazy evaluated: null means that we have not built yet.
    BucketList *buckets_;
 
    UnicodeString  inflowLabel_;
    UnicodeString  overflowLabel_;
    UnicodeString  underflowLabel_;
    UnicodeString  overflowComparisonString_;
 
    UnicodeString emptyString_;
};
 
U_NAMESPACE_END
 
#endif  // !UCONFIG_NO_COLLATION
#endif