coleitr.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) 1997-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 ******************************************************************************
 */
 
#ifndef COLEITR_H
#define COLEITR_H
 
#include "unicode/utypes.h"
 
#if U_SHOW_CPLUSPLUS_API
 
#if !UCONFIG_NO_COLLATION
 
#include "unicode/unistr.h"
#include "unicode/uobject.h"
 
struct UCollationElements;
struct UHashtable;
 
U_NAMESPACE_BEGIN
 
struct CollationData;
 
class CharacterIterator;
class CollationIterator;
class RuleBasedCollator;
class UCollationPCE;
class UVector32;
 
class U_I18N_API CollationElementIterator final : public UObject {
public: 
 
    // CollationElementIterator public data member ------------------------------
 
    enum {
        NULLORDER = static_cast<int32_t>(0xffffffff)
    };
 
    // CollationElementIterator public constructor/destructor -------------------
 
    CollationElementIterator(const CollationElementIterator& other);
 
    virtual ~CollationElementIterator();
 
    // CollationElementIterator public methods ----------------------------------
 
    bool operator==(const CollationElementIterator& other) const;
 
    bool operator!=(const CollationElementIterator& other) const;
 
    void reset();
 
    int32_t next(UErrorCode& status);
 
    int32_t previous(UErrorCode& status);
 
    static inline int32_t primaryOrder(int32_t order);
 
    static inline int32_t secondaryOrder(int32_t order);
 
    static inline int32_t tertiaryOrder(int32_t order);
 
    int32_t getMaxExpansion(int32_t order) const;
 
    int32_t strengthOrder(int32_t order) const;
 
    void setText(const UnicodeString& str, UErrorCode& status);
 
    void setText(CharacterIterator& str, UErrorCode& status);
 
    static inline UBool isIgnorable(int32_t order);
 
    int32_t getOffset() const;
 
    void setOffset(int32_t newOffset, UErrorCode& status);
 
    virtual UClassID getDynamicClassID() const override;
 
    static UClassID U_EXPORT2 getStaticClassID();
 
#ifndef U_HIDE_INTERNAL_API
    static inline CollationElementIterator *fromUCollationElements(UCollationElements *uc) {
        return reinterpret_cast<CollationElementIterator *>(uc);
    }
    static inline const CollationElementIterator *fromUCollationElements(const UCollationElements *uc) {
        return reinterpret_cast<const CollationElementIterator *>(uc);
    }
    inline UCollationElements *toUCollationElements() {
        return reinterpret_cast<UCollationElements *>(this);
    }
    inline const UCollationElements *toUCollationElements() const {
        return reinterpret_cast<const UCollationElements *>(this);
    }
#endif  // U_HIDE_INTERNAL_API
 
private:
    friend class RuleBasedCollator;
    friend class UCollationPCE;
 
    CollationElementIterator(const UnicodeString& sourceText,
        const RuleBasedCollator* order, UErrorCode& status);
    // Note: The constructors should take settings & tailoring, not a collator,
    // to avoid circular dependencies.
    // However, for operator==() we would need to be able to compare tailoring data for equality
    // without making CollationData or CollationTailoring depend on TailoredSet.
    // (See the implementation of RuleBasedCollator::operator==().)
    // That might require creating an intermediate class that would be used
    // by both CollationElementIterator and RuleBasedCollator
    // but only contain the part of RBC== related to data and rules.
 
    CollationElementIterator(const CharacterIterator& sourceText,
        const RuleBasedCollator* order, UErrorCode& status);
 
    const CollationElementIterator&
        operator=(const CollationElementIterator& other);
 
    CollationElementIterator() = delete; // default constructor not implemented
 
    inline int8_t normalizeDir() const { return dir_ == 1 ? 0 : dir_; }
 
    static UHashtable *computeMaxExpansions(const CollationData *data, UErrorCode &errorCode);
 
    static int32_t getMaxExpansion(const UHashtable *maxExpansions, int32_t order);
 
    // CollationElementIterator private data members ----------------------------
 
    CollationIterator *iter_;  // owned
    const RuleBasedCollator *rbc_;  // aliased
    uint32_t otherHalf_;
    int8_t dir_;
    UVector32 *offsets_;
 
    UnicodeString string_;
};
 
// CollationElementIterator inline method definitions --------------------------
 
inline int32_t CollationElementIterator::primaryOrder(int32_t order)
{
    return (order >> 16) & 0xffff;
}
 
inline int32_t CollationElementIterator::secondaryOrder(int32_t order)
{
    return (order >> 8) & 0xff;
}
 
inline int32_t CollationElementIterator::tertiaryOrder(int32_t order)
{
    return order & 0xff;
}
 
inline UBool CollationElementIterator::isIgnorable(int32_t order)
{
    return (order & 0xffff0000) == 0;
}
 
U_NAMESPACE_END
 
#endif /* #if !UCONFIG_NO_COLLATION */
 
#endif /* U_SHOW_CPLUSPLUS_API */
 
#endif