uniset.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) 1999-2016, International Business Machines Corporation
* and others. All Rights Reserved.
***************************************************************************
*   Date        Name        Description
*   10/20/99    alan        Creation.
***************************************************************************
*/
 
#ifndef UNICODESET_H
#define UNICODESET_H
 
#include "unicode/utypes.h"
 
#if U_SHOW_CPLUSPLUS_API
 
#include "unicode/ucpmap.h"
#include "unicode/unifilt.h"
#include "unicode/unistr.h"
#include "unicode/uset.h"
 
U_NAMESPACE_BEGIN
 
// Forward Declarations.
class BMPSet;
class ParsePosition;
class RBBIRuleScanner;
class SymbolTable;
class UnicodeSetStringSpan;
class UVector;
class RuleCharacterIterator;
 
class U_COMMON_API UnicodeSet final : public UnicodeFilter {
private:
    static constexpr int32_t INITIAL_CAPACITY = 25;
    // fFlags constant
    static constexpr uint8_t kIsBogus = 1;  // This set is bogus (i.e. not valid)
 
    UChar32* list = stackList; // MUST be terminated with HIGH
    int32_t capacity = INITIAL_CAPACITY; // capacity of list
    int32_t len = 1; // length of list used; 1 <= len <= capacity
    uint8_t fFlags = 0;         // Bit flag (see constants above)
 
    BMPSet *bmpSet = nullptr; // The set is frozen iff either bmpSet or stringSpan is not nullptr.
    UChar32* buffer = nullptr; // internal buffer, may be nullptr
    int32_t bufferCapacity = 0; // capacity of buffer
 
    char16_t *pat = nullptr;
    int32_t patLen = 0;
 
    UVector* strings_ = nullptr; // maintained in sorted order
    UnicodeSetStringSpan *stringSpan = nullptr;
 
    UChar32 stackList[INITIAL_CAPACITY];
 
public:
    inline UBool isBogus() const;
 
    void setToBogus();
 
public:
 
    enum {
        MIN_VALUE = 0,
 
        MAX_VALUE = 0x10ffff
    };
 
    //----------------------------------------------------------------
    // Constructors &c
    //----------------------------------------------------------------
 
public:
 
    UnicodeSet();
 
    UnicodeSet(UChar32 start, UChar32 end);
 
#ifndef U_HIDE_INTERNAL_API
    enum ESerialization {
      kSerialized  /* result of serialize() */
    };
 
    UnicodeSet(const uint16_t buffer[], int32_t bufferLen,
               ESerialization serialization, UErrorCode &status);
#endif  /* U_HIDE_INTERNAL_API */
 
    UnicodeSet(const UnicodeString& pattern,
               UErrorCode& status);
 
#ifndef U_HIDE_INTERNAL_API
    UnicodeSet(const UnicodeString& pattern,
               uint32_t options,
               const SymbolTable* symbols,
               UErrorCode& status);
#endif  /* U_HIDE_INTERNAL_API */
 
    UnicodeSet(const UnicodeString& pattern, ParsePosition& pos,
               uint32_t options,
               const SymbolTable* symbols,
               UErrorCode& status);
 
    UnicodeSet(const UnicodeSet& o);
 
    virtual ~UnicodeSet();
 
    UnicodeSet& operator=(const UnicodeSet& o) U_LIFETIME_BOUND;
 
    bool operator==(const UnicodeSet& o) const;
 
    inline bool operator!=(const UnicodeSet& o) const;
 
    virtual UnicodeSet* clone() const override;
 
    int32_t hashCode() const;
 
    inline static UnicodeSet* fromUSet(USet* uset U_LIFETIME_BOUND);
 
    inline static const UnicodeSet* fromUSet(const USet* uset U_LIFETIME_BOUND);
 
    inline USet* toUSet() U_LIFETIME_BOUND;
 
    inline const USet* toUSet() const U_LIFETIME_BOUND;
 
 
    //----------------------------------------------------------------
    // Freezable API
    //----------------------------------------------------------------
 
    inline UBool isFrozen() const;
 
    UnicodeSet* freeze() U_LIFETIME_BOUND;
 
    UnicodeSet *cloneAsThawed() const;
 
    //----------------------------------------------------------------
    // Public API
    //----------------------------------------------------------------
 
    UnicodeSet& set(UChar32 start, UChar32 end) U_LIFETIME_BOUND;
 
    static UBool resemblesPattern(const UnicodeString& pattern,
                                  int32_t pos);
 
    UnicodeSet& applyPattern(const UnicodeString& pattern, UErrorCode& status) U_LIFETIME_BOUND;
 
#ifndef U_HIDE_INTERNAL_API
    UnicodeSet& applyPattern(const UnicodeString& pattern,
                             uint32_t options,
                             const SymbolTable* symbols,
                             UErrorCode& status) U_LIFETIME_BOUND;
#endif  /* U_HIDE_INTERNAL_API */
 
    UnicodeSet& applyPattern(const UnicodeString& pattern,
                             ParsePosition& pos,
                             uint32_t options,
                             const SymbolTable* symbols,
                             UErrorCode& status) U_LIFETIME_BOUND;
 
    virtual UnicodeString& toPattern(UnicodeString& result U_LIFETIME_BOUND,
                                     UBool escapeUnprintable = false) const override;
 
    UnicodeSet& applyIntPropertyValue(UProperty prop,
                                      int32_t value,
                                      UErrorCode& ec) U_LIFETIME_BOUND;
 
    UnicodeSet& applyPropertyAlias(const UnicodeString& prop,
                                   const UnicodeString& value,
                                   UErrorCode& ec) U_LIFETIME_BOUND;
 
    int32_t size() const;
 
    UBool isEmpty() const;
 
    UBool hasStrings() const;
 
    virtual UBool contains(UChar32 c) const override;
 
    UBool contains(UChar32 start, UChar32 end) const;
 
    UBool contains(const UnicodeString& s) const;
 
    UBool containsAll(const UnicodeSet& c) const;
 
    UBool containsAll(const UnicodeString& s) const;
 
    UBool containsNone(UChar32 start, UChar32 end) const;
 
    UBool containsNone(const UnicodeSet& c) const;
 
    UBool containsNone(const UnicodeString& s) const;
 
    inline UBool containsSome(UChar32 start, UChar32 end) const;
 
    inline UBool containsSome(const UnicodeSet& s) const;
 
    inline UBool containsSome(const UnicodeString& s) const;
 
    int32_t span(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const;
 
    inline int32_t span(const UnicodeString &s, int32_t start, USetSpanCondition spanCondition) const;
 
    int32_t spanBack(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const;
 
    inline int32_t spanBack(const UnicodeString &s, int32_t limit, USetSpanCondition spanCondition) const;
 
    int32_t spanUTF8(const char *s, int32_t length, USetSpanCondition spanCondition) const;
 
    int32_t spanBackUTF8(const char *s, int32_t length, USetSpanCondition spanCondition) const;
 
    UMatchDegree matches(const Replaceable& text,
                         int32_t& offset,
                         int32_t limit,
                         UBool incremental) override;
 
private:
    static int32_t matchRest(const Replaceable& text,
                             int32_t start, int32_t limit,
                             const UnicodeString& s);
 
    int32_t findCodePoint(UChar32 c) const;
 
public:
 
    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const override;
 
    int32_t indexOf(UChar32 c) const;
 
    UChar32 charAt(int32_t index) const;
 
    inline U_HEADER_NESTED_NAMESPACE::USetCodePoints codePoints() const U_LIFETIME_BOUND {
        return U_HEADER_NESTED_NAMESPACE::USetCodePoints(toUSet());
    }
 
    inline U_HEADER_NESTED_NAMESPACE::USetRanges ranges() const U_LIFETIME_BOUND {
        return U_HEADER_NESTED_NAMESPACE::USetRanges(toUSet());
    }
 
    inline U_HEADER_NESTED_NAMESPACE::USetStrings strings() const U_LIFETIME_BOUND {
        return U_HEADER_NESTED_NAMESPACE::USetStrings(toUSet());
    }
 
    inline U_HEADER_NESTED_NAMESPACE::USetElementIterator begin() const U_LIFETIME_BOUND {
        return U_HEADER_NESTED_NAMESPACE::USetElements(toUSet()).begin();
    }
 
    inline U_HEADER_NESTED_NAMESPACE::USetElementIterator end() const U_LIFETIME_BOUND {
        return U_HEADER_NESTED_NAMESPACE::USetElements(toUSet()).end();
    }
 
    UnicodeSet& add(UChar32 start, UChar32 end) U_LIFETIME_BOUND;
 
    UnicodeSet& add(UChar32 c) U_LIFETIME_BOUND;
 
    UnicodeSet& add(const UnicodeString& s) U_LIFETIME_BOUND;
 
 private:
    static int32_t getSingleCP(const UnicodeString& s);
 
    void _add(const UnicodeString& s);
 
 public:
    UnicodeSet& addAll(const UnicodeString& s) U_LIFETIME_BOUND;
 
    UnicodeSet& retainAll(const UnicodeString& s) U_LIFETIME_BOUND;
 
    UnicodeSet& complementAll(const UnicodeString& s) U_LIFETIME_BOUND;
 
    UnicodeSet& removeAll(const UnicodeString& s) U_LIFETIME_BOUND;
 
    static UnicodeSet* U_EXPORT2 createFrom(const UnicodeString& s);
 
 
    static UnicodeSet* U_EXPORT2 createFromAll(const UnicodeString& s);
 
    UnicodeSet& retain(UChar32 start, UChar32 end) U_LIFETIME_BOUND;
 
 
    UnicodeSet& retain(UChar32 c) U_LIFETIME_BOUND;
 
    UnicodeSet& retain(const UnicodeString& s) U_LIFETIME_BOUND;
 
    UnicodeSet& remove(UChar32 start, UChar32 end) U_LIFETIME_BOUND;
 
    UnicodeSet& remove(UChar32 c) U_LIFETIME_BOUND;
 
    UnicodeSet& remove(const UnicodeString& s) U_LIFETIME_BOUND;
 
    UnicodeSet& complement() U_LIFETIME_BOUND;
 
    UnicodeSet& complement(UChar32 start, UChar32 end) U_LIFETIME_BOUND;
 
    UnicodeSet& complement(UChar32 c) U_LIFETIME_BOUND;
 
    UnicodeSet& complement(const UnicodeString& s) U_LIFETIME_BOUND;
 
    UnicodeSet& addAll(const UnicodeSet& c) U_LIFETIME_BOUND;
 
    UnicodeSet& retainAll(const UnicodeSet& c) U_LIFETIME_BOUND;
 
    UnicodeSet& removeAll(const UnicodeSet& c) U_LIFETIME_BOUND;
 
    UnicodeSet& complementAll(const UnicodeSet& c) U_LIFETIME_BOUND;
 
    UnicodeSet& clear() U_LIFETIME_BOUND;
 
    UnicodeSet& closeOver(int32_t attribute) U_LIFETIME_BOUND;
 
    UnicodeSet& removeAllStrings() U_LIFETIME_BOUND;
 
    int32_t getRangeCount() const;
 
    UChar32 getRangeStart(int32_t index) const;
 
    UChar32 getRangeEnd(int32_t index) const;
 
    int32_t serialize(uint16_t *dest, int32_t destCapacity, UErrorCode& ec) const;
 
    UnicodeSet& compact() U_LIFETIME_BOUND;
 
    static UClassID U_EXPORT2 getStaticClassID();
 
    virtual UClassID getDynamicClassID() const override;
 
  private:
 
    // Private API for the USet API
 
    friend class USetAccess;
 
    const UnicodeString* getString(int32_t index) const U_LIFETIME_BOUND;
 
    //----------------------------------------------------------------
    // RuleBasedTransliterator support
    //----------------------------------------------------------------
 
private:
 
    virtual UBool matchesIndexValue(uint8_t v) const override;
 
private:
    friend class RBBIRuleScanner;
 
    //----------------------------------------------------------------
    // Implementation: Clone as thawed (see ICU4J Freezable)
    //----------------------------------------------------------------
 
    UnicodeSet(const UnicodeSet& o, UBool /* asThawed */);
    UnicodeSet& copyFrom(const UnicodeSet& o, UBool asThawed) U_LIFETIME_BOUND;
 
    //----------------------------------------------------------------
    // Implementation: Pattern parsing
    //----------------------------------------------------------------
 
    void applyPatternIgnoreSpace(const UnicodeString& pattern,
                                 ParsePosition& pos,
                                 const SymbolTable* symbols,
                                 UErrorCode& status);
 
    void applyPattern(const UnicodeString &pattern,
                      const ParsePosition& parsePosition,
                      RuleCharacterIterator &chars,
                      const SymbolTable *symbols,
                      UnicodeString &rebuiltPat,
                      uint32_t options,
                      UnicodeSet &(UnicodeSet::*caseClosure)(int32_t attribute),
                      UErrorCode &ec);
 
    // Recursive-descent predictive parsing.  These functions parse the syntactic categories
    // matching their name in the base grammar of PD UTR #56 (before the highlighted changes are
    // applied).
    // See https://www.unicode.org/reports/tr61/tr61-1.html#Set-Operations.
    // `parseUnicodeSet` clears `*this` and makes it represent the parsed UnicodeSet; all other functions
    // add the set represented by the parsed construct to `*this`.
 
    class Lexer;
 
    static UnicodeSet parseUnicodeSet(Lexer &lexer,
                                      UnicodeString &rebuiltPat,
                                      uint32_t options,
                                      UnicodeSet &(UnicodeSet::*caseClosure)(int32_t attribute),
                                      int32_t depth,
                                      UErrorCode &ec);
 
    static UnicodeSet parseContent(Lexer &lexer,
                                   UnicodeString &rebuiltPat,
                                   uint32_t options,
                                   UnicodeSet &(UnicodeSet::*caseClosure)(int32_t attribute),
                                   int32_t depth,
                                   bool &containsSetOperation,
                                   UErrorCode &ec);
 
    void parseMutation(Lexer &lexer,
                       UnicodeString &rebuiltPat,
                       uint32_t options,
                       UnicodeSet &(UnicodeSet::*caseClosure)(int32_t attribute),
                       int32_t depth,
                       bool &containsSetOperation,
                       UErrorCode &ec);
 
    void parseSetOperations(Lexer &lexer,
                            UnicodeString &rebuiltPat,
                            uint32_t options,
                            UnicodeSet &(UnicodeSet::*caseClosure)(int32_t attribute),
                            int32_t depth,
                            UErrorCode &ec);
 
    static UnicodeSet parseElements(Lexer &lexer,
                                    UnicodeString &rebuiltPat,
                                    UErrorCode &ec);
 
 
    void closeOverCaseInsensitive(bool simple);
    void closeOverAddCaseMappings();
 
    //----------------------------------------------------------------
    // Implementation: Utility methods
    //----------------------------------------------------------------
 
    static int32_t nextCapacity(int32_t minCapacity);
 
    bool ensureCapacity(int32_t newLen);
 
    bool ensureBufferCapacity(int32_t newLen);
 
    void swapBuffers();
 
    UBool allocateStrings(UErrorCode &status);
    int32_t stringsSize() const;
    UBool stringsContains(const UnicodeString &s) const;
 
    UnicodeString& _toPattern(UnicodeString& result U_LIFETIME_BOUND,
                              UBool escapeUnprintable) const;
 
    UnicodeString& _generatePattern(UnicodeString& result U_LIFETIME_BOUND,
                                    UBool escapeUnprintable) const;
 
    static void _appendToPat(UnicodeString& buf, const UnicodeString& s, UBool escapeUnprintable);
 
    static void _appendToPat(UnicodeString& buf, UChar32 c, UBool escapeUnprintable);
 
    static void _appendToPat(UnicodeString &result, UChar32 start, UChar32 end,
                             UBool escapeUnprintable);
 
    //----------------------------------------------------------------
    // Implementation: Fundamental operators
    //----------------------------------------------------------------
 
    void exclusiveOr(const UChar32* other, int32_t otherLen, int8_t polarity);
 
    void add(const UChar32* other, int32_t otherLen, int8_t polarity);
 
    void retain(const UChar32* other, int32_t otherLen, int8_t polarity);
 
    static UBool resemblesPropertyPattern(const UnicodeString& pattern,
                                          int32_t pos);
 
    UnicodeSet& applyPropertyPattern(const UnicodeString& pattern,
                                     ParsePosition& ppos,
                                     UErrorCode& ec) U_LIFETIME_BOUND;
 
    typedef UBool (*Filter)(UChar32 codePoint, void* context);
 
    void applyFilter(Filter filter,
                     void* context,
                     const UnicodeSet* inclusions,
                     UErrorCode &status);
 
    void setPattern(const UnicodeString& newPat) {
        setPattern(newPat.getBuffer(), newPat.length());
    }
    void setPattern(const char16_t *newPat, int32_t newPatLen);
    void releasePattern();
 
    friend class UnicodeSetIterator;
};
 
 
 
inline bool UnicodeSet::operator!=(const UnicodeSet& o) const {
    return !operator==(o);
}
 
inline UBool UnicodeSet::isFrozen() const {
    return bmpSet != nullptr || stringSpan != nullptr;
}
 
inline UBool UnicodeSet::containsSome(UChar32 start, UChar32 end) const {
    return !containsNone(start, end);
}
 
inline UBool UnicodeSet::containsSome(const UnicodeSet& s) const {
    return !containsNone(s);
}
 
inline UBool UnicodeSet::containsSome(const UnicodeString& s) const {
    return !containsNone(s);
}
 
inline UBool UnicodeSet::isBogus() const {
    return fFlags & kIsBogus;
}
 
inline UnicodeSet* UnicodeSet::fromUSet(USet* uset U_LIFETIME_BOUND) {
    return reinterpret_cast<UnicodeSet *>(uset);
}
 
inline const UnicodeSet* UnicodeSet::fromUSet(const USet* uset U_LIFETIME_BOUND) {
    return reinterpret_cast<const UnicodeSet *>(uset);
}
 
inline USet* UnicodeSet::toUSet() U_LIFETIME_BOUND {
    return reinterpret_cast<USet*>(this);
}
 
inline const USet* UnicodeSet::toUSet() const U_LIFETIME_BOUND {
    return reinterpret_cast<const USet *>(this);
}
 
inline int32_t UnicodeSet::span(const UnicodeString &s, int32_t start, USetSpanCondition spanCondition) const {
    int32_t sLength=s.length();
    if(start<0) {
        start=0;
    } else if(start>sLength) {
        start=sLength;
    }
    return start+span(s.getBuffer()+start, sLength-start, spanCondition);
}
 
inline int32_t UnicodeSet::spanBack(const UnicodeString &s, int32_t limit, USetSpanCondition spanCondition) const {
    int32_t sLength=s.length();
    if(limit<0) {
        limit=0;
    } else if(limit>sLength) {
        limit=sLength;
    }
    return spanBack(s.getBuffer(), limit, spanCondition);
}
 
U_NAMESPACE_END
 
#endif /* U_SHOW_CPLUSPLUS_API */
 
#endif