Movatterモバイル変換

[0]ホーム
URL:

ICU 77.1  77.1
uset.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 *
6 * Copyright (C) 2002-2014, International Business Machines
7 * Corporation and others. All Rights Reserved.
8 *
9 *******************************************************************************
10 * file name: uset.h
11 * encoding: UTF-8
12 * tab size: 8 (not used)
13 * indentation:4
14 *
15 * created on: 2002mar07
16 * created by: Markus W. Scherer
17 *
18 * C version of UnicodeSet.
19 */
20 
21 
29 #ifndef __USET_H__
30 #define __USET_H__
31 
32 #include "unicode/utypes.h"
33 #include "unicode/uchar.h"
34 
35 #if U_SHOW_CPLUSPLUS_API || U_SHOW_CPLUSPLUS_HEADER_API
36 #include <string>
37 #include <string_view>
38 #include "unicode/char16ptr.h"
39 #include "unicode/localpointer.h"
40 #include "unicode/utf16.h"
41 #endif
42 
43 #ifndef USET_DEFINED
44 
45 #ifndef U_IN_DOXYGEN
46 #define USET_DEFINED
47 #endif
54 typedefstructUSetUSet;
55 #endif
56 
68 enum {
73 USET_IGNORE_SPACE = 1,
74 
101 USET_CASE_INSENSITIVE = 2,
102 
114 USET_ADD_CASE_MAPPINGS = 4,
115 
128 USET_SIMPLE_CASE_INSENSITIVE = 6
129 };
130 
186 typedefenumUSetSpanCondition {
199 USET_SPAN_NOT_CONTAINED = 0,
214 USET_SPAN_CONTAINED = 1,
234 USET_SPAN_SIMPLE = 2,
235 #ifndef U_HIDE_DEPRECATED_API
240 USET_SPAN_CONDITION_COUNT
241 #endif// U_HIDE_DEPRECATED_API
242 }USetSpanCondition;
243 
244 enum {
251 USET_SERIALIZED_STATIC_ARRAY_CAPACITY=8
252 };
253 
259 typedefstructUSerializedSet {
264 const uint16_t *array;
269  int32_tbmpLength;
274  int32_tlength;
279  uint16_tstaticArray[USET_SERIALIZED_STATIC_ARRAY_CAPACITY];
280 }USerializedSet;
281 
282 /*********************************************************************
283  * USet API
284  *********************************************************************/
285 
293 U_CAPIUSet* U_EXPORT2
294 uset_openEmpty(void);
295 
306 U_CAPIUSet* U_EXPORT2
307 uset_open(UChar32 start,UChar32 end);
308 
318 U_CAPIUSet* U_EXPORT2
319 uset_openPattern(constUChar* pattern, int32_t patternLength,
320 UErrorCode* ec);
321 
335 U_CAPIUSet* U_EXPORT2
336 uset_openPatternOptions(constUChar* pattern, int32_t patternLength,
337  uint32_t options,
338 UErrorCode* ec);
339 
346 U_CAPIvoid U_EXPORT2
347 uset_close(USet* set);
348 
349 #if U_SHOW_CPLUSPLUS_API
350 
351 U_NAMESPACE_BEGIN
352 
362 U_DEFINE_LOCAL_OPEN_POINTER(LocalUSetPointer,USet,uset_close);
363 
364 U_NAMESPACE_END
365 
366 #endif
367 
377 U_CAPIUSet * U_EXPORT2
378 uset_clone(constUSet *set);
379 
389 U_CAPIUBool U_EXPORT2
390 uset_isFrozen(constUSet *set);
391 
406 U_CAPIvoid U_EXPORT2
407 uset_freeze(USet *set);
408 
419 U_CAPIUSet * U_EXPORT2
420 uset_cloneAsThawed(constUSet *set);
421 
431 U_CAPIvoid U_EXPORT2
432 uset_set(USet* set,
433 UChar32 start,UChar32 end);
434 
459 U_CAPI int32_t U_EXPORT2
460 uset_applyPattern(USet *set,
461 constUChar *pattern, int32_t patternLength,
462  uint32_t options,
463 UErrorCode *status);
464 
487 U_CAPIvoid U_EXPORT2
488 uset_applyIntPropertyValue(USet* set,
489 UProperty prop, int32_t value,UErrorCode* ec);
490 
526 U_CAPIvoid U_EXPORT2
527 uset_applyPropertyAlias(USet* set,
528 constUChar *prop, int32_t propLength,
529 constUChar *value, int32_t valueLength,
530 UErrorCode* ec);
531 
541 U_CAPIUBool U_EXPORT2
542 uset_resemblesPattern(constUChar *pattern, int32_t patternLength,
543  int32_t pos);
544 
560 U_CAPI int32_t U_EXPORT2
561 uset_toPattern(constUSet* set,
562 UChar* result, int32_t resultCapacity,
563 UBool escapeUnprintable,
564 UErrorCode* ec);
565 
574 U_CAPIvoid U_EXPORT2
575 uset_add(USet* set,UChar32 c);
576 
589 U_CAPIvoid U_EXPORT2
590 uset_addAll(USet* set,constUSet *additionalSet);
591 
601 U_CAPIvoid U_EXPORT2
602 uset_addRange(USet* set,UChar32 start,UChar32 end);
603 
613 U_CAPIvoid U_EXPORT2
614 uset_addString(USet* set,constUChar* str, int32_t strLen);
615 
625 U_CAPIvoid U_EXPORT2
626 uset_addAllCodePoints(USet* set,constUChar *str, int32_t strLen);
627 
636 U_CAPIvoid U_EXPORT2
637 uset_remove(USet* set,UChar32 c);
638 
648 U_CAPIvoid U_EXPORT2
649 uset_removeRange(USet* set,UChar32 start,UChar32 end);
650 
660 U_CAPIvoid U_EXPORT2
661 uset_removeString(USet* set,constUChar* str, int32_t strLen);
662 
672 U_CAPIvoid U_EXPORT2
673 uset_removeAllCodePoints(USet *set,constUChar *str, int32_t length);
674 
686 U_CAPIvoid U_EXPORT2
687 uset_removeAll(USet* set,constUSet* removeSet);
688 
701 U_CAPIvoid U_EXPORT2
702 uset_retain(USet* set,UChar32 start,UChar32 end);
703 
715 U_CAPIvoid U_EXPORT2
716 uset_retainString(USet *set,constUChar *str, int32_t length);
717 
727 U_CAPIvoid U_EXPORT2
728 uset_retainAllCodePoints(USet *set,constUChar *str, int32_t length);
729 
742 U_CAPIvoid U_EXPORT2
743 uset_retainAll(USet* set,constUSet* retain);
744 
753 U_CAPIvoid U_EXPORT2
754 uset_compact(USet* set);
755 
769 U_CAPIvoid U_EXPORT2
770 uset_complement(USet* set);
771 
785 U_CAPIvoid U_EXPORT2
786 uset_complementRange(USet *set,UChar32 start,UChar32 end);
787 
798 U_CAPIvoid U_EXPORT2
799 uset_complementString(USet *set,constUChar *str, int32_t length);
800 
810 U_CAPIvoid U_EXPORT2
811 uset_complementAllCodePoints(USet *set,constUChar *str, int32_t length);
812 
824 U_CAPIvoid U_EXPORT2
825 uset_complementAll(USet* set,constUSet* complement);
826 
834 U_CAPIvoid U_EXPORT2
835 uset_clear(USet* set);
836 
865 U_CAPIvoid U_EXPORT2
866 uset_closeOver(USet* set, int32_t attributes);
867 
874 U_CAPIvoid U_EXPORT2
875 uset_removeAllStrings(USet* set);
876 
884 U_CAPIUBool U_EXPORT2
885 uset_isEmpty(constUSet* set);
886 
892 U_CAPIUBool U_EXPORT2
893 uset_hasStrings(constUSet *set);
894 
903 U_CAPIUBool U_EXPORT2
904 uset_contains(constUSet* set,UChar32 c);
905 
915 U_CAPIUBool U_EXPORT2
916 uset_containsRange(constUSet* set,UChar32 start,UChar32 end);
917 
926 U_CAPIUBool U_EXPORT2
927 uset_containsString(constUSet* set,constUChar* str, int32_t strLen);
928 
939 U_CAPI int32_t U_EXPORT2
940 uset_indexOf(constUSet* set,UChar32 c);
941 
957 U_CAPIUChar32 U_EXPORT2
958 uset_charAt(constUSet* set, int32_t charIndex);
959 
975 U_CAPI int32_t U_EXPORT2
976 uset_size(constUSet* set);
977 
987 U_CAPI int32_t U_EXPORT2
988 uset_getRangeCount(constUSet *set);
989 
990 #ifndef U_HIDE_DRAFT_API
991 
1000 U_CAPI int32_t U_EXPORT2
1001 uset_getStringCount(constUSet *set);
1002 
1015 U_CAPIconstUChar* U_EXPORT2
1016 uset_getString(constUSet *set, int32_t index, int32_t *pLength);
1017 
1018 #endif// U_HIDE_DRAFT_API
1019 
1030 U_CAPI int32_t U_EXPORT2
1031 uset_getItemCount(constUSet* set);
1032 
1063 U_CAPI int32_t U_EXPORT2
1064 uset_getItem(constUSet* set, int32_t itemIndex,
1065 UChar32* start,UChar32* end,
1066 UChar* str, int32_t strCapacity,
1067 UErrorCode* ec);
1068 
1077 U_CAPIUBool U_EXPORT2
1078 uset_containsAll(constUSet* set1,constUSet* set2);
1079 
1090 U_CAPIUBool U_EXPORT2
1091 uset_containsAllCodePoints(constUSet* set,constUChar *str, int32_t strLen);
1092 
1101 U_CAPIUBool U_EXPORT2
1102 uset_containsNone(constUSet* set1,constUSet* set2);
1103 
1112 U_CAPIUBool U_EXPORT2
1113 uset_containsSome(constUSet* set1,constUSet* set2);
1114 
1134 U_CAPI int32_t U_EXPORT2
1135 uset_span(constUSet *set,constUChar *s, int32_t length,USetSpanCondition spanCondition);
1136 
1155 U_CAPI int32_t U_EXPORT2
1156 uset_spanBack(constUSet *set,constUChar *s, int32_t length,USetSpanCondition spanCondition);
1157 
1177 U_CAPI int32_t U_EXPORT2
1178 uset_spanUTF8(constUSet *set,constchar *s, int32_t length,USetSpanCondition spanCondition);
1179 
1198 U_CAPI int32_t U_EXPORT2
1199 uset_spanBackUTF8(constUSet *set,constchar *s, int32_t length,USetSpanCondition spanCondition);
1200 
1209 U_CAPIUBool U_EXPORT2
1210 uset_equals(constUSet* set1,constUSet* set2);
1211 
1212 /*********************************************************************
1213  * Serialized set API
1214  *********************************************************************/
1215 
1265 U_CAPI int32_t U_EXPORT2
1266 uset_serialize(constUSet* set, uint16_t* dest, int32_t destCapacity,UErrorCode* pErrorCode);
1267 
1276 U_CAPIUBool U_EXPORT2
1277 uset_getSerializedSet(USerializedSet* fillSet,const uint16_t* src, int32_t srcLength);
1278 
1286 U_CAPIvoid U_EXPORT2
1287 uset_setSerializedToOne(USerializedSet* fillSet,UChar32 c);
1288 
1297 U_CAPIUBool U_EXPORT2
1298 uset_serializedContains(constUSerializedSet* set,UChar32 c);
1299 
1309 U_CAPI int32_t U_EXPORT2
1310 uset_getSerializedRangeCount(constUSerializedSet* set);
1311 
1325 U_CAPIUBool U_EXPORT2
1326 uset_getSerializedRange(constUSerializedSet* set, int32_t rangeIndex,
1327 UChar32* pStart,UChar32* pEnd);
1328 
1329 #if U_SHOW_CPLUSPLUS_API || U_SHOW_CPLUSPLUS_HEADER_API
1330 #ifndef U_HIDE_DRAFT_API
1331 
1332 namespaceU_HEADER_ONLY_NAMESPACE {
1333 
1334 // Note: Not U_COMMON_API, and not a subclass of UMemory, because this is a header-only class,
1335 // not intended to be used via export from the ICU DLL.
1336 
1341 classUSetCodePointIterator {
1342 public:
1344 USetCodePointIterator(constUSetCodePointIterator &other) =default;
1345 
1347 booloperator==(constUSetCodePointIterator &other) const{
1348 // No need to compare rangeCount & end given private constructor
1349 // and assuming we don't compare iterators across the set being modified.
1350 // And comparing rangeIndex is redundant with comparing c.
1351 // We might even skip comparing uset.
1352 // Unless we want operator==() to be "correct" for more than iteration.
1353 return uset == other.uset && c == other.c;
1354  }
1355 
1357 booloperator!=(constUSetCodePointIterator &other) const{return !operator==(other); }
1358 
1360 UChar32operator*() const{return c; }
1361 
1366 USetCodePointIterator &operator++() {
1367 if (c < end) {
1368  ++c;
1369  }elseif (rangeIndex < rangeCount) {
1370 UErrorCode errorCode =U_ZERO_ERROR;
1371  int32_t result =uset_getItem(uset, rangeIndex, &c, &end,nullptr, 0, &errorCode);
1372 if (U_SUCCESS(errorCode) && result == 0) {
1373  ++rangeIndex;
1374  }else {
1375  c = end =U_SENTINEL;
1376  }
1377  }else {
1378  c = end =U_SENTINEL;
1379  }
1380 return *this;
1381  }
1382 
1387 USetCodePointIteratoroperator++(int) {
1388 USetCodePointIterator result(*this);
1389 operator++();
1390 return result;
1391  }
1392 
1393 private:
1394 friendclassUSetCodePoints;
1395 
1396 USetCodePointIterator(constUSet *pUset, int32_t nRangeIndex, int32_t nRangeCount)
1397  : uset(pUset), rangeIndex(nRangeIndex), rangeCount(nRangeCount),
1398  c(U_SENTINEL), end(U_SENTINEL) {
1399 // Fetch the first range.
1400 operator++();
1401  }
1402 
1403 constUSet *uset;
1404  int32_t rangeIndex;
1405  int32_t rangeCount;
1406 UChar32 c, end;
1407 };
1408 
1427 classUSetCodePoints {
1428 public:
1433 USetCodePoints(constUSet *pUset) : uset(pUset), rangeCount(uset_getRangeCount(pUset)) {}
1434 
1436 USetCodePoints(constUSetCodePoints &other) =default;
1437 
1439 USetCodePointIteratorbegin() const{
1440 returnUSetCodePointIterator(uset, 0, rangeCount);
1441  }
1442 
1444 USetCodePointIteratorend() const{
1445 returnUSetCodePointIterator(uset, rangeCount, rangeCount);
1446  }
1447 
1448 private:
1449 constUSet *uset;
1450  int32_t rangeCount;
1451 };
1452 
1460 structCodePointRange {
1462 structiterator {
1464 iterator(UChar32 aC) :c(aC) {}
1465 
1467 booloperator==(constiterator &other) const{returnc == other.c; }
1469 booloperator!=(constiterator &other) const{return !operator==(other); }
1470 
1472 UChar32operator*() const{returnc; }
1473 
1478 iterator &operator++() {
1479  ++c;
1480 return *this;
1481  }
1482 
1487 iteratoroperator++(int) {
1488 returnc++;
1489  }
1490 
1495 UChar32c;
1496  };
1497 
1499 CodePointRange(UChar32 start,UChar32end) :rangeStart(start),rangeEnd(end) {}
1501 CodePointRange(constCodePointRange &other) =default;
1503 size_tsize() const{return (rangeEnd + 1) -rangeStart; }
1505 iteratorbegin() const{returnrangeStart; }
1507 iteratorend() const{returnrangeEnd + 1; }
1508 
1513 UChar32rangeStart;
1518 UChar32rangeEnd;
1519 };
1520 
1525 classUSetRangeIterator {
1526 public:
1528 USetRangeIterator(constUSetRangeIterator &other) =default;
1529 
1531 booloperator==(constUSetRangeIterator &other) const{
1532 // No need to compare rangeCount given private constructor
1533 // and assuming we don't compare iterators across the set being modified.
1534 // We might even skip comparing uset.
1535 // Unless we want operator==() to be "correct" for more than iteration.
1536 return uset == other.uset && rangeIndex == other.rangeIndex;
1537  }
1538 
1540 booloperator!=(constUSetRangeIterator &other) const{return !operator==(other); }
1541 
1543 CodePointRangeoperator*() const{
1544 if (rangeIndex < rangeCount) {
1545 UChar32 start, end;
1546 UErrorCode errorCode =U_ZERO_ERROR;
1547  int32_t result =uset_getItem(uset, rangeIndex, &start, &end,nullptr, 0, &errorCode);
1548 if (U_SUCCESS(errorCode) && result == 0) {
1549 returnCodePointRange(start, end);
1550  }
1551  }
1552 returnCodePointRange(U_SENTINEL,U_SENTINEL);
1553  }
1554 
1559 USetRangeIterator &operator++() {
1560  ++rangeIndex;
1561 return *this;
1562  }
1563 
1568 USetRangeIteratoroperator++(int) {
1569 USetRangeIterator result(*this);
1570  ++rangeIndex;
1571 return result;
1572  }
1573 
1574 private:
1575 friendclassUSetRanges;
1576 
1577 USetRangeIterator(constUSet *pUset, int32_t nRangeIndex, int32_t nRangeCount)
1578  : uset(pUset), rangeIndex(nRangeIndex), rangeCount(nRangeCount) {}
1579 
1580 constUSet *uset;
1581  int32_t rangeIndex;
1582  int32_t rangeCount;
1583 };
1584 
1608 classUSetRanges {
1609 public:
1614 USetRanges(constUSet *pUset) : uset(pUset), rangeCount(uset_getRangeCount(pUset)) {}
1615 
1617 USetRanges(constUSetRanges &other) =default;
1618 
1620 USetRangeIteratorbegin() const{
1621 returnUSetRangeIterator(uset, 0, rangeCount);
1622  }
1623 
1625 USetRangeIteratorend() const{
1626 returnUSetRangeIterator(uset, rangeCount, rangeCount);
1627  }
1628 
1629 private:
1630 constUSet *uset;
1631  int32_t rangeCount;
1632 };
1633 
1638 classUSetStringIterator {
1639 public:
1641 USetStringIterator(constUSetStringIterator &other) =default;
1642 
1644 booloperator==(constUSetStringIterator &other) const{
1645 // No need to compare count given private constructor
1646 // and assuming we don't compare iterators across the set being modified.
1647 // We might even skip comparing uset.
1648 // Unless we want operator==() to be "correct" for more than iteration.
1649 return uset == other.uset && index == other.index;
1650  }
1651 
1653 booloperator!=(constUSetStringIterator &other) const{return !operator==(other); }
1654 
1656  std::u16string_viewoperator*() const{
1657 if (index < count) {
1658  int32_t length;
1659 constUChar *uchars =uset_getString(uset, index, &length);
1660 // assert uchars != nullptr;
1661 return {uprv_char16PtrFromUChar(uchars),static_cast<size_t>(length)};
1662  }
1663 return {};
1664  }
1665 
1670 USetStringIterator &operator++() {
1671  ++index;
1672 return *this;
1673  }
1674 
1679 USetStringIteratoroperator++(int) {
1680 USetStringIterator result(*this);
1681  ++index;
1682 return result;
1683  }
1684 
1685 private:
1686 friendclassUSetStrings;
1687 
1688 USetStringIterator(constUSet *pUset, int32_t nIndex, int32_t nCount)
1689  : uset(pUset), index(nIndex), count(nCount) {}
1690 
1691 constUSet *uset;
1692  int32_t index;
1693  int32_t count;
1694 };
1695 
1718 classUSetStrings {
1719 public:
1724 USetStrings(constUSet *pUset) : uset(pUset), count(uset_getStringCount(pUset)) {}
1725 
1727 USetStrings(constUSetStrings &other) =default;
1728 
1730 USetStringIteratorbegin() const{
1731 returnUSetStringIterator(uset, 0, count);
1732  }
1733 
1735 USetStringIteratorend() const{
1736 returnUSetStringIterator(uset, count, count);
1737  }
1738 
1739 private:
1740 constUSet *uset;
1741  int32_t count;
1742 };
1743 #endif// U_HIDE_DRAFT_API
1744 
1745 #ifndef U_HIDE_DRAFT_API
1750 classUSetElementIterator {
1751 public:
1753 USetElementIterator(constUSetElementIterator &other) =default;
1754 
1756 booloperator==(constUSetElementIterator &other) const{
1757 // No need to compare rangeCount & end given private constructor
1758 // and assuming we don't compare iterators across the set being modified.
1759 // We might even skip comparing uset.
1760 // Unless we want operator==() to be "correct" for more than iteration.
1761 return uset == other.uset && c == other.c && index == other.index;
1762  }
1763 
1765 booloperator!=(constUSetElementIterator &other) const{return !operator==(other); }
1766 
1768  std::u16stringoperator*() const{
1769 if (c >= 0) {
1770 return c <= 0xffff ?
1771  std::u16string({static_cast<char16_t>(c)}) :
1772  std::u16string({U16_LEAD(c),U16_TRAIL(c)});
1773  }elseif (index < totalCount) {
1774  int32_t length;
1775 constUChar *uchars =uset_getString(uset, index - rangeCount, &length);
1776 // assert uchars != nullptr;
1777 return {uprv_char16PtrFromUChar(uchars),static_cast<size_t>(length)};
1778  }else {
1779 return {};
1780  }
1781  }
1782 
1787 USetElementIterator &operator++() {
1788 if (c < end) {
1789  ++c;
1790  }elseif (index < rangeCount) {
1791 UErrorCode errorCode =U_ZERO_ERROR;
1792  int32_t result =uset_getItem(uset, index, &c, &end,nullptr, 0, &errorCode);
1793 if (U_SUCCESS(errorCode) && result == 0) {
1794  ++index;
1795  }else {
1796  c = end =U_SENTINEL;
1797  }
1798  }elseif (c >= 0) {
1799 // assert index == rangeCount;
1800 // Switch from the last range to the first string.
1801  c = end =U_SENTINEL;
1802  }else {
1803  ++index;
1804  }
1805 return *this;
1806  }
1807 
1812 USetElementIteratoroperator++(int) {
1813 USetElementIterator result(*this);
1814 operator++();
1815 return result;
1816  }
1817 
1818 private:
1819 friendclassUSetElements;
1820 
1821 USetElementIterator(constUSet *pUset, int32_t nIndex, int32_t nRangeCount, int32_t nTotalCount)
1822  : uset(pUset), index(nIndex), rangeCount(nRangeCount), totalCount(nTotalCount),
1823  c(U_SENTINEL), end(U_SENTINEL) {
1824 if (index < rangeCount) {
1825 // Fetch the first range.
1826 operator++();
1827  }
1828 // Otherwise don't move beyond the (index - rangeCount)-th string.
1829  }
1830 
1831 constUSet *uset;
1832  int32_t index;
1834  int32_t rangeCount;
1844  int32_t totalCount;
1845 UChar32 c, end;
1846 };
1847 
1875 classUSetElements {
1876 public:
1881 USetElements(constUSet *pUset)
1882  : uset(pUset), rangeCount(uset_getRangeCount(pUset)),
1883  stringCount(uset_getStringCount(pUset)) {}
1884 
1886 USetElements(constUSetElements &other) =default;
1887 
1889 USetElementIteratorbegin() const{
1890 returnUSetElementIterator(uset, 0, rangeCount, rangeCount + stringCount);
1891  }
1892 
1894 USetElementIteratorend() const{
1895 returnUSetElementIterator(uset, rangeCount + stringCount, rangeCount, rangeCount + stringCount);
1896  }
1897 
1898 private:
1899 constUSet *uset;
1900  int32_t rangeCount, stringCount;
1901 };
1902 
1903 }// namespace U_HEADER_ONLY_NAMESPACE
1904 
1905 #endif// U_HIDE_DRAFT_API
1906 #endif// U_SHOW_CPLUSPLUS_API || U_SHOW_CPLUSPLUS_HEADER_API
1907 
1908 #endif// __USET_H__
char16ptr.h
C++ API: char16_t pointer wrappers with implicit conversion from bit-compatible raw pointer types.
LocalUSetPointer
"Smart pointer" class, closes a USet via uset_close().
U_HEADER_ONLY_NAMESPACE::USetCodePointIterator
Iterator returned by USetCodePoints.
Definition:uset.h:1341
U_HEADER_ONLY_NAMESPACE::USetCodePointIterator::operator==
bool operator==(const USetCodePointIterator &other) const
Definition:uset.h:1347
U_HEADER_ONLY_NAMESPACE::USetCodePointIterator::operator*
UChar32 operator*() const
Definition:uset.h:1360
U_HEADER_ONLY_NAMESPACE::USetCodePointIterator::operator!=
bool operator!=(const USetCodePointIterator &other) const
Definition:uset.h:1357
U_HEADER_ONLY_NAMESPACE::USetCodePointIterator::operator++
USetCodePointIterator operator++(int)
Post-increment.
Definition:uset.h:1387
U_HEADER_ONLY_NAMESPACE::USetCodePointIterator::USetCodePointIterator
USetCodePointIterator(const USetCodePointIterator &other)=default
U_HEADER_ONLY_NAMESPACE::USetCodePointIterator::operator++
USetCodePointIterator & operator++()
Pre-increment.
Definition:uset.h:1366
U_HEADER_ONLY_NAMESPACE::USetCodePoints
C++ "range" for iterating over the code points of a USet.
Definition:uset.h:1427
U_HEADER_ONLY_NAMESPACE::USetCodePoints::USetCodePoints
USetCodePoints(const USetCodePoints &other)=default
U_HEADER_ONLY_NAMESPACE::USetCodePoints::end
USetCodePointIterator end() const
Definition:uset.h:1444
U_HEADER_ONLY_NAMESPACE::USetCodePoints::USetCodePoints
USetCodePoints(const USet *pUset)
Constructs a C++ "range" object over the code points of the USet.
Definition:uset.h:1433
U_HEADER_ONLY_NAMESPACE::USetCodePoints::begin
USetCodePointIterator begin() const
Definition:uset.h:1439
U_HEADER_ONLY_NAMESPACE::USetElementIterator
Iterator returned by USetElements.
Definition:uset.h:1750
U_HEADER_ONLY_NAMESPACE::USetElementIterator::operator++
USetElementIterator & operator++()
Pre-increment.
Definition:uset.h:1787
U_HEADER_ONLY_NAMESPACE::USetElementIterator::operator++
USetElementIterator operator++(int)
Post-increment.
Definition:uset.h:1812
U_HEADER_ONLY_NAMESPACE::USetElementIterator::operator==
bool operator==(const USetElementIterator &other) const
Definition:uset.h:1756
U_HEADER_ONLY_NAMESPACE::USetElementIterator::operator!=
bool operator!=(const USetElementIterator &other) const
Definition:uset.h:1765
U_HEADER_ONLY_NAMESPACE::USetElementIterator::USetElementIterator
USetElementIterator(const USetElementIterator &other)=default
U_HEADER_ONLY_NAMESPACE::USetElementIterator::operator*
std::u16string operator*() const
Definition:uset.h:1768
U_HEADER_ONLY_NAMESPACE::USetElements
A C++ "range" for iterating over all of the elements of a USet.
Definition:uset.h:1875
U_HEADER_ONLY_NAMESPACE::USetElements::USetElements
USetElements(const USetElements &other)=default
U_HEADER_ONLY_NAMESPACE::USetElements::end
USetElementIterator end() const
Definition:uset.h:1894
U_HEADER_ONLY_NAMESPACE::USetElements::USetElements
USetElements(const USet *pUset)
Constructs a C++ "range" object over all of the elements of the USet.
Definition:uset.h:1881
U_HEADER_ONLY_NAMESPACE::USetElements::begin
USetElementIterator begin() const
Definition:uset.h:1889
U_HEADER_ONLY_NAMESPACE::USetRangeIterator
Iterator returned by USetRanges.
Definition:uset.h:1525
U_HEADER_ONLY_NAMESPACE::USetRangeIterator::operator++
USetRangeIterator & operator++()
Pre-increment.
Definition:uset.h:1559
U_HEADER_ONLY_NAMESPACE::USetRangeIterator::operator*
CodePointRange operator*() const
Definition:uset.h:1543
U_HEADER_ONLY_NAMESPACE::USetRangeIterator::operator==
bool operator==(const USetRangeIterator &other) const
Definition:uset.h:1531
U_HEADER_ONLY_NAMESPACE::USetRangeIterator::operator++
USetRangeIterator operator++(int)
Post-increment.
Definition:uset.h:1568
U_HEADER_ONLY_NAMESPACE::USetRangeIterator::operator!=
bool operator!=(const USetRangeIterator &other) const
Definition:uset.h:1540
U_HEADER_ONLY_NAMESPACE::USetRangeIterator::USetRangeIterator
USetRangeIterator(const USetRangeIterator &other)=default
U_HEADER_ONLY_NAMESPACE::USetRanges
C++ "range" for iterating over the code point ranges of a USet.
Definition:uset.h:1608
U_HEADER_ONLY_NAMESPACE::USetRanges::end
USetRangeIterator end() const
Definition:uset.h:1625
U_HEADER_ONLY_NAMESPACE::USetRanges::begin
USetRangeIterator begin() const
Definition:uset.h:1620
U_HEADER_ONLY_NAMESPACE::USetRanges::USetRanges
USetRanges(const USet *pUset)
Constructs a C++ "range" object over the code point ranges of the USet.
Definition:uset.h:1614
U_HEADER_ONLY_NAMESPACE::USetRanges::USetRanges
USetRanges(const USetRanges &other)=default
U_HEADER_ONLY_NAMESPACE::USetStringIterator
Iterator returned by USetStrings.
Definition:uset.h:1638
U_HEADER_ONLY_NAMESPACE::USetStringIterator::USetStringIterator
USetStringIterator(const USetStringIterator &other)=default
U_HEADER_ONLY_NAMESPACE::USetStringIterator::operator!=
bool operator!=(const USetStringIterator &other) const
Definition:uset.h:1653
U_HEADER_ONLY_NAMESPACE::USetStringIterator::operator*
std::u16string_view operator*() const
Definition:uset.h:1656
U_HEADER_ONLY_NAMESPACE::USetStringIterator::operator++
USetStringIterator operator++(int)
Post-increment.
Definition:uset.h:1679
U_HEADER_ONLY_NAMESPACE::USetStringIterator::operator++
USetStringIterator & operator++()
Pre-increment.
Definition:uset.h:1670
U_HEADER_ONLY_NAMESPACE::USetStringIterator::operator==
bool operator==(const USetStringIterator &other) const
Definition:uset.h:1644
U_HEADER_ONLY_NAMESPACE::USetStrings
C++ "range" for iterating over the empty and multi-character strings of a USet.
Definition:uset.h:1718
U_HEADER_ONLY_NAMESPACE::USetStrings::USetStrings
USetStrings(const USetStrings &other)=default
U_HEADER_ONLY_NAMESPACE::USetStrings::begin
USetStringIterator begin() const
Definition:uset.h:1730
U_HEADER_ONLY_NAMESPACE::USetStrings::end
USetStringIterator end() const
Definition:uset.h:1735
U_HEADER_ONLY_NAMESPACE::USetStrings::USetStrings
USetStrings(const USet *pUset)
Constructs a C++ "range" object over the strings of the USet.
Definition:uset.h:1724
localpointer.h
C++ API: "Smart pointers" for use with and in ICU4C C++ code.
U_DEFINE_LOCAL_OPEN_POINTER
#define U_DEFINE_LOCAL_OPEN_POINTER(LocalPointerClassName, Type, closeFunction)
"Smart pointer" definition macro, deletes objects via the closeFunction.
Definition:localpointer.h:550
USerializedSet
A serialized form of a Unicode set.
Definition:uset.h:259
USerializedSet::staticArray
uint16_t staticArray[USET_SERIALIZED_STATIC_ARRAY_CAPACITY]
A small buffer for the array to reduce memory allocations.
Definition:uset.h:279
USerializedSet::bmpLength
int32_t bmpLength
The length of the array that contains BMP characters.
Definition:uset.h:269
USerializedSet::array
const uint16_t * array
The serialized Unicode Set.
Definition:uset.h:264
USerializedSet::length
int32_t length
The total length of the array.
Definition:uset.h:274
U_HEADER_ONLY_NAMESPACE::CodePointRange::iterator
Definition:uset.h:1462
U_HEADER_ONLY_NAMESPACE::CodePointRange::iterator::operator!=
bool operator!=(const iterator &other) const
Definition:uset.h:1469
U_HEADER_ONLY_NAMESPACE::CodePointRange::iterator::iterator
iterator(UChar32 aC)
Definition:uset.h:1464
U_HEADER_ONLY_NAMESPACE::CodePointRange::iterator::operator*
UChar32 operator*() const
Definition:uset.h:1472
U_HEADER_ONLY_NAMESPACE::CodePointRange::iterator::c
UChar32 c
The current code point in the range.
Definition:uset.h:1495
U_HEADER_ONLY_NAMESPACE::CodePointRange::iterator::operator++
iterator operator++(int)
Post-increment.
Definition:uset.h:1487
U_HEADER_ONLY_NAMESPACE::CodePointRange::iterator::operator++
iterator & operator++()
Pre-increment.
Definition:uset.h:1478
U_HEADER_ONLY_NAMESPACE::CodePointRange::iterator::operator==
bool operator==(const iterator &other) const
Definition:uset.h:1467
U_HEADER_ONLY_NAMESPACE::CodePointRange
A contiguous range of code points in a USet/UnicodeSet.
Definition:uset.h:1460
U_HEADER_ONLY_NAMESPACE::CodePointRange::begin
iterator begin() const
Definition:uset.h:1505
U_HEADER_ONLY_NAMESPACE::CodePointRange::CodePointRange
CodePointRange(UChar32 start, UChar32 end)
Definition:uset.h:1499
U_HEADER_ONLY_NAMESPACE::CodePointRange::size
size_t size() const
Definition:uset.h:1503
U_HEADER_ONLY_NAMESPACE::CodePointRange::end
iterator end() const
Definition:uset.h:1507
U_HEADER_ONLY_NAMESPACE::CodePointRange::rangeEnd
UChar32 rangeEnd
Inclusive end of a USet/UnicodeSet range of code points.
Definition:uset.h:1518
U_HEADER_ONLY_NAMESPACE::CodePointRange::CodePointRange
CodePointRange(const CodePointRange &other)=default
U_HEADER_ONLY_NAMESPACE::CodePointRange::rangeStart
UChar32 rangeStart
Start of a USet/UnicodeSet range of code points.
Definition:uset.h:1513
uchar.h
C API: Unicode Properties.
UProperty
UProperty
Selection constants for Unicode properties.
Definition:uchar.h:196
UChar32
int32_t UChar32
Define UChar32 as a type for single Unicode code points.
Definition:umachine.h:427
UBool
int8_t UBool
The ICU boolean type, a signed-byte integer.
Definition:umachine.h:247
U_CAPI
#define U_CAPI
This is used to declare a function as a public ICU C API.
Definition:umachine.h:110
UChar
char16_t UChar
The base type for UTF-16 code units and pointers.
Definition:umachine.h:378
U_SENTINEL
#define U_SENTINEL
This value is intended for sentinel values for APIs that (take or) return single code points (UChar32...
Definition:umachine.h:447
uset_containsAll
U_CAPI UBool uset_containsAll(const USet *set1, const USet *set2)
Returns true if set1 contains all the characters and strings of set2.
uset_hasStrings
U_CAPI UBool uset_hasStrings(const USet *set)
uset_getStringCount
U_CAPI int32_t uset_getStringCount(const USet *set)
uset_serializedContains
U_CAPI UBool uset_serializedContains(const USerializedSet *set, UChar32 c)
Returns true if the given USerializedSet contains the given character.
uset_getSerializedSet
U_CAPI UBool uset_getSerializedSet(USerializedSet *fillSet, const uint16_t *src, int32_t srcLength)
Given a serialized array, fill in the given serialized set object.
uset_set
U_CAPI void uset_set(USet *set, UChar32 start, UChar32 end)
Causes the USet object to represent the range start - end.
uset_addString
U_CAPI void uset_addString(USet *set, const UChar *str, int32_t strLen)
Adds the given string to the given USet.
uset_containsString
U_CAPI UBool uset_containsString(const USet *set, const UChar *str, int32_t strLen)
Returns true if the given USet contains the given string.
USET_IGNORE_SPACE
@ USET_IGNORE_SPACE
Ignore white space within patterns unless quoted or escaped.
Definition:uset.h:73
USET_ADD_CASE_MAPPINGS
@ USET_ADD_CASE_MAPPINGS
Adds all case mappings for each element in the set.
Definition:uset.h:114
USET_CASE_INSENSITIVE
@ USET_CASE_INSENSITIVE
Enable case insensitive matching.
Definition:uset.h:101
USET_SIMPLE_CASE_INSENSITIVE
@ USET_SIMPLE_CASE_INSENSITIVE
Enable case insensitive matching.
Definition:uset.h:128
uset_isEmpty
U_CAPI UBool uset_isEmpty(const USet *set)
Returns true if the given USet contains no characters and no strings.
uset_getItemCount
U_CAPI int32_t uset_getItemCount(const USet *set)
Returns the number of items in this set.
uset_getSerializedRangeCount
U_CAPI int32_t uset_getSerializedRangeCount(const USerializedSet *set)
Returns the number of disjoint ranges of characters contained in the given serialized set.
uset_charAt
U_CAPI UChar32 uset_charAt(const USet *set, int32_t charIndex)
Returns the character at the given index within this set, where the set is ordered by ascending code ...
uset_open
U_CAPI USet * uset_open(UChar32 start, UChar32 end)
Creates a USet object that contains the range of characters start..end, inclusive.
uset_retainAll
U_CAPI void uset_retainAll(USet *set, const USet *retain)
Retains only the elements in this set that are contained in the specified set.
uset_setSerializedToOne
U_CAPI void uset_setSerializedToOne(USerializedSet *fillSet, UChar32 c)
Set the USerializedSet to contain the given character (and nothing else).
uset_complementString
U_CAPI void uset_complementString(USet *set, const UChar *str, int32_t length)
Complements the specified string in this set.
uset_applyIntPropertyValue
U_CAPI void uset_applyIntPropertyValue(USet *set, UProperty prop, int32_t value, UErrorCode *ec)
Modifies the set to contain those code points which have the given value for the given binary or enum...
uset_complementRange
U_CAPI void uset_complementRange(USet *set, UChar32 start, UChar32 end)
Complements the specified range in this set.
uset_resemblesPattern
U_CAPI UBool uset_resemblesPattern(const UChar *pattern, int32_t patternLength, int32_t pos)
Return true if the given position, in the given pattern, appears to be the start of a UnicodeSet patt...
uset_addRange
U_CAPI void uset_addRange(USet *set, UChar32 start, UChar32 end)
Adds the given range of characters to the given USet.
uset_add
U_CAPI void uset_add(USet *set, UChar32 c)
Adds the given character to the given USet.
uset_complementAllCodePoints
U_CAPI void uset_complementAllCodePoints(USet *set, const UChar *str, int32_t length)
Complements EACH of the characters in this string.
uset_size
U_CAPI int32_t uset_size(const USet *set)
Returns the number of characters and strings contained in this set.
uset_span
U_CAPI int32_t uset_span(const USet *set, const UChar *s, int32_t length, USetSpanCondition spanCondition)
Returns the length of the initial substring of the input string which consists only of characters and...
uset_removeAllStrings
U_CAPI void uset_removeAllStrings(USet *set)
Remove all strings from this set.
uset_clear
U_CAPI void uset_clear(USet *set)
Removes all of the elements from this set.
uset_removeAllCodePoints
U_CAPI void uset_removeAllCodePoints(USet *set, const UChar *str, int32_t length)
Removes EACH of the characters in this string.
USetSpanCondition
USetSpanCondition
Argument values for whether span() and similar functions continue while the current character is cont...
Definition:uset.h:186
USET_SPAN_NOT_CONTAINED
@ USET_SPAN_NOT_CONTAINED
Continues a span() while there is no set element at the current position.
Definition:uset.h:199
USET_SPAN_CONTAINED
@ USET_SPAN_CONTAINED
Spans the longest substring that is a concatenation of set elements (characters or strings).
Definition:uset.h:214
USET_SPAN_CONDITION_COUNT
@ USET_SPAN_CONDITION_COUNT
One more than the last span condition.
Definition:uset.h:240
USET_SPAN_SIMPLE
@ USET_SPAN_SIMPLE
Continues a span() while there is a set element at the current position.
Definition:uset.h:234
uset_remove
U_CAPI void uset_remove(USet *set, UChar32 c)
Removes the given character from the given USet.
uset_removeRange
U_CAPI void uset_removeRange(USet *set, UChar32 start, UChar32 end)
Removes the given range of characters from the given USet.
uset_equals
U_CAPI UBool uset_equals(const USet *set1, const USet *set2)
Returns true if set1 contains all of the characters and strings of set2, and vis versa.
uset_isFrozen
U_CAPI UBool uset_isFrozen(const USet *set)
Determines whether the set has been frozen (made immutable) or not.
uset_getRangeCount
U_CAPI int32_t uset_getRangeCount(const USet *set)
uset_clone
U_CAPI USet * uset_clone(const USet *set)
Returns a copy of this object.
uset_containsAllCodePoints
U_CAPI UBool uset_containsAllCodePoints(const USet *set, const UChar *str, int32_t strLen)
Returns true if this set contains all the characters of the given string.
uset_openPattern
U_CAPI USet * uset_openPattern(const UChar *pattern, int32_t patternLength, UErrorCode *ec)
Creates a set from the given pattern.
uset_serialize
U_CAPI int32_t uset_serialize(const USet *set, uint16_t *dest, int32_t destCapacity, UErrorCode *pErrorCode)
Serializes this set into an array of 16-bit integers.
uset_indexOf
U_CAPI int32_t uset_indexOf(const USet *set, UChar32 c)
Returns the index of the given character within this set, where the set is ordered by ascending code ...
uset_freeze
U_CAPI void uset_freeze(USet *set)
Freeze the set (make it immutable).
uset_spanUTF8
U_CAPI int32_t uset_spanUTF8(const USet *set, const char *s, int32_t length, USetSpanCondition spanCondition)
Returns the length of the initial substring of the input string which consists only of characters and...
uset_getString
U_CAPI const UChar * uset_getString(const USet *set, int32_t index, int32_t *pLength)
Returns the index-th string (empty or multi-character) in the set.
USerializedSet
struct USerializedSet USerializedSet
A serialized form of a Unicode set.
uset_retain
U_CAPI void uset_retain(USet *set, UChar32 start, UChar32 end)
Retain only the elements in this set that are contained in the specified range.
uset_toPattern
U_CAPI int32_t uset_toPattern(const USet *set, UChar *result, int32_t resultCapacity, UBool escapeUnprintable, UErrorCode *ec)
Returns a string representation of this set.
uset_spanBackUTF8
U_CAPI int32_t uset_spanBackUTF8(const USet *set, const char *s, int32_t length, USetSpanCondition spanCondition)
Returns the start of the trailing substring of the input string which consists only of characters and...
uset_complement
U_CAPI void uset_complement(USet *set)
This is equivalent to uset_complementRange(set, 0, 0x10FFFF).
USET_SERIALIZED_STATIC_ARRAY_CAPACITY
@ USET_SERIALIZED_STATIC_ARRAY_CAPACITY
Capacity of USerializedSet::staticArray.
Definition:uset.h:251
uset_containsSome
U_CAPI UBool uset_containsSome(const USet *set1, const USet *set2)
Returns true if set1 contains some of the characters and strings of set2.
uset_spanBack
U_CAPI int32_t uset_spanBack(const USet *set, const UChar *s, int32_t length, USetSpanCondition spanCondition)
Returns the start of the trailing substring of the input string which consists only of characters and...
uset_containsNone
U_CAPI UBool uset_containsNone(const USet *set1, const USet *set2)
Returns true if set1 contains none of the characters and strings of set2.
uset_retainAllCodePoints
U_CAPI void uset_retainAllCodePoints(USet *set, const UChar *str, int32_t length)
Retains EACH of the characters in this string.
uset_contains
U_CAPI UBool uset_contains(const USet *set, UChar32 c)
Returns true if the given USet contains the given character.
uset_applyPattern
U_CAPI int32_t uset_applyPattern(USet *set, const UChar *pattern, int32_t patternLength, uint32_t options, UErrorCode *status)
Modifies the set to represent the set specified by the given pattern.
uset_complementAll
U_CAPI void uset_complementAll(USet *set, const USet *complement)
Complements in this set all elements contained in the specified set.
uset_applyPropertyAlias
U_CAPI void uset_applyPropertyAlias(USet *set, const UChar *prop, int32_t propLength, const UChar *value, int32_t valueLength, UErrorCode *ec)
Modifies the set to contain those code points which have the given value for the given property.
uset_close
U_CAPI void uset_close(USet *set)
Disposes of the storage used by a USet object.
USet
struct USet USet
USet is the C API type corresponding to C++ class UnicodeSet.
Definition:uset.h:54
uset_openPatternOptions
U_CAPI USet * uset_openPatternOptions(const UChar *pattern, int32_t patternLength, uint32_t options, UErrorCode *ec)
Creates a set from the given pattern.
uset_openEmpty
U_CAPI USet * uset_openEmpty(void)
Create an empty USet object.
uset_addAll
U_CAPI void uset_addAll(USet *set, const USet *additionalSet)
Adds all of the elements in the specified set to this set if they're not already present.
uset_removeString
U_CAPI void uset_removeString(USet *set, const UChar *str, int32_t strLen)
Removes the given string to the given USet.
uset_compact
U_CAPI void uset_compact(USet *set)
Reallocate this objects internal structures to take up the least possible space, without changing thi...
uset_getItem
U_CAPI int32_t uset_getItem(const USet *set, int32_t itemIndex, UChar32 *start, UChar32 *end, UChar *str, int32_t strCapacity, UErrorCode *ec)
Returns an item of this set.
uset_closeOver
U_CAPI void uset_closeOver(USet *set, int32_t attributes)
Close this set over the given attribute.
uset_addAllCodePoints
U_CAPI void uset_addAllCodePoints(USet *set, const UChar *str, int32_t strLen)
Adds each of the characters in this string to the set.
uset_cloneAsThawed
U_CAPI USet * uset_cloneAsThawed(const USet *set)
Clone the set and make the clone mutable.
uset_retainString
U_CAPI void uset_retainString(USet *set, const UChar *str, int32_t length)
Retains only the specified string from this set if it is present.
uset_removeAll
U_CAPI void uset_removeAll(USet *set, const USet *removeSet)
Removes from this set all of its elements that are contained in the specified set.
uset_containsRange
U_CAPI UBool uset_containsRange(const USet *set, UChar32 start, UChar32 end)
Returns true if the given USet contains all characters c where start <= c && c <= end.
uset_getSerializedRange
U_CAPI UBool uset_getSerializedRange(const USerializedSet *set, int32_t rangeIndex, UChar32 *pStart, UChar32 *pEnd)
Returns a range of characters contained in the given serialized set.
utf16.h
C API: 16-bit Unicode handling macros.
U16_TRAIL
#define U16_TRAIL(supplementary)
Get the trail surrogate (0xdc00..0xdfff) for a supplementary code point (0x10000.....
Definition:utf16.h:132
U16_LEAD
#define U16_LEAD(supplementary)
Get the lead surrogate (0xd800..0xdbff) for a supplementary code point (0x10000..0x10ffff).
Definition:utf16.h:123
utypes.h
Basic definitions for ICU, for both C and C++ APIs.
UErrorCode
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
Definition:utypes.h:430
U_ZERO_ERROR
@ U_ZERO_ERROR
No error, no warning.
Definition:utypes.h:465
U_SUCCESS
#define U_SUCCESS(x)
Does the error code indicate success?
Definition:utypes.h:743
Generated by doxygen 1.9.1
[8]ページ先頭
©2009-2025 Movatter.jp