tblcoll.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) 1996-2016, International Business Machines Corporation and
* others. All Rights Reserved.
******************************************************************************
*/


 
#ifndef TBLCOLL_H
#define TBLCOLL_H
 
#include "unicode/utypes.h"
 
#if U_SHOW_CPLUSPLUS_API
 
#if !UCONFIG_NO_COLLATION
 
#include "unicode/coll.h"
#include "unicode/locid.h"
#include "unicode/uiter.h"
#include "unicode/ucol.h"
 
U_NAMESPACE_BEGIN
 
struct CollationCacheEntry;
struct CollationData;
struct CollationSettings;
struct CollationTailoring;
class StringSearch;
class CollationElementIterator;
class CollationKey;
class SortKeyByteSink;
class UnicodeSet;
class UnicodeString;
class UVector64;

class U_I18N_API_CLASS RuleBasedCollator final : public Collator {
public:
    U_I18N_API RuleBasedCollator(const UnicodeString& rules, UErrorCode& status);

    U_I18N_API RuleBasedCollator(const UnicodeString& rules,
                                 ECollationStrength collationStrength,
                                 UErrorCode& status);

    U_I18N_API RuleBasedCollator(const UnicodeString& rules,
                                 UColAttributeValue decompositionMode,
                                 UErrorCode& status);

    U_I18N_API RuleBasedCollator(const UnicodeString& rules,
                                 ECollationStrength collationStrength,
                                 UColAttributeValue decompositionMode,
                                 UErrorCode& status);
 
#ifndef U_HIDE_INTERNAL_API
    U_I18N_API RuleBasedCollator(const UnicodeString& rules,
                                 UParseError& parseError,
                                 UnicodeString& reason,
                                 UErrorCode& errorCode);
#endif  /* U_HIDE_INTERNAL_API */

    U_I18N_API RuleBasedCollator(const RuleBasedCollator& other);

    U_I18N_API RuleBasedCollator(const uint8_t* bin,
                                 int32_t length,
                                 const RuleBasedCollator* base,
                                 UErrorCode& status);

    U_I18N_API virtual ~RuleBasedCollator();

    U_I18N_API RuleBasedCollator& operator=(const RuleBasedCollator& other);

    U_I18N_API virtual bool operator==(const Collator& other) const override;

    U_I18N_API virtual RuleBasedCollator* clone() const override;

    U_I18N_API CollationElementIterator*
    createCollationElementIterator(const UnicodeString& source) const;

    U_I18N_API CollationElementIterator*
    createCollationElementIterator(const CharacterIterator& source) const;
 
    // Make deprecated versions of Collator::compare() visible.
    using Collator::compare;

    U_I18N_API virtual UCollationResult compare(const UnicodeString& source,
                                                const UnicodeString& target,
                                                UErrorCode& status) const override;

    U_I18N_API virtual UCollationResult compare(const UnicodeString& source,
                                                const UnicodeString& target,
                                                int32_t length,
                                                UErrorCode& status) const override;

    U_I18N_API virtual UCollationResult compare(const char16_t* source, int32_t sourceLength,
                                                const char16_t* target, int32_t targetLength,
                                                UErrorCode& status) const override;

    U_I18N_API virtual UCollationResult compare(UCharIterator& sIter,
                                                UCharIterator& tIter,
                                                UErrorCode& status) const override;

    U_I18N_API virtual UCollationResult compareUTF8(const StringPiece& source,
                                                    const StringPiece& target,
                                                    UErrorCode& status) const override;

    U_I18N_API virtual CollationKey& getCollationKey(const UnicodeString& source,
                                                     CollationKey& key,
                                                     UErrorCode& status) const override;

    U_I18N_API virtual CollationKey& getCollationKey(const char16_t* source,
                                                     int32_t sourceLength,
                                                     CollationKey& key,
                                                     UErrorCode& status) const override;

    U_I18N_API virtual int32_t hashCode() const override;
 
#ifndef U_FORCE_HIDE_DEPRECATED_API
    U_I18N_API virtual Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const override;
#endif  // U_FORCE_HIDE_DEPRECATED_API

    U_I18N_API const UnicodeString& getRules() const;

    U_I18N_API virtual void getVersion(UVersionInfo info) const override;
 
#ifndef U_HIDE_DEPRECATED_API
    U_I18N_API int32_t getMaxExpansion(int32_t order) const;
#endif  /* U_HIDE_DEPRECATED_API */

    U_I18N_API virtual UClassID getDynamicClassID() const override;

    U_I18N_API static UClassID getStaticClassID();
 
#ifndef U_HIDE_DEPRECATED_API
    U_I18N_API uint8_t* cloneRuleData(int32_t& length, UErrorCode& status) const;
#endif  /* U_HIDE_DEPRECATED_API */

    U_I18N_API int32_t cloneBinary(uint8_t* buffer, int32_t capacity, UErrorCode& status) const;

    U_I18N_API void getRules(UColRuleOption delta, UnicodeString& buffer) const;

    U_I18N_API virtual void setAttribute(UColAttribute attr,
                                         UColAttributeValue value,
                                         UErrorCode& status) override;

    U_I18N_API virtual UColAttributeValue getAttribute(UColAttribute attr,
                                                       UErrorCode& status) const override;

    U_I18N_API virtual Collator& setMaxVariable(UColReorderCode group, UErrorCode& errorCode) override;

    U_I18N_API virtual UColReorderCode getMaxVariable() const override;
 
#ifndef U_FORCE_HIDE_DEPRECATED_API
    U_I18N_API virtual uint32_t setVariableTop(const char16_t* varTop,
                                               int32_t len,
                                               UErrorCode& status) override;

    U_I18N_API virtual uint32_t setVariableTop(const UnicodeString& varTop, UErrorCode& status) override;

    U_I18N_API virtual void setVariableTop(uint32_t varTop, UErrorCode& status) override;
#endif  // U_FORCE_HIDE_DEPRECATED_API

    U_I18N_API virtual uint32_t getVariableTop(UErrorCode& status) const override;

    U_I18N_API virtual UnicodeSet* getTailoredSet(UErrorCode& status) const override;

    U_I18N_API virtual int32_t getSortKey(const UnicodeString& source,
                                          uint8_t* result,
                                          int32_t resultLength) const override;

    U_I18N_API virtual int32_t getSortKey(const char16_t* source,
                                          int32_t sourceLength,
                                          uint8_t* result,
                                          int32_t resultLength) const override;

    U_I18N_API virtual int32_t getReorderCodes(int32_t* dest,
                                               int32_t destCapacity,
                                               UErrorCode& status) const override;

    U_I18N_API virtual void setReorderCodes(const int32_t* reorderCodes,
                                            int32_t reorderCodesLength,
                                            UErrorCode& status) override;

    U_I18N_API virtual UCollationResult internalCompareUTF8(const char* left, int32_t leftLength,
                                                            const char* right, int32_t rightLength,
                                                            UErrorCode& errorCode) const override;

    U_I18N_API virtual int32_t internalGetShortDefinitionString(const char* locale,
                                                                char* buffer,
                                                                int32_t capacity,
                                                                UErrorCode& status) const override;

    U_I18N_API virtual int32_t internalNextSortKeyPart(UCharIterator* iter,
                                                       uint32_t state[2],
                                                       uint8_t* dest,
                                                       int32_t count,
                                                       UErrorCode& errorCode) const override;
 
    // Do not enclose the default constructor with #ifndef U_HIDE_INTERNAL_API
    U_I18N_API RuleBasedCollator();
 
#ifndef U_HIDE_INTERNAL_API
    U_I18N_API const char* internalGetLocaleID(ULocDataLocaleType type, UErrorCode& errorCode) const;

    U_I18N_API void internalGetContractionsAndExpansions(UnicodeSet* contractions,
                                                         UnicodeSet* expansions,
                                                         UBool addPrefixes,
                                                         UErrorCode& errorCode) const;

    U_I18N_API void internalAddContractions(UChar32 c, UnicodeSet& set, UErrorCode& errorCode) const;

    U_I18N_API void internalBuildTailoring(const UnicodeString& rules,
                                           int32_t strength,
                                           UColAttributeValue decompositionMode,
                                           UParseError* outParseError,
                                           UnicodeString* outReason,
                                           UErrorCode& errorCode);

    static inline RuleBasedCollator *rbcFromUCollator(UCollator *uc) {
        return dynamic_cast<RuleBasedCollator *>(fromUCollator(uc));
    }

    static inline const RuleBasedCollator *rbcFromUCollator(const UCollator *uc) {
        return dynamic_cast<const RuleBasedCollator *>(fromUCollator(uc));
    }

    U_I18N_API void internalGetCEs(const UnicodeString& str,
                                   UVector64& ces,
                                   UErrorCode& errorCode) const;
#endif  // U_HIDE_INTERNAL_API
 
protected:
    virtual void setLocales(const Locale& requestedLocale, const Locale& validLocale, const Locale& actualLocale) override;
 
private:
    friend class CollationElementIterator;
    friend class Collator;
 
    RuleBasedCollator(const CollationCacheEntry *entry);

    enum Attributes {
        ATTR_VARIABLE_TOP = UCOL_ATTRIBUTE_COUNT,
        ATTR_LIMIT
    };
 
    void adoptTailoring(CollationTailoring *t, UErrorCode &errorCode);
 
    // Both lengths must be <0 or else both must be >=0.
    UCollationResult doCompare(const char16_t *left, int32_t leftLength,
                               const char16_t *right, int32_t rightLength,
                               UErrorCode &errorCode) const;
    UCollationResult doCompare(const uint8_t *left, int32_t leftLength,
                               const uint8_t *right, int32_t rightLength,
                               UErrorCode &errorCode) const;
 
    void writeSortKey(const char16_t *s, int32_t length,
                      SortKeyByteSink &sink, UErrorCode &errorCode) const;
 
    void writeIdenticalLevel(const char16_t *s, const char16_t *limit,
                             SortKeyByteSink &sink, UErrorCode &errorCode) const;
 
    const CollationSettings &getDefaultSettings() const;
 
    void setAttributeDefault(int32_t attribute) {
        explicitlySetAttributes &= ~(static_cast<uint32_t>(1) << attribute);
    }
    void setAttributeExplicitly(int32_t attribute) {
        explicitlySetAttributes |= static_cast<uint32_t>(1) << attribute;
    }
    UBool attributeHasBeenSetExplicitly(int32_t attribute) const {
        // assert(0 <= attribute < ATTR_LIMIT);
        return (explicitlySetAttributes & (static_cast<uint32_t>(1) << attribute)) != 0;
    }

    UBool isUnsafe(UChar32 c) const;
 
    static void U_CALLCONV computeMaxExpansions(const CollationTailoring *t, UErrorCode &errorCode);
    UBool initMaxExpansions(UErrorCode &errorCode) const;
 
    void setFastLatinOptions(CollationSettings &ownedSettings) const;
 
    const CollationData *data;
    const CollationSettings *settings;  // reference-counted
    const CollationTailoring *tailoring;  // alias of cacheEntry->tailoring
    const CollationCacheEntry *cacheEntry;  // reference-counted
    Locale validLocale;
    uint32_t explicitlySetAttributes;
 
    UBool actualLocaleIsSameAsValid;
};
 
U_NAMESPACE_END
 
#endif  // !UCONFIG_NO_COLLATION
 
#endif /* U_SHOW_CPLUSPLUS_API */
 
#endif  // TBLCOLL_H