ICU 70.1 70.1
uniset.h
Go to the documentation of this file.
1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4***************************************************************************
5* Copyright (C) 1999-2016, International Business Machines Corporation
6* and others. All Rights Reserved.
7***************************************************************************
8* Date Name Description
9* 10/20/99 alan Creation.
10***************************************************************************
11*/
12
13#ifndef UNICODESET_H
14#define UNICODESET_H
15
16#include "unicode/utypes.h"
17
18#if U_SHOW_CPLUSPLUS_API
19
20#include "unicode/ucpmap.h"
21#include "unicode/unifilt.h"
22#include "unicode/unistr.h"
23#include "unicode/uset.h"
24
30U_NAMESPACE_BEGIN
31
32// Forward Declarations.
33class BMPSet;
34class ParsePosition;
35class RBBIRuleScanner;
36class SymbolTable;
37class UnicodeSetStringSpan;
38class UVector;
39class RuleCharacterIterator;
40
286private:
291 static constexpr int32_t INITIAL_CAPACITY = 25;
292 // fFlags constant
293 static constexpr uint8_t kIsBogus = 1; // This set is bogus (i.e. not valid)
294
295 UChar32* list = stackList; // MUST be terminated with HIGH
296 int32_t capacity = INITIAL_CAPACITY; // capacity of list
297 int32_t len = 1; // length of list used; 1 <= len <= capacity
298 uint8_t fFlags = 0; // Bit flag (see constants above)
299
300 BMPSet *bmpSet = nullptr; // The set is frozen iff either bmpSet or stringSpan is not NULL.
301 UChar32* buffer = nullptr; // internal buffer, may be NULL
302 int32_t bufferCapacity = 0; // capacity of buffer
303
313 char16_t *pat = nullptr;
314 int32_t patLen = 0;
315
316 UVector* strings = nullptr; // maintained in sorted order
317 UnicodeSetStringSpan *stringSpan = nullptr;
318
324 UChar32 stackList[INITIAL_CAPACITY];
325
326public:
336 inline UBool isBogus(void) const;
337
355
356public:
357
358 enum {
363 MIN_VALUE = 0,
364
369 MAX_VALUE = 0x10ffff
370 };
371
372 //----------------------------------------------------------------
373 // Constructors &c
374 //----------------------------------------------------------------
375
376public:
377
383
393
394#ifndef U_HIDE_INTERNAL_API
399 kSerialized /* result of serialize() */
400 };
401
412 UnicodeSet(const uint16_t buffer[], int32_t bufferLen,
413 ESerialization serialization, UErrorCode &status);
414#endif /* U_HIDE_INTERNAL_API */
415
424 UnicodeSet(const UnicodeString& pattern,
425 UErrorCode& status);
426
427#ifndef U_HIDE_INTERNAL_API
440 UnicodeSet(const UnicodeString& pattern,
441 uint32_t options,
442 const SymbolTable* symbols,
443 UErrorCode& status);
444#endif /* U_HIDE_INTERNAL_API */
445
460 uint32_t options,
461 const SymbolTable* symbols,
462 UErrorCode& status);
463
469
474 virtual ~UnicodeSet();
475
482
494 virtual bool operator==(const UnicodeSet& o) const;
495
501 inline bool operator!=(const UnicodeSet& o) const;
502
512 virtual UnicodeSet* clone() const override;
513
521 virtual int32_t hashCode(void) const;
522
531 inline static UnicodeSet *fromUSet(USet *uset);
532
541 inline static const UnicodeSet *fromUSet(const USet *uset);
542
550 inline USet *toUSet();
551
552
560 inline const USet * toUSet() const;
561
562
563 //----------------------------------------------------------------
564 // Freezable API
565 //----------------------------------------------------------------
566
575 inline UBool isFrozen() const;
576
591
601
602 //----------------------------------------------------------------
603 // Public API
604 //----------------------------------------------------------------
605
616
622 static UBool resemblesPattern(const UnicodeString& pattern,
623 int32_t pos);
624
638 UErrorCode& status);
639
640#ifndef U_HIDE_INTERNAL_API
658 uint32_t options,
659 const SymbolTable* symbols,
660 UErrorCode& status);
661#endif /* U_HIDE_INTERNAL_API */
662
695 ParsePosition& pos,
696 uint32_t options,
697 const SymbolTable* symbols,
698 UErrorCode& status);
699
714 UBool escapeUnprintable = false) const override;
715
739 int32_t value,
740 UErrorCode& ec);
741
772 const UnicodeString& value,
773 UErrorCode& ec);
774
787 virtual int32_t size(void) const;
788
795 virtual UBool isEmpty(void) const;
796
797#ifndef U_HIDE_DRAFT_API
803#endif // U_HIDE_DRAFT_API
804
812 virtual UBool contains(UChar32 c) const override;
813
822 virtual UBool contains(UChar32 start, UChar32 end) const;
823
831 UBool contains(const UnicodeString& s) const;
832
840 virtual UBool containsAll(const UnicodeSet& c) const;
841
850
860
869
878
887 inline UBool containsSome(UChar32 start, UChar32 end) const;
888
896 inline UBool containsSome(const UnicodeSet& s) const;
897
905 inline UBool containsSome(const UnicodeString& s) const;
906
925 int32_t span(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const;
926
939 inline int32_t span(const UnicodeString &s, int32_t start, USetSpanCondition spanCondition) const;
940
958 int32_t spanBack(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const;
959
973 inline int32_t spanBack(const UnicodeString &s, int32_t limit, USetSpanCondition spanCondition) const;
974
993 int32_t spanUTF8(const char *s, int32_t length, USetSpanCondition spanCondition) const;
994
1012 int32_t spanBackUTF8(const char *s, int32_t length, USetSpanCondition spanCondition) const;
1013
1018 virtual UMatchDegree matches(const Replaceable& text,
1019 int32_t& offset,
1020 int32_t limit,
1021 UBool incremental) override;
1022
1023private:
1046 static int32_t matchRest(const Replaceable& text,
1047 int32_t start, int32_t limit,
1048 const UnicodeString& s);
1049
1059 int32_t findCodePoint(UChar32 c) const;
1060
1061public:
1062
1070 virtual void addMatchSetTo(UnicodeSet& toUnionTo) const override;
1071
1080 int32_t indexOf(UChar32 c) const;
1081
1097 UChar32 charAt(int32_t index) const;
1098
1113 virtual UnicodeSet& add(UChar32 start, UChar32 end);
1114
1126
1139
1140 private:
1146 static int32_t getSingleCP(const UnicodeString& s);
1147
1148 void _add(const UnicodeString& s);
1149
1150 public:
1160
1169
1178
1187
1196 static UnicodeSet* U_EXPORT2 createFrom(const UnicodeString& s);
1197
1198
1206 static UnicodeSet* U_EXPORT2 createFromAll(const UnicodeString& s);
1207
1219 virtual UnicodeSet& retain(UChar32 start, UChar32 end);
1220
1221
1231
1232#ifndef U_HIDE_DRAFT_API
1244#endif // U_HIDE_DRAFT_API
1245
1259 virtual UnicodeSet& remove(UChar32 start, UChar32 end);
1260
1272
1283
1297
1310 virtual UnicodeSet& complement(UChar32 start, UChar32 end);
1311
1323
1334
1347 virtual UnicodeSet& addAll(const UnicodeSet& c);
1348
1360 virtual UnicodeSet& retainAll(const UnicodeSet& c);
1361
1373 virtual UnicodeSet& removeAll(const UnicodeSet& c);
1374
1386
1393 virtual UnicodeSet& clear(void);
1394
1420 UnicodeSet& closeOver(int32_t attribute);
1421
1429
1437 virtual int32_t getRangeCount(void) const;
1438
1446 virtual UChar32 getRangeStart(int32_t index) const;
1447
1455 virtual UChar32 getRangeEnd(int32_t index) const;
1456
1505 int32_t serialize(uint16_t *dest, int32_t destCapacity, UErrorCode& ec) const;
1506
1514
1526 static UClassID U_EXPORT2 getStaticClassID(void);
1527
1536 virtual UClassID getDynamicClassID(void) const override;
1537
1538private:
1539
1540 // Private API for the USet API
1541
1542 friend class USetAccess;
1543
1544 const UnicodeString* getString(int32_t index) const;
1545
1546 //----------------------------------------------------------------
1547 // RuleBasedTransliterator support
1548 //----------------------------------------------------------------
1549
1550private:
1551
1557 virtual UBool matchesIndexValue(uint8_t v) const override;
1558
1559private:
1560 friend class RBBIRuleScanner;
1561
1562 //----------------------------------------------------------------
1563 // Implementation: Clone as thawed (see ICU4J Freezable)
1564 //----------------------------------------------------------------
1565
1566 UnicodeSet(const UnicodeSet& o, UBool /* asThawed */);
1567 UnicodeSet& copyFrom(const UnicodeSet& o, UBool asThawed);
1568
1569 //----------------------------------------------------------------
1570 // Implementation: Pattern parsing
1571 //----------------------------------------------------------------
1572
1573 void applyPatternIgnoreSpace(const UnicodeString& pattern,
1574 ParsePosition& pos,
1575 const SymbolTable* symbols,
1576 UErrorCode& status);
1577
1578 void applyPattern(RuleCharacterIterator& chars,
1579 const SymbolTable* symbols,
1580 UnicodeString& rebuiltPat,
1581 uint32_t options,
1582 UnicodeSet& (UnicodeSet::*caseClosure)(int32_t attribute),
1583 int32_t depth,
1584 UErrorCode& ec);
1585
1586 //----------------------------------------------------------------
1587 // Implementation: Utility methods
1588 //----------------------------------------------------------------
1589
1590 static int32_t nextCapacity(int32_t minCapacity);
1591
1592 bool ensureCapacity(int32_t newLen);
1593
1594 bool ensureBufferCapacity(int32_t newLen);
1595
1596 void swapBuffers(void);
1597
1598 UBool allocateStrings(UErrorCode &status);
1599 int32_t stringsSize() const;
1600 UBool stringsContains(const UnicodeString &s) const;
1601
1602 UnicodeString& _toPattern(UnicodeString& result,
1603 UBool escapeUnprintable) const;
1604
1605 UnicodeString& _generatePattern(UnicodeString& result,
1606 UBool escapeUnprintable) const;
1607
1608 static void _appendToPat(UnicodeString& buf, const UnicodeString& s, UBool escapeUnprintable);
1609
1610 static void _appendToPat(UnicodeString& buf, UChar32 c, UBool escapeUnprintable);
1611
1612 static void _appendToPat(UnicodeString &result, UChar32 start, UChar32 end,
1613 UBool escapeUnprintable);
1614
1615 //----------------------------------------------------------------
1616 // Implementation: Fundamental operators
1617 //----------------------------------------------------------------
1618
1619 void exclusiveOr(const UChar32* other, int32_t otherLen, int8_t polarity);
1620
1621 void add(const UChar32* other, int32_t otherLen, int8_t polarity);
1622
1623 void retain(const UChar32* other, int32_t otherLen, int8_t polarity);
1624
1630 static UBool resemblesPropertyPattern(const UnicodeString& pattern,
1631 int32_t pos);
1632
1633 static UBool resemblesPropertyPattern(RuleCharacterIterator& chars,
1634 int32_t iterOpts);
1635
1675 UnicodeSet& applyPropertyPattern(const UnicodeString& pattern,
1676 ParsePosition& ppos,
1677 UErrorCode &ec);
1678
1679 void applyPropertyPattern(RuleCharacterIterator& chars,
1680 UnicodeString& rebuiltPat,
1681 UErrorCode& ec);
1682
1683 static const UnicodeSet* getInclusions(int32_t src, UErrorCode &status);
1684
1689 typedef UBool (*Filter)(UChar32 codePoint, void* context);
1690
1700 void applyFilter(Filter filter,
1701 void* context,
1702 const UnicodeSet* inclusions,
1703 UErrorCode &status);
1704
1705 // UCPMap is now stable ICU 63
1706 void applyIntPropertyValue(const UCPMap *map,
1707 UCPMapValueFilter *filter, const void *context,
1708 UErrorCode &errorCode);
1709
1713 void setPattern(const UnicodeString& newPat) {
1714 setPattern(newPat.getBuffer(), newPat.length());
1715 }
1716 void setPattern(const char16_t *newPat, int32_t newPatLen);
1720 void releasePattern();
1721
1722 friend class UnicodeSetIterator;
1723};
1724
1725
1726
1727inline bool UnicodeSet::operator!=(const UnicodeSet& o) const {
1728 return !operator==(o);
1729}
1730
1731inline UBool UnicodeSet::isFrozen() const {
1732 return (UBool)(bmpSet!=NULL || stringSpan!=NULL);
1733}
1734
1735inline UBool UnicodeSet::containsSome(UChar32 start, UChar32 end) const {
1736 return !containsNone(start, end);
1737}
1738
1739inline UBool UnicodeSet::containsSome(const UnicodeSet& s) const {
1740 return !containsNone(s);
1741}
1742
1743inline UBool UnicodeSet::containsSome(const UnicodeString& s) const {
1744 return !containsNone(s);
1745}
1746
1747inline UBool UnicodeSet::isBogus() const {
1748 return (UBool)(fFlags & kIsBogus);
1749}
1750
1751inline UnicodeSet *UnicodeSet::fromUSet(USet *uset) {
1752 return reinterpret_cast<UnicodeSet *>(uset);
1753}
1754
1755inline const UnicodeSet *UnicodeSet::fromUSet(const USet *uset) {
1756 return reinterpret_cast<const UnicodeSet *>(uset);
1757}
1758
1759inline USet *UnicodeSet::toUSet() {
1760 return reinterpret_cast<USet *>(this);
1761}
1762
1763inline const USet *UnicodeSet::toUSet() const {
1764 return reinterpret_cast<const USet *>(this);
1765}
1766
1767inline int32_t UnicodeSet::span(const UnicodeString &s, int32_t start, USetSpanCondition spanCondition) const {
1768 int32_t sLength=s.length();
1769 if(start<0) {
1770 start=0;
1771 } else if(start>sLength) {
1772 start=sLength;
1773 }
1774 return start+span(s.getBuffer()+start, sLength-start, spanCondition);
1775}
1776
1777inline int32_t UnicodeSet::spanBack(const UnicodeString &s, int32_t limit, USetSpanCondition spanCondition) const {
1778 int32_t sLength=s.length();
1779 if(limit<0) {
1780 limit=0;
1781 } else if(limit>sLength) {
1782 limit=sLength;
1783 }
1784 return spanBack(s.getBuffer(), limit, spanCondition);
1785}
1786
1787U_NAMESPACE_END
1788
1789#endif /* U_SHOW_CPLUSPLUS_API */
1790
1791#endif
#define INITIAL_CAPACITY
The initial size of an array if it is unspecified.
Definition: RunArrays.h:32
ParsePosition is a simple class used by Format and its subclasses to keep track of the current positi...
Definition: parsepos.h:52
Replaceable is an abstract base class representing a string of characters that supports the replaceme...
Definition: rep.h:77
An interface that defines both lookup protocol and parsing of symbolic names.
Definition: symtable.h:59
UnicodeFilter defines a protocol for selecting a subset of the full range (U+0000 to U+10FFFF) of Uni...
Definition: unifilt.h:65
virtual UBool matchesIndexValue(uint8_t v) const =0
Returns true if this matcher will match a character c, where c & 0xFF == v, at offset,...
UnicodeSetIterator iterates over the contents of a UnicodeSet.
Definition: usetiter.h:67
A mutable set of Unicode characters and multicharacter strings.
Definition: uniset.h:285
UnicodeSet & operator=(const UnicodeSet &o)
Assigns this object to be a copy of another.
UnicodeSet & addAll(const UnicodeString &s)
Adds each of the characters in this string to the set.
virtual UChar32 getRangeEnd(int32_t index) const
Iteration method that returns the last character in the specified range of this set.
UnicodeSet()
Constructs an empty set.
int32_t spanBackUTF8(const char *s, int32_t length, USetSpanCondition spanCondition) const
Returns the start of the trailing substring of the input string which consists only of characters and...
UnicodeSet(UChar32 start, UChar32 end)
Constructs a set containing the given range.
static UnicodeSet * createFromAll(const UnicodeString &s)
Makes a set from each of the characters in the string.
int32_t spanUTF8(const char *s, int32_t length, USetSpanCondition spanCondition) const
Returns the length of the initial substring of the input string which consists only of characters and...
UnicodeSet & complementAll(const UnicodeString &s)
Complement EACH of the characters in this string.
void setToBogus()
Make this UnicodeSet object invalid.
virtual UnicodeSet * clone() const override
Returns a copy of this object.
UnicodeSet & applyPropertyAlias(const UnicodeString &prop, const UnicodeString &value, UErrorCode &ec)
Modifies this set to contain those code points which have the given value for the given property.
virtual UnicodeSet & removeAll(const UnicodeSet &c)
Removes from this set all of its elements that are contained in the specified set.
virtual UnicodeSet & remove(UChar32 start, UChar32 end)
Removes the specified range from this set if it is present.
UnicodeSet & applyPattern(const UnicodeString &pattern, UErrorCode &status)
Modifies this set to represent the set specified by the given pattern, ignoring Unicode Pattern_White...
virtual void addMatchSetTo(UnicodeSet &toUnionTo) const override
Implementation of UnicodeMatcher API.
virtual UChar32 getRangeStart(int32_t index) const
Iteration method that returns the first character in the specified range of this set.
UnicodeSet & add(const UnicodeString &s)
Adds the specified multicharacter to this set if it is not already present.
UnicodeSet & applyPattern(const UnicodeString &pattern, uint32_t options, const SymbolTable *symbols, UErrorCode &status)
Modifies this set to represent the set specified by the given pattern, optionally ignoring Unicode Pa...
virtual UnicodeSet & clear(void)
Removes all of the elements from this set.
UnicodeSet * cloneAsThawed() const
Clone the set and make the clone mutable.
int32_t indexOf(UChar32 c) const
Returns the index of the given character within this set, where the set is ordered by ascending code ...
UnicodeSet & closeOver(int32_t attribute)
Close this set over the given attribute.
virtual UClassID getDynamicClassID(void) const override
Implement UnicodeFunctor API.
UnicodeSet(const UnicodeString &pattern, ParsePosition &pos, uint32_t options, const SymbolTable *symbols, UErrorCode &status)
Constructs a set from the given pattern.
virtual int32_t hashCode(void) const
Returns the hash code value for this set.
virtual UnicodeSet & complementAll(const UnicodeSet &c)
Complements in this set all elements contained in the specified set.
UnicodeSet & complement(const UnicodeString &s)
Complement the specified string in this set.
virtual UBool containsAll(const UnicodeSet &c) const
Returns true if this set contains all the characters and strings of the given set.
UBool containsNone(const UnicodeString &s) const
Returns true if this set contains none of the characters of the given string.
UnicodeSet(const UnicodeSet &o)
Constructs a set that is identical to the given UnicodeSet.
static UBool resemblesPattern(const UnicodeString &pattern, int32_t pos)
Return true if the given position, in the given pattern, appears to be the start of a UnicodeSet patt...
virtual ~UnicodeSet()
Destructs the set.
UnicodeSet & retain(UChar32 c)
Retain the specified character from this set if it is present.
virtual UnicodeSet & compact()
Reallocate this objects internal structures to take up the least possible space, without changing thi...
int32_t span(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const
Returns the length of the initial substring of the input string which consists only of characters and...
UnicodeSet & retainAll(const UnicodeString &s)
Retains EACH of the characters in this string.
virtual UnicodeSet & removeAllStrings()
Remove all strings from this set.
UChar32 charAt(int32_t index) const
Returns the character at the given index within this set, where the set is ordered by ascending code ...
virtual int32_t getRangeCount(void) const
Iteration method that returns the number of ranges contained in this set.
UBool containsNone(UChar32 start, UChar32 end) const
Returns true if this set contains none of the characters of the given range.
virtual UBool contains(UChar32 start, UChar32 end) const
Returns true if this set contains every character of the given range.
UBool containsAll(const UnicodeString &s) const
Returns true if this set contains all the characters of the given string.
UnicodeSet & removeAll(const UnicodeString &s)
Remove EACH of the characters in this string.
virtual int32_t size(void) const
Returns the number of elements in this set (its cardinality).
int32_t serialize(uint16_t *dest, int32_t destCapacity, UErrorCode &ec) const
Serializes this set into an array of 16-bit integers.
UnicodeSet & set(UChar32 start, UChar32 end)
Make this object represent the range start - end.
UBool contains(const UnicodeString &s) const
Returns true if this set contains the given multicharacter string.
virtual UnicodeSet & complement(UChar32 start, UChar32 end)
Complements the specified range in this set.
static UnicodeSet * createFrom(const UnicodeString &s)
Makes a set from a multicharacter string.
static UClassID getStaticClassID(void)
Return the class ID for this class.
virtual UBool isEmpty(void) const
Returns true if this set contains no elements.
virtual bool operator==(const UnicodeSet &o) const
Compares the specified object with this set for equality.
UnicodeSet(const UnicodeString &pattern, UErrorCode &status)
Constructs a set from the given pattern.
UBool hasStrings() const
UnicodeSet & remove(UChar32 c)
Removes the specified character from this set if it is present.
virtual UnicodeString & toPattern(UnicodeString &result, UBool escapeUnprintable=false) const override
Returns a string representation of this set.
virtual UnicodeSet & complement()
This is equivalent to complement(MIN_VALUE, MAX_VALUE).
UnicodeSet & add(UChar32 c)
Adds the specified character to this set if it is not already present.
UnicodeSet & applyIntPropertyValue(UProperty prop, int32_t value, UErrorCode &ec)
Modifies this set to contain those code points which have the given value for the given binary or enu...
int32_t spanBack(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const
Returns the start of the trailing substring of the input string which consists only of characters and...
UnicodeSet & remove(const UnicodeString &s)
Removes the specified string from this set if it is present.
virtual UMatchDegree matches(const Replaceable &text, int32_t &offset, int32_t limit, UBool incremental) override
Implement UnicodeMatcher::matches()
virtual UnicodeSet & add(UChar32 start, UChar32 end)
Adds the specified range to this set if it is not already present.
UnicodeSet * freeze()
Freeze the set (make it immutable).
UnicodeSet & applyPattern(const UnicodeString &pattern, ParsePosition &pos, uint32_t options, const SymbolTable *symbols, UErrorCode &status)
Parses the given pattern, starting at the given position.
virtual UBool contains(UChar32 c) const override
Returns true if this set contains the given character.
UnicodeSet & retain(const UnicodeString &s)
Retains only the specified string from this set if it is present.
UnicodeSet(const uint16_t buffer[], int32_t bufferLen, ESerialization serialization, UErrorCode &status)
Constructs a set from the output of serialize().
virtual UnicodeSet & retain(UChar32 start, UChar32 end)
Retain only the elements in this set that are contained in the specified range.
virtual UnicodeSet & addAll(const UnicodeSet &c)
Adds all of the elements in the specified set to this set if they're not already present.
UnicodeSet(const UnicodeString &pattern, uint32_t options, const SymbolTable *symbols, UErrorCode &status)
Constructs a set from the given pattern.
virtual UnicodeSet & retainAll(const UnicodeSet &c)
Retains only the elements in this set that are contained in the specified set.
UnicodeSet & complement(UChar32 c)
Complements the specified character in this set.
UBool containsNone(const UnicodeSet &c) const
Returns true if this set contains none of the characters and strings of the given set.
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:296
int32_t length(void) const
Return the length of the UnicodeString object.
Definition: unistr.h:3890
char16_t * getBuffer(int32_t minCapacity)
Get a read/write pointer to the internal buffer.
U_EXPORT UBool operator==(const StringPiece &x, const StringPiece &y)
Global operator == for StringPiece.
UMatchDegree
Constants returned by UnicodeMatcher::matches() indicating the degree of match.
Definition: unimatch.h:33
bool operator!=(const StringPiece &x, const StringPiece &y)
Global operator != for StringPiece.
Definition: stringpiece.h:335
UProperty
Selection constants for Unicode properties.
Definition: uchar.h:195
This file defines an abstract map from Unicode code points to integer values.
uint32_t UCPMapValueFilter(const void *context, uint32_t value)
Callback function type: Modifies a map value.
Definition: ucpmap.h:114
struct UCPMap UCPMap
Abstract map from Unicode code points (U+0000..U+10FFFF) to integer values.
Definition: ucpmap.h:31
int32_t UChar32
Define UChar32 as a type for single Unicode code points.
Definition: umachine.h:467
int8_t UBool
The ICU boolean type, a signed-byte integer.
Definition: umachine.h:269
#define U_FINAL
Defined to the C++11 "final" keyword if available.
Definition: umachine.h:141
C++ API: Unicode Filter.
C++ API: Unicode String.
void * UClassID
UClassID is used to identify classes without using the compiler's RTTI.
Definition: uobject.h:96
C API: Unicode Set.
USetSpanCondition
Argument values for whether span() and similar functions continue while the current character is cont...
Definition: uset.h:159
struct USet USet
USet is the C API type corresponding to C++ class UnicodeSet.
Definition: uset.h:50
Basic definitions for ICU, for both C and C++ APIs.
#define NULL
Define NULL if necessary, to nullptr for C++ and to ((void *)0) for C.
Definition: utypes.h:188
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
Definition: utypes.h:415
#define U_COMMON_API
Set to export library symbols from inside the common library, and to import them from outside.
Definition: utypes.h:300