alphaindex.h

Go to the documentation of this file.

// © 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"
#include "unicode/uobject.h"
#include "unicode/locid.h"
#include "unicode/unistr.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

---