LLVM: include/llvm/Support/YAMLTraits.h Source File (original) (raw)
1
2
3
4
5
6
7
8
9#ifndef LLVM_SUPPORT_YAMLTRAITS_H
10#define LLVM_SUPPORT_YAMLTRAITS_H
11
27#include
28#include
29#include
30#include
31#include
32#include
33#include
34#include <system_error>
35#include <type_traits>
36#include
37
38namespace llvm {
39
41
42namespace yaml {
43
49
51
52
53
54
55
56
57
58
59
60
61
63
64
65
66
67
68
69
70
71
72};
73
74
75
76
77
78
79
80
81
82
83
84
86
87
88
89
90
91
92
93
94};
95
96
97
98
99
100
101
102
103
104
105
106
111
112
113
114
115
116
117
118
119
120
121
122
127
128
129
130
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149template <typename T, typename Enable = void> struct ScalarTraits {
150
151
152
153
154
155
156
157
158
159
160
161};
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
180
181
182
183
184
185
186
187
188
189
190
191
192};
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
216
217
218
219
220
221
222
223
224
225
226
227
228
229};
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245template <typename T, typename EnableIf = void> struct SequenceTraits {
246
247
248
249
250
251
252
253};
254
255
256
261
262
263
269
270
271
272
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
296
297
298
299
300
301};
302
303
305
306
309
310 template
313
315};
316
317
320
321 template
323
325};
326
327
332
333 template
334 using check = std::tuple<SameType<SignatureInput, &U::input>,
337
339};
340
341
345
346 template
347 using check = std::tuple<SameType<SignatureInput, &U::input>,
349
351};
352
353
359
360 template
361 using check = std::tuple<SameType<SignatureInput, &U::input>,
364
365 static constexpr bool value =
367};
368
369
372
374
375 static constexpr bool value =
377};
378
379
387
388
391
393
394 static constexpr bool value =
396};
397
398
406
407
410
412
413 static constexpr bool value =
415};
416
417
425
426
434
435
438
440
441 static constexpr bool value =
443};
444
445
447 template using check = decltype(&U::flow);
448
450};
451
452
453template
455 : public std::bool_constant<has_SequenceMethodTraits::value> {};
456
457
460
462
463 static constexpr bool value =
465};
466
474
477 return Input.ltrim("0123456789");
478 };
479
480
481
482 if (S.empty() || S == "+" || S == "-")
483 return false;
484
485 if (S == ".nan" || S == ".NaN" || S == ".NAN")
486 return true;
487
488
490
491
492
493 if (Tail == ".inf" || Tail == ".Inf" || Tail == ".INF")
494 return true;
495
496
497
498
500 return S.size() > 2 &&
502
506
507
509
510
511
512
514 (S == "." ||
515 (S.size() > 1 && std::strchr("0123456789", S[1]) == nullptr)))
516 return false;
517
519 return false;
520
521 enum ParseState {
523 FoundDot,
524 FoundExponent,
525 };
526 ParseState State = Default;
527
528 S = skipDigits(S);
529
530
532 return true;
533
534 if (S.front() == '.') {
535 State = FoundDot;
537 } else if (S.front() == 'e' || S.front() == 'E') {
538 State = FoundExponent;
540 } else {
541 return false;
542 }
543
544 if (State == FoundDot) {
545 S = skipDigits(S);
547 return true;
548
549 if (S.front() == 'e' || S.front() == 'E') {
550 State = FoundExponent;
552 } else {
553 return false;
554 }
555 }
556
557 assert(State == FoundExponent && "Should have found exponent at this point.");
559 return false;
560
561 if (S.front() == '+' || S.front() == '-') {
564 return false;
565 }
566
567 return skipDigits(S).empty();
568}
569
571 return S == "null" || S == "Null" || S == "NULL" || S == "~";
572}
573
575
576 return S == "true" || S == "True" || S == "TRUE" || S == "false" ||
577 S == "False" || S == "FALSE";
578}
579
580
581
582
583
584
585
586
587
588
592
594 if (isSpace(static_cast<unsigned char>(S.front())) ||
595 isSpace(static_cast<unsigned char>(S.back())))
597 if (ForcePreserveAsString) {
604 }
605
606
607
608
609 if (std::strchr(R"(-?:\,[]{}#&*!|>'"%@`)", S[0]) != nullptr)
611
612 for (unsigned char C : S) {
613
615 continue;
616
617 switch (C) {
618
619 case '_':
620 case '-':
621 case '^':
622 case '.':
623 case ',':
624 case ' ':
625
626 case 0x9:
627 continue;
628
629
630
631 case 0xA:
632 case 0xD:
634
635 case 0x7F:
637
638
639
640
641
642 case '/':
643 default: {
644
645
646 if (C <= 0x1F)
648
649
650 if ((C & 0x80) != 0)
652
653
655 }
656 }
657 }
658
659 return MaxQuotingNeeded;
660}
661
662template <typename T, typename Context>
664 : public std::bool_constant<
665 !has_ScalarEnumerationTraits::value &&
666 !has_ScalarBitSetTraits::value && !has_ScalarTraits::value &&
667 !has_BlockScalarTraits::value &&
668 !has_TaggedScalarTraits::value &&
669 !has_MappingTraits<T, Context>::value &&
670 !has_SequenceTraits::value && !has_CustomMappingTraits::value &&
671 !has_DocumentListTraits::value &&
672 !has_PolymorphicTraits::value> {};
673
674template <typename T, typename Context>
676 : public std::bool_constant<has_MappingTraits<T, Context>::value &&
677 has_MappingValidateTraits<T, Context>::value> {
678};
679
680template <typename T, typename Context>
682 : public std::bool_constant<has_MappingTraits<T, Context>::value &&
683 !has_MappingValidateTraits<T, Context>::value> {
684};
685
686
688public:
689 IO(void *Ctxt = nullptr);
691
693
699
704
710 virtual std::vector keys() = 0;
711
714
719
723
727
729
731 virtual std::error_code error() = 0;
733
736 Val = ConstVal;
737 }
738 }
739
740
741 template
744 Val = ConstVal;
745 }
746 }
747
748 template <typename FBT, typename T> void enumFallback(T &Val) {
751
752 FBT Res = static_cast<typename FBT::BaseType>(Val);
753 yamlize(*this, Res, true, Context);
754 Val = static_cast<T>(static_cast<typename FBT::BaseType>(Res));
755 }
756 }
757
758 template
761 Val = static_cast<T>(Val | ConstVal);
762 }
763 }
764
765
766 template
769 Val = static_cast<T>(Val | ConstVal);
770 }
771 }
772
773 template
776 Val = Val | ConstVal;
777 }
778
779 template
783 Val = Val | ConstVal;
784 }
785
786 void *getContext() const;
787 void setContext(void *);
788
791 this->processKey(Key, Val, true, Ctx);
792 }
793
794 template <typename T, typename Context>
796 this->processKey(Key, Val, true, Ctx);
797 }
798
803
804 template <typename T, typename DefaultT>
809
810 template <typename T, typename Context>
813
815 return;
816 }
817 this->processKey(Key, Val, false, Ctx);
818 }
819
820 template <typename T, typename Context>
822 Context &Ctx) {
823 this->processKeyWithDefault(Key, Val, std::optional(),
824 false, Ctx);
825 }
826
827 template <typename T, typename Context, typename DefaultT>
829 Context &Ctx) {
830 static_assert(std::is_convertible<DefaultT, T>::value,
831 "Default type must be implicitly convertible to value type!");
832 this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
833 false, Ctx);
834 }
835
836private:
837 template <typename T, typename Context>
838 void processKeyWithDefault(StringRef Key, std::optional &Val,
839 const std::optional &DefaultValue,
840 bool Required, Context &Ctx);
841
842 template <typename T, typename Context>
843 void processKeyWithDefault(StringRef Key, T &Val, const T &DefaultValue,
844 bool Required, Context &Ctx) {
845 void *SaveInfo;
846 bool UseDefault;
847 const bool sameAsDefault = outputting() && Val == DefaultValue;
848 if (this->preflightKey(Key, Required, sameAsDefault, UseDefault,
849 SaveInfo)) {
851 this->postflightKey(SaveInfo);
852 } else {
853 if (UseDefault)
854 Val = DefaultValue;
855 }
856 }
857
858 template <typename T, typename Context>
859 void processKey(StringRef Key, T &Val, bool Required, Context &Ctx) {
860 void *SaveInfo;
861 bool UseDefault;
862 if (this->preflightKey(Key, Required, false, UseDefault, SaveInfo)) {
863 yamlize(*this, Val, Required, Ctx);
864 this->postflightKey(SaveInfo);
865 }
866 }
867
868private:
869 void *Ctxt;
870};
871
873
874template <typename T, typename Context>
878
882
883}
884
885template
886std::enable_if_t<has_ScalarEnumerationTraits::value, void>
892
893template
894std::enable_if_t<has_ScalarBitSetTraits::value, void>
896 bool DoClear;
898 if (DoClear)
899 Val = T();
902 }
903}
904
905template
906std::enable_if_t<has_ScalarTraits::value, void> yamlize(IO &io, T &Val, bool,
914 } else {
918 if (!Result.empty()) {
920 }
921 }
922}
923
924template
925std::enable_if_t<has_BlockScalarTraits::value, void>
928 std::string Storage;
933 } else {
938 if (!Result.empty())
940 }
941}
942
943template
944std::enable_if_t<has_TaggedScalarTraits::value, void>
947 std::string ScalarStorage, TagStorage;
948 raw_string_ostream ScalarBuffer(ScalarStorage), TagBuffer(TagStorage);
950 TagBuffer);
952 StringRef ScalarStr(ScalarStorage);
955 } else {
956 std::string Tag;
962 if (!Result.empty()) {
964 }
965 }
966}
967
969
970template <typename T, typename Context>
974
978
979}
980
981template <typename T, typename Context>
982std::enable_if_t<validatedMappingTraits<T, Context>::value, void>
986 else
990 if (!Err.empty()) {
991 errs() << Err << "\n";
992 assert(Err.empty() && "invalid struct trying to be written as yaml");
993 }
994 }
998 if (!Err.empty())
1000 }
1003 else
1005}
1006
1007template <typename T, typename Context>
1011 return false;
1012
1017 return Matched;
1018 }
1019 return false;
1020}
1021
1022template <typename T, typename Context>
1023std::enable_if_t<unvalidatedMappingTraits<T, Context>::value, void>
1026 return;
1031 } else {
1035 }
1036}
1037
1038template
1039std::enable_if_t<has_CustomMappingTraits::value, void>
1045 } else {
1050 }
1051}
1052
1053template
1054std::enable_if_t<has_PolymorphicTraits::value, void>
1066
1067template
1068std::enable_if_t<missingTraits<T, EmptyContext>::value, void>
1072
1073template <typename T, typename Context>
1074std::enable_if_t<has_SequenceTraits::value, void>
1079 for (unsigned i = 0; i < count; ++i) {
1080 void *SaveInfo;
1084 }
1085 }
1087 } else {
1090 for (unsigned i = 0; i < count; ++i) {
1091 void *SaveInfo;
1095 }
1096 }
1098 }
1099}
1100
1106
1112
1118
1124
1130
1136
1142
1148
1154
1160
1166
1172
1178
1179
1180
1181
1182template <typename value_type, llvm::endianness endian, size_t alignment>
1184 value_type, endian, alignment>,
1185 std::enable_if_t<has_ScalarTraits<value_type>::value>> {
1188 alignment>;
1189
1193
1195 value_type V;
1198 return R;
1199 }
1200
1204};
1205
1206template <typename value_type, llvm::endianness endian, size_t alignment>
1208 support::detail::packed_endian_specific_integral<value_type, endian,
1209 alignment>,
1210 std::enable_if_t<has_ScalarEnumerationTraits<value_type>::value>> {
1213 alignment>;
1214
1216 value_type V = E;
1218 E = V;
1219 }
1220};
1221
1222template <typename value_type, llvm::endianness endian, size_t alignment>
1224 support::detail::packed_endian_specific_integral<value_type, endian,
1225 alignment>,
1226 std::enable_if_t<has_ScalarBitSetTraits<value_type>::value>> {
1229 alignment>;
1231 value_type V = E;
1233 E = V;
1234 }
1235};
1236
1237
1238
1241 : io(i_o), BufPtr(nullptr), Result(Obj) {
1242 if (io.outputting()) {
1243 BufPtr = new (&Buffer) TNorm(io, Obj);
1244 } else {
1245 BufPtr = new (&Buffer) TNorm(io);
1246 }
1247 }
1248
1250 if (!io.outputting()) {
1251 Result = BufPtr->denormalize(io);
1252 }
1253 BufPtr->~TNorm();
1254 }
1255
1257
1258private:
1260
1261 Storage Buffer;
1262 IO &io;
1263 TNorm *BufPtr;
1264 TFinal &Result;
1265};
1266
1267
1268
1271 : io(i_o), Result(Obj) {
1272 if (io.outputting()) {
1273 BufPtr = new (&Buffer) TNorm(io, Obj);
1275 BufPtr = allocator->Allocate();
1276 new (BufPtr) TNorm(io);
1277 } else {
1278 BufPtr = new TNorm(io);
1279 }
1280 }
1281
1283 if (io.outputting()) {
1284 BufPtr->~TNorm();
1285 } else {
1286 Result = BufPtr->denormalize(io);
1287 }
1288 }
1289
1291
1292private:
1294
1295 Storage Buffer;
1296 IO &io;
1297 TNorm *BufPtr = nullptr;
1298 TFinal &Result;
1299};
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1314public:
1315
1316
1317
1320 void *DiagHandlerCtxt = nullptr);
1323 void *DiagHandlerCtxt = nullptr);
1325
1326
1327 std::error_code error() override;
1328
1329private:
1330 bool outputting() const override;
1331 bool mapTag(StringRef, bool) override;
1332 void beginMapping() override;
1333 void endMapping() override;
1334 bool preflightKey(StringRef Key, bool, bool, bool &, void *&) override;
1335 void postflightKey(void *) override;
1336 std::vector keys() override;
1337 void beginFlowMapping() override;
1338 void endFlowMapping() override;
1339 unsigned beginSequence() override;
1340 void endSequence() override;
1341 bool preflightElement(unsigned index, void *&) override;
1342 void postflightElement(void *) override;
1343 unsigned beginFlowSequence() override;
1344 bool preflightFlowElement(unsigned, void *&) override;
1345 void postflightFlowElement(void *) override;
1346 void endFlowSequence() override;
1347 void beginEnumScalar() override;
1348 bool matchEnumScalar(StringRef, bool) override;
1349 bool matchEnumFallback() override;
1350 void endEnumScalar() override;
1351 bool beginBitSetScalar(bool &) override;
1352 bool bitSetMatch(StringRef, bool) override;
1353 void endBitSetScalar() override;
1355 void blockScalarString(StringRef &) override;
1356 void scalarTag(std::string &) override;
1357 NodeKind getNodeKind() override;
1358 void setError(const Twine &message) override;
1359 bool canElideEmptySequence() override;
1360
1361 class HNode {
1362 public:
1363 HNode(Node *n) : _node(n) {}
1364
1365 static bool classof(const HNode *) { return true; }
1366
1367 Node *_node;
1368 };
1369
1370 class EmptyHNode : public HNode {
1371 public:
1372 EmptyHNode(Node *n) : HNode(n) {}
1373
1374 static bool classof(const HNode *n) { return NullNode::classof(n->_node); }
1375
1376 static bool classof(const EmptyHNode *) { return true; }
1377 };
1378
1379 class ScalarHNode : public HNode {
1380 public:
1381 ScalarHNode(Node *n, StringRef s) : HNode(n), _value(s) {}
1382
1383 StringRef value() const { return _value; }
1384
1385 static bool classof(const HNode *n) {
1386 return ScalarNode::classof(n->_node) ||
1387 BlockScalarNode::classof(n->_node);
1388 }
1389
1390 static bool classof(const ScalarHNode *) { return true; }
1391
1392 protected:
1393 StringRef _value;
1394 };
1395
1396 class MapHNode : public HNode {
1397 public:
1398 MapHNode(Node *n) : HNode(n) {}
1399
1400 static bool classof(const HNode *n) {
1401 return MappingNode::classof(n->_node);
1402 }
1403
1404 static bool classof(const MapHNode *) { return true; }
1405
1406 using NameToNodeAndLoc = StringMap<std::pair<HNode *, SMRange>>;
1407
1408 NameToNodeAndLoc Mapping;
1409 SmallVector<std::string, 6> ValidKeys;
1410 };
1411
1412 class SequenceHNode : public HNode {
1413 public:
1414 SequenceHNode(Node *n) : HNode(n) {}
1415
1416 static bool classof(const HNode *n) {
1417 return SequenceNode::classof(n->_node);
1418 }
1419
1420 static bool classof(const SequenceHNode *) { return true; }
1421
1422 std::vector<HNode *> Entries;
1423 };
1424
1425 Input::HNode *createHNodes(Node *node);
1426 void setError(HNode *hnode, const Twine &message);
1427 void setError(Node *node, const Twine &message);
1428 void setError(const SMRange &Range, const Twine &message);
1429
1430 void reportWarning(HNode *hnode, const Twine &message);
1431 void reportWarning(Node *hnode, const Twine &message);
1432 void reportWarning(const SMRange &Range, const Twine &message);
1433
1434
1435 void releaseHNodeBuffers();
1436
1437public:
1438
1439
1440 bool setCurrentDocument();
1441 bool nextDocument();
1442
1443
1444 const Node *getCurrentNode() const;
1445
1446 void setAllowUnknownKeys(bool Allow) override;
1447
1448private:
1449 SourceMgr SrcMgr;
1450 std::unique_ptrllvm::yaml::Stream Strm;
1451 HNode *TopNode = nullptr;
1452 std::error_code EC;
1454 SpecificBumpPtrAllocator EmptyHNodeAllocator;
1455 SpecificBumpPtrAllocator ScalarHNodeAllocator;
1456 SpecificBumpPtrAllocator MapHNodeAllocator;
1457 SpecificBumpPtrAllocator SequenceHNodeAllocator;
1458 document_iterator DocIterator;
1459 llvm::BitVector BitValuesUsed;
1460 HNode *CurrentNode = nullptr;
1461 bool ScalarMatchFound = false;
1462 bool AllowUnknownKeys = false;
1463};
1464
1465
1466
1467
1468
1470public:
1471 Output(raw_ostream &, void *Ctxt = nullptr, int WrapColumn = 70);
1473
1474
1475
1476
1477
1478
1480
1481 bool outputting() const override;
1482 bool mapTag(StringRef, bool) override;
1483 void beginMapping() override;
1484 void endMapping() override;
1485 bool preflightKey(StringRef Key, bool, bool, bool &, void *&) override;
1486 void postflightKey(void *) override;
1487 std::vector keys() override;
1488 void beginFlowMapping() override;
1489 void endFlowMapping() override;
1490 unsigned beginSequence() override;
1491 void endSequence() override;
1492 bool preflightElement(unsigned, void *&) override;
1493 void postflightElement(void *) override;
1494 unsigned beginFlowSequence() override;
1495 bool preflightFlowElement(unsigned, void *&) override;
1496 void postflightFlowElement(void *) override;
1497 void endFlowSequence() override;
1498 void beginEnumScalar() override;
1499 bool matchEnumScalar(StringRef, bool) override;
1500 bool matchEnumFallback() override;
1501 void endEnumScalar() override;
1502 bool beginBitSetScalar(bool &) override;
1503 bool bitSetMatch(StringRef, bool) override;
1504 void endBitSetScalar() override;
1506 void blockScalarString(StringRef &) override;
1507 void scalarTag(std::string &) override;
1508 NodeKind getNodeKind() override;
1509 void setError(const Twine &message) override;
1510 std::error_code error() override;
1511 bool canElideEmptySequence() override;
1512
1513
1514
1515 void beginDocuments();
1516 bool preflightDocument(unsigned);
1517 void postflightDocument();
1518 void endDocuments();
1519
1520private:
1523 void outputUpToEndOfLine(StringRef s);
1524 void newLineCheck(bool EmptySequence = false);
1525 void outputNewLine();
1528
1529 enum InState {
1530 inSeqFirstElement,
1531 inSeqOtherElement,
1532 inFlowSeqFirstElement,
1533 inFlowSeqOtherElement,
1534 inMapFirstKey,
1535 inMapOtherKey,
1536 inFlowMapFirstKey,
1537 inFlowMapOtherKey
1538 };
1539
1540 static bool inSeqAnyElement(InState State);
1541 static bool inFlowSeqAnyElement(InState State);
1542 static bool inMapAnyKey(InState State);
1543 static bool inFlowMapAnyKey(InState State);
1544
1546 int WrapColumn;
1548 int Column = 0;
1549 int ColumnAtFlowStart = 0;
1550 int ColumnAtMapFlowStart = 0;
1551 bool NeedBitValueComma = false;
1552 bool NeedFlowSequenceComma = false;
1553 bool EnumerationMatchFound = false;
1554 bool WriteDefaultValues = false;
1556 StringRef PaddingBeforeContainer;
1557};
1558
1559template <typename T, typename Context>
1560void IO::processKeyWithDefault(StringRef Key, std::optional &Val,
1561 const std::optional &DefaultValue,
1562 bool Required, Context &Ctx) {
1563 assert(!DefaultValue && "std::optional shouldn't have a value!");
1564 void *SaveInfo;
1565 bool UseDefault = true;
1566 const bool sameAsDefault = outputting() && !Val;
1568 Val = T();
1569 if (Val &&
1571
1572
1573
1574
1575
1576 bool IsNone = false;
1578 if (const auto *Node =
1580
1581
1582 IsNone = Node->getRawValue().rtrim(' ') == "";
1583
1584 if (IsNone)
1585 Val = DefaultValue;
1586 else
1589 } else {
1590 if (UseDefault)
1591 Val = DefaultValue;
1592 }
1593}
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603#define LLVM_YAML_STRONG_TYPEDEF(_base, _type) \
1604 struct _type { \
1605 _type() = default; \
1606 _type(const _base v) : value(v) {} \
1607 _type(const _type &v) = default; \
1608 _type &operator=(const _type &rhs) = default; \
1609 _type &operator=(const _base &rhs) { \
1610 value = rhs; \
1611 return *this; \
1612 } \
1613 operator const _base &() const { return value; } \
1614 bool operator==(const _type &rhs) const { return value == rhs.value; } \
1615 bool operator==(const _base &rhs) const { return value == rhs; } \
1616 bool operator<(const _type &rhs) const { return value < rhs.value; } \
1617 _base value; \
1618 using BaseType = _base; \
1619 };
1620
1621
1622
1623
1624
1629
1635
1641
1647
1653
1660
1661
1662template
1663inline std::enable_if_t<has_DocumentListTraits::value, Input &>
1665 int i = 0;
1669 if (yin.error())
1670 return yin;
1672 ++i;
1673 }
1674 return yin;
1675}
1676
1677
1678template
1679inline std::enable_if_t<has_MappingTraits<T, EmptyContext>::value, Input &>
1683 yamlize(yin, docMap, true, Ctx);
1684 return yin;
1685}
1686
1687
1688
1689template
1690inline std::enable_if_t<has_SequenceTraits::value, Input &>
1694 yamlize(yin, docSeq, true, Ctx);
1695 return yin;
1696}
1697
1698
1699template
1700inline std::enable_if_t<has_BlockScalarTraits::value, Input &>
1703 if (In.setCurrentDocument())
1704 yamlize(In, Val, true, Ctx);
1705 return In;
1706}
1707
1708
1709template
1710inline std::enable_if_t<has_CustomMappingTraits::value, Input &>
1713 if (In.setCurrentDocument())
1714 yamlize(In, Val, true, Ctx);
1715 return In;
1716}
1717
1718
1719template
1720inline std::enable_if_t<has_PolymorphicTraits::value, Input &>
1723 if (In.setCurrentDocument())
1724 yamlize(In, Val, true, Ctx);
1725 return In;
1726}
1727
1728
1729template
1730inline std::enable_if_t<missingTraits<T, EmptyContext>::value, Input &>
1732 char missing_yaml_trait_for_type[sizeof(MissingTrait)];
1733 return yin;
1734}
1735
1736
1737template
1738inline std::enable_if_t<has_DocumentListTraits::value, Output &>
1740 EmptyContext Ctx;
1741 yout.beginDocuments();
1742 const size_t count = DocumentListTraits::size(yout, docList);
1743 for (size_t i = 0; i < count; ++i) {
1744 if (yout.preflightDocument(i)) {
1745 yamlize(yout, DocumentListTraits::element(yout, docList, i), true,
1746 Ctx);
1747 yout.postflightDocument();
1748 }
1749 }
1750 yout.endDocuments();
1751 return yout;
1752}
1753
1754
1755template
1756inline std::enable_if_t<has_MappingTraits<T, EmptyContext>::value, Output &>
1759 yout.beginDocuments();
1760 if (yout.preflightDocument(0)) {
1761 yamlize(yout, map, true, Ctx);
1762 yout.postflightDocument();
1763 }
1764 yout.endDocuments();
1765 return yout;
1766}
1767
1768
1769template
1770inline std::enable_if_t<has_SequenceTraits::value, Output &>
1773 yout.beginDocuments();
1774 if (yout.preflightDocument(0)) {
1776 yout.postflightDocument();
1777 }
1778 yout.endDocuments();
1779 return yout;
1780}
1781
1782
1783template
1784inline std::enable_if_t<has_BlockScalarTraits::value, Output &>
1787 Out.beginDocuments();
1788 if (Out.preflightDocument(0)) {
1789 yamlize(Out, Val, true, Ctx);
1790 Out.postflightDocument();
1791 }
1792 Out.endDocuments();
1793 return Out;
1794}
1795
1796
1797template
1798inline std::enable_if_t<has_CustomMappingTraits::value, Output &>
1801 Out.beginDocuments();
1802 if (Out.preflightDocument(0)) {
1803 yamlize(Out, Val, true, Ctx);
1804 Out.postflightDocument();
1805 }
1806 Out.endDocuments();
1807 return Out;
1808}
1809
1810
1811
1812template
1813inline std::enable_if_t<has_PolymorphicTraits::value, Output &>
1816 Out.beginDocuments();
1817 if (Out.preflightDocument(0)) {
1818
1819
1821 "plain scalar documents are not supported");
1822 yamlize(Out, Val, true, Ctx);
1823 Out.postflightDocument();
1824 }
1825 Out.endDocuments();
1826 return Out;
1827}
1828
1829
1830template
1831inline std::enable_if_t<missingTraits<T, EmptyContext>::value, Output &>
1833 char missing_yaml_trait_for_type[sizeof(MissingTrait)];
1834 return yout;
1835}
1836
1839 static const bool flow = true;
1840};
1841
1842template
1844
1846 using type = typename T::value_type;
1847
1850 if (index >= seq.size())
1851 seq.resize(index + 1);
1852 } else {
1853 if (index >= seq.size()) {
1854 io.setError(Twine("value sequence extends beyond static size (") +
1856 return seq[0];
1857 }
1858 }
1859 return seq[index];
1860 }
1861};
1862
1863template <typename T, bool Flow>
1867
1868
1869
1873
1874
1875
1876template
1878 std::vector,
1879 std::enable_if_t<CheckIsBool<SequenceElementTraits::flow>::value>>
1880 : SequenceTraitsImpl<std::vector, SequenceElementTraits::flow> {};
1881template <typename T, size_t N>
1883 std::array<T, N>,
1884 std::enable_if_t<CheckIsBool<SequenceElementTraits::flow>::value>>
1885 : SequenceTraitsImpl<std::array<T, N>, SequenceElementTraits::flow> {};
1886template <typename T, unsigned N>
1889 std::enable_if_t<CheckIsBool<SequenceElementTraits::flow>::value>>
1890 : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits::flow> {};
1891template
1894 std::enable_if_t<CheckIsBool<SequenceElementTraits::flow>::value>>
1895 : SequenceTraitsImpl<SmallVectorImpl, SequenceElementTraits::flow> {};
1896template
1899 std::enable_if_t<CheckIsBool<SequenceElementTraits::flow>::value>>
1900 : SequenceTraitsImpl<MutableArrayRef, SequenceElementTraits::flow> {};
1901
1902
1903template
1905 static const bool flow = true;
1906};
1907
1908
1910 static const bool flow = false;
1911};
1913 static const bool flow = false;
1914};
1916 static const bool flow = false;
1917};
1918
1919
1922
1926
1928 for (auto &p : v)
1930 }
1931};
1932
1933}
1934}
1935
1936#define LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(TYPE, FLOW) \
1937 namespace llvm { \
1938 namespace yaml { \
1939 static_assert( \
1940 !std::is_fundamental_v && !std::is_same_v<TYPE, std::string> && \
1941 !std::is_same_v<TYPE, llvm::StringRef>, \
1942 "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"); \
1943 template <> struct SequenceElementTraits { \
1944 static const bool flow = FLOW; \
1945 }; \
1946 } \
1947 }
1948
1949
1950
1951#define LLVM_YAML_IS_SEQUENCE_VECTOR(type) \
1952 LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, false)
1953
1954
1955
1956#define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(type) \
1957 LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, true)
1958
1959#define LLVM_YAML_DECLARE_MAPPING_TRAITS(Type) \
1960 namespace llvm { \
1961 namespace yaml { \
1962 template <> struct LLVM_ABI MappingTraits { \
1963 static void mapping(IO &IO, Type &Obj); \
1964 }; \
1965 } \
1966 }
1967
1968#define LLVM_YAML_DECLARE_MAPPING_TRAITS_PRIVATE(Type) \
1969 namespace llvm { \
1970 namespace yaml { \
1971 template <> struct MappingTraits { \
1972 static void mapping(IO &IO, Type &Obj); \
1973 }; \
1974 } \
1975 }
1976
1977#define LLVM_YAML_DECLARE_ENUM_TRAITS(Type) \
1978 namespace llvm { \
1979 namespace yaml { \
1980 template <> struct LLVM_ABI ScalarEnumerationTraits { \
1981 static void enumeration(IO &io, Type &Value); \
1982 }; \
1983 } \
1984 }
1985
1986#define LLVM_YAML_DECLARE_BITSET_TRAITS(Type) \
1987 namespace llvm { \
1988 namespace yaml { \
1989 template <> struct LLVM_ABI ScalarBitSetTraits { \
1990 static void bitset(IO &IO, Type &Options); \
1991 }; \
1992 } \
1993 }
1994
1995#define LLVM_YAML_DECLARE_SCALAR_TRAITS(Type, MustQuote) \
1996 namespace llvm { \
1997 namespace yaml { \
1998 template <> struct LLVM_ABI ScalarTraits { \
1999 static void output(const Type &Value, void *ctx, raw_ostream &Out); \
2000 static StringRef input(StringRef Scalar, void *ctxt, Type &Value); \
2001 static QuotingType mustQuote(StringRef) { return MustQuote; } \
2002 }; \
2003 } \
2004 }
2005
2006
2007
2008#define LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(_type) \
2009 namespace llvm { \
2010 namespace yaml { \
2011 template \
2012 struct DocumentListTraits<SmallVector<_type, N>> \
2013 : public SequenceTraitsImpl<SmallVector<_type, N>, false> {}; \
2014 template <> \
2015 struct DocumentListTraits<std::vector<_type>> \
2016 : public SequenceTraitsImpl<std::vector<_type>, false> {}; \
2017 } \
2018 }
2019
2020
2021
2022#define LLVM_YAML_IS_STRING_MAP(_type) \
2023 namespace llvm { \
2024 namespace yaml { \
2025 template <> \
2026 struct CustomMappingTraits<std::map<std::string, _type>> \
2027 : public StdMapStringCustomMappingTraitsImpl<_type> {}; \
2028 } \
2029 }
2030
2035
2036#endif
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file defines the StringMap class.
This file defines the BumpPtrAllocator interface.
This file implements the BitVector class.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
This file defines the SmallVector class.
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
#define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(type)
Utility for declaring that a std::vector of a particular type should be considered a YAML flow sequen...
Definition YAMLTraits.h:1956
#define LLVM_YAML_STRONG_TYPEDEF(_base, _type)
YAML I/O does conversion based on types. But often native data types are just a typedef of built in i...
Definition YAMLTraits.h:1603
The Input class is used to parse a yaml document into in-memory structs and vectors.
Definition YAMLTraits.h:1313
Input(StringRef InputContent, void *Ctxt=nullptr, SourceMgr::DiagHandlerTy DiagHandler=nullptr, void *DiagHandlerCtxt=nullptr)
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
void(*)(const SMDiagnostic &, void *Context) DiagHandlerTy
Clients that want to handle their own diagnostics in a custom way can register a function pointer+con...
StringRef - Represent a constant reference to a string, i.e.
static constexpr size_t npos
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
constexpr bool empty() const
empty - Check if the string is empty.
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
char back() const
back - Get the last character in the string.
constexpr size_t size() const
size - Get the string size.
char front() const
front - Get the first character in the string.
LLVM_ABI size_t find_first_not_of(char C, size_t From=0) const
Find the first character in the string that is not C or npos if not found.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
LLVM Value Representation.
Represents a version number in the form major[.minor[.subminor[.build]]].
This class implements an extremely fast bulk output stream that can only output to a stream.
A raw_ostream that writes to an std::string.
A raw_ostream that writes to an SmallVector or SmallString.
StringRef str() const
Return a StringRef for the vector contents.
Definition YAMLTraits.h:687
virtual bool canElideEmptySequence()=0
virtual void postflightFlowElement(void *)=0
virtual NodeKind getNodeKind()=0
virtual void endSequence()=0
void bitSetCase(T &Val, StringRef Str, const T ConstVal)
Definition YAMLTraits.h:759
virtual bool matchEnumScalar(StringRef, bool)=0
virtual void endEnumScalar()=0
void bitSetCase(T &Val, StringRef Str, const uint32_t ConstVal)
Definition YAMLTraits.h:767
virtual bool outputting() const =0
virtual unsigned beginFlowSequence()=0
virtual bool mapTag(StringRef Tag, bool Default=false)=0
void mapOptionalWithContext(StringRef Key, T &Val, const DefaultT &Default, Context &Ctx)
Definition YAMLTraits.h:828
virtual void endFlowSequence()=0
virtual void beginMapping()=0
virtual void setAllowUnknownKeys(bool Allow)
void mapOptionalWithContext(StringRef Key, std::optional< T > &Val, Context &Ctx)
Definition YAMLTraits.h:821
void enumCase(T &Val, StringRef Str, const T ConstVal)
Definition YAMLTraits.h:734
virtual void endMapping()=0
void mapOptionalWithContext(StringRef Key, T &Val, Context &Ctx)
Definition YAMLTraits.h:811
virtual bool preflightElement(unsigned, void *&)=0
virtual unsigned beginSequence()=0
virtual void beginEnumScalar()=0
void maskedBitSetCase(T &Val, StringRef Str, uint32_t ConstVal, uint32_t Mask)
Definition YAMLTraits.h:780
virtual std::error_code error()=0
virtual void scalarString(StringRef &, QuotingType)=0
virtual bool bitSetMatch(StringRef, bool)=0
void mapOptional(StringRef Key, T &Val)
Definition YAMLTraits.h:799
virtual void setError(const Twine &)=0
void * getContext() const
virtual void postflightElement(void *)=0
virtual void postflightKey(void *)=0
void enumCase(T &Val, StringRef Str, const uint32_t ConstVal)
Definition YAMLTraits.h:742
virtual void endFlowMapping()=0
void mapRequired(StringRef Key, T &Val, Context &Ctx)
Definition YAMLTraits.h:795
void enumFallback(T &Val)
Definition YAMLTraits.h:748
virtual void beginFlowMapping()=0
virtual bool preflightKey(StringRef, bool, bool, bool &, void *&)=0
void mapOptional(StringRef Key, T &Val, const DefaultT &Default)
Definition YAMLTraits.h:805
void mapRequired(StringRef Key, T &Val)
Definition YAMLTraits.h:789
virtual bool beginBitSetScalar(bool &)=0
virtual void blockScalarString(StringRef &)=0
virtual void scalarTag(std::string &)=0
virtual bool matchEnumFallback()=0
virtual bool preflightFlowElement(unsigned, void *&)=0
virtual void endBitSetScalar()=0
virtual std::vector< StringRef > keys()=0
void maskedBitSetCase(T &Val, StringRef Str, T ConstVal, T Mask)
Definition YAMLTraits.h:774
The Input class is used to parse a yaml document into in-memory structs and vectors.
Definition YAMLTraits.h:1313
std::error_code error() override
bool setCurrentDocument()
Abstract base class for all Nodes.
The Output class is used to generate a yaml document from in-memory structs and vectors.
Definition YAMLTraits.h:1469
Output(raw_ostream &, void *Ctxt=nullptr, int WrapColumn=70)
void setWriteDefaultValues(bool Write)
Set whether or not to output optional values which are equal to the default value....
Definition YAMLTraits.h:1479
This class represents a YAML stream potentially containing multiple documents.
@ Tail
Attemps to make calls as fast as possible while guaranteeing that tail call optimization can always b...
@ C
The default llvm calling convention, compatible with C.
NodeAddr< NodeBase * > Node
void doMapping(IO &io, T &Val, Context &Ctx)
Definition YAMLTraits.h:875
std::string doValidate(IO &io, T &Val, Context &Ctx)
Definition YAMLTraits.h:971
QuotingType
Describe which type of quotes should be used when quoting is necessary.
Definition YAMLTraits.h:131
@ Single
Definition YAMLTraits.h:131
@ None
Definition YAMLTraits.h:131
@ Double
Definition YAMLTraits.h:131
std::enable_if_t< has_ScalarEnumerationTraits< T >::value, void > yamlize(IO &io, T &Val, bool, EmptyContext &Ctx)
Definition YAMLTraits.h:887
NodeKind
Definition YAMLTraits.h:44
@ Sequence
Definition YAMLTraits.h:47
@ Map
Definition YAMLTraits.h:46
@ Scalar
Definition YAMLTraits.h:45
decltype(std::declval< T >().resize(0)) check_resize_t
Definition YAMLTraits.h:1843
bool isNumeric(StringRef S)
Definition YAMLTraits.h:475
std::enable_if_t< has_DocumentListTraits< T >::value, Input & > operator>>(Input &yin, T &docList)
Definition YAMLTraits.h:1664
QuotingType needsQuotes(StringRef S, bool ForcePreserveAsString=true)
Definition YAMLTraits.h:589
bool isNull(StringRef S)
Definition YAMLTraits.h:570
bool isBool(StringRef S)
Definition YAMLTraits.h:574
bool yamlizeMappingEnumInput(IO &io, T &Val)
Definition YAMLTraits.h:1008
std::enable_if_t< has_DocumentListTraits< T >::value, Output & > operator<<(Output &yout, T &docList)
Definition YAMLTraits.h:1739
This is an optimization pass for GlobalISel generic memory operations.
decltype(auto) dyn_cast(const From &Val)
dyn_cast - Return the argument parameter cast to the specified type.
bool isAlnum(char C)
Checks whether character C is either a decimal digit or an uppercase or lowercase letter as classifie...
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
auto count(R &&Range, const E &Element)
Wrapper function around std::count to count the number of times an element Element occurs in the give...
typename detail::detector< void, Op, Args... >::value_t is_detected
Detects if a given trait holds for some set of arguments 'Args'.
bool isSpace(char C)
Checks whether character C is whitespace in the "C" locale.
auto seq(T Begin, T End)
Iterate over an integral type from Begin up to - but not including - End.
BumpPtrAllocatorImpl<> BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
@ Default
The result values are uniform if and only if all operands are uniform.
Implement std::hash so that hash_code can be used in STL containers.
A suitably aligned and sized character array member which can hold elements of any type.
This class should be specialized by type that requires custom conversion to/from a YAML literal block...
Definition YAMLTraits.h:179
Definition YAMLTraits.h:1870
static const bool value
Definition YAMLTraits.h:1871
This class should be specialized by any type that needs to be converted to/from a YAML mapping in the...
Definition YAMLTraits.h:273
This class should be specialized by any type that needs to be converted to/from a list of YAML docume...
Definition YAMLTraits.h:264
Definition YAMLTraits.h:50
static const bool flow
Definition YAMLTraits.h:1839
Definition YAMLTraits.h:1837
Definition YAMLTraits.h:1845
typename T::value_type type
Definition YAMLTraits.h:1846
static type & element(IO &io, T &seq, size_t index)
Definition YAMLTraits.h:1848
This class is similar to MappingTraits but allows you to pass in additional context for each map o...
Definition YAMLTraits.h:85
~MappingNormalizationHeap()
Definition YAMLTraits.h:1282
MappingNormalizationHeap(IO &i_o, TFinal &Obj, BumpPtrAllocator *allocator)
Definition YAMLTraits.h:1270
TNorm * operator->()
Definition YAMLTraits.h:1290
TNorm * operator->()
Definition YAMLTraits.h:1256
MappingNormalization(IO &i_o, TFinal &Obj)
Definition YAMLTraits.h:1240
~MappingNormalization()
Definition YAMLTraits.h:1249
This class should be specialized by any type that needs to be converted to/from a YAML mapping.
Definition YAMLTraits.h:62
Definition YAMLTraits.h:304
This class should be specialized by any type that can be represented as a scalar, map,...
Definition YAMLTraits.h:295
support::detail::packed_endian_specific_integral< value_type, endian, alignment > endian_type
Definition YAMLTraits.h:1227
static void bitset(IO &io, endian_type &E)
Definition YAMLTraits.h:1230
This class should be specialized by any integer type that is a union of bit values and the YAML repre...
Definition YAMLTraits.h:123
support::detail::packed_endian_specific_integral< value_type, endian, alignment > endian_type
Definition YAMLTraits.h:1211
static void enumeration(IO &io, endian_type &E)
Definition YAMLTraits.h:1215
This class should be specialized by any integral type that converts to/from a YAML scalar where there...
Definition YAMLTraits.h:107
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1639
static LLVM_ABI void output(const Hex16 &, void *, raw_ostream &)
static LLVM_ABI StringRef input(StringRef, void *, Hex16 &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1645
static LLVM_ABI void output(const Hex32 &, void *, raw_ostream &)
static LLVM_ABI StringRef input(StringRef, void *, Hex32 &)
static LLVM_ABI StringRef input(StringRef, void *, Hex64 &)
static LLVM_ABI void output(const Hex64 &, void *, raw_ostream &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1651
static LLVM_ABI StringRef input(StringRef, void *, Hex8 &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1633
static LLVM_ABI void output(const Hex8 &, void *, raw_ostream &)
static LLVM_ABI StringRef input(StringRef, void *, StringRef &)
static LLVM_ABI void output(const StringRef &, void *, raw_ostream &)
static QuotingType mustQuote(StringRef S)
Definition YAMLTraits.h:1110
static LLVM_ABI void output(const VersionTuple &Value, void *, llvm::raw_ostream &Out)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1658
static LLVM_ABI StringRef input(StringRef, void *, VersionTuple &)
static LLVM_ABI void output(const bool &, void *, raw_ostream &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1104
static LLVM_ABI StringRef input(StringRef, void *, bool &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1176
static LLVM_ABI StringRef input(StringRef, void *, double &)
static LLVM_ABI void output(const double &, void *, raw_ostream &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1170
static LLVM_ABI StringRef input(StringRef, void *, float &)
static LLVM_ABI void output(const float &, void *, raw_ostream &)
static LLVM_ABI void output(const int16_t &, void *, raw_ostream &)
static LLVM_ABI StringRef input(StringRef, void *, int16_t &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1152
static LLVM_ABI void output(const int32_t &, void *, raw_ostream &)
static LLVM_ABI StringRef input(StringRef, void *, int32_t &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1158
static LLVM_ABI StringRef input(StringRef, void *, int64_t &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1164
static LLVM_ABI void output(const int64_t &, void *, raw_ostream &)
static LLVM_ABI void output(const int8_t &, void *, raw_ostream &)
static LLVM_ABI StringRef input(StringRef, void *, int8_t &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1146
static LLVM_ABI void output(const std::string &, void *, raw_ostream &)
static QuotingType mustQuote(StringRef S)
Definition YAMLTraits.h:1116
static LLVM_ABI StringRef input(StringRef, void *, std::string &)
support::detail::packed_endian_specific_integral< value_type, endian, alignment > endian_type
Definition YAMLTraits.h:1186
static StringRef input(StringRef Str, void *Ctx, endian_type &E)
Definition YAMLTraits.h:1194
static void output(const endian_type &E, void *Ctx, raw_ostream &Stream)
Definition YAMLTraits.h:1190
static QuotingType mustQuote(StringRef Str)
Definition YAMLTraits.h:1201
static LLVM_ABI void output(const uint16_t &, void *, raw_ostream &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1128
static LLVM_ABI StringRef input(StringRef, void *, uint16_t &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1134
static LLVM_ABI StringRef input(StringRef, void *, uint32_t &)
static LLVM_ABI void output(const uint32_t &, void *, raw_ostream &)
static LLVM_ABI void output(const uint64_t &, void *, raw_ostream &)
static LLVM_ABI StringRef input(StringRef, void *, uint64_t &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1140
static LLVM_ABI void output(const uint8_t &, void *, raw_ostream &)
static QuotingType mustQuote(StringRef)
Definition YAMLTraits.h:1122
static LLVM_ABI StringRef input(StringRef, void *, uint8_t &)
This class should be specialized by type that requires custom conversion to/from a yaml scalar.
Definition YAMLTraits.h:149
static const bool flow
Definition YAMLTraits.h:1913
static const bool flow
Definition YAMLTraits.h:1905
static const bool flow
Definition YAMLTraits.h:1916
static const bool flow
Definition YAMLTraits.h:1910
This class should be specialized by any type for which vectors of that type need to be converted to/f...
Definition YAMLTraits.h:257
Definition YAMLTraits.h:1864
static size_t size(IO &io, T &seq)
Definition YAMLTraits.h:1865
This class should be specialized by any type that needs to be converted to/from a YAML sequence.
Definition YAMLTraits.h:245
Implementation of CustomMappingTraits for std::map<std::string, T>.
Definition YAMLTraits.h:1920
static void inputOne(IO &io, StringRef key, map_type &v)
Definition YAMLTraits.h:1923
std::map< std::string, T > map_type
Definition YAMLTraits.h:1921
static void output(IO &io, map_type &v)
Definition YAMLTraits.h:1927
This class should be specialized by type that requires custom conversion to/from a YAML scalar with o...
Definition YAMLTraits.h:215
Definition YAMLTraits.h:342
StringRef(*)(StringRef, void *, T &) SignatureInput
Definition YAMLTraits.h:343
static constexpr bool value
Definition YAMLTraits.h:350
void(*)(const T &, void *, raw_ostream &) SignatureOutput
Definition YAMLTraits.h:344
std::tuple< SameType< SignatureInput, &U::input >, SameType< SignatureOutput, &U::output > > check
Definition YAMLTraits.h:347
Definition YAMLTraits.h:436
SameType< SignatureInput, &U::inputOne > check
Definition YAMLTraits.h:439
static constexpr bool value
Definition YAMLTraits.h:441
void(*)(IO &io, StringRef key, T &v) SignatureInput
Definition YAMLTraits.h:437
Definition YAMLTraits.h:458
static constexpr bool value
Definition YAMLTraits.h:463
size_t(*)(class IO &, T &) SignatureSize
Definition YAMLTraits.h:459
SameType< SignatureSize, &U::size > check
Definition YAMLTraits.h:461
Definition YAMLTraits.h:446
decltype(&U::flow) check
Definition YAMLTraits.h:447
static constexpr bool value
Definition YAMLTraits.h:449
static constexpr bool value
Definition YAMLTraits.h:423
SameType< SignatureEnumInput, &U::enumInput > check
Definition YAMLTraits.h:421
void(*)(class IO &, T &) SignatureEnumInput
Definition YAMLTraits.h:419
Definition YAMLTraits.h:408
void(*)(class IO &, T &) SignatureEnumInput
Definition YAMLTraits.h:409
SameType< SignatureEnumInput, &U::enumInput > check
Definition YAMLTraits.h:411
static constexpr bool value
Definition YAMLTraits.h:413
SameType< SignatureMapping, &U::mapping > check
Definition YAMLTraits.h:383
void(*)(class IO &, T &) SignatureMapping
Definition YAMLTraits.h:381
static constexpr bool value
Definition YAMLTraits.h:385
Definition YAMLTraits.h:370
void(*)(class IO &, T &, Context &) SignatureMapping
Definition YAMLTraits.h:371
SameType< SignatureMapping, &U::mapping > check
Definition YAMLTraits.h:373
static constexpr bool value
Definition YAMLTraits.h:375
SameType< SignatureValidate, &U::validate > check
Definition YAMLTraits.h:402
static constexpr bool value
Definition YAMLTraits.h:404
std::string(*)(class IO &, T &) SignatureValidate
Definition YAMLTraits.h:400
Definition YAMLTraits.h:389
std::string(*)(class IO &, T &, Context &) SignatureValidate
Definition YAMLTraits.h:390
static constexpr bool value
Definition YAMLTraits.h:394
SameType< SignatureValidate, &U::validate > check
Definition YAMLTraits.h:392
Definition YAMLTraits.h:467
NodeKind(*)(const T &) SignatureGetKind
Definition YAMLTraits.h:468
static constexpr bool value
Definition YAMLTraits.h:472
SameType< SignatureGetKind, &U::getKind > check
Definition YAMLTraits.h:470
Definition YAMLTraits.h:318
void(*)(class IO &, T &) SignatureBitset
Definition YAMLTraits.h:319
static constexpr bool value
Definition YAMLTraits.h:324
SameType< SignatureBitset, &ScalarBitSetTraits< U >::bitset > check
Definition YAMLTraits.h:322
Definition YAMLTraits.h:307
void(*)(class IO &, T &) SignatureEnumeration
Definition YAMLTraits.h:308
SameType< SignatureEnumeration, &ScalarEnumerationTraits< U >::enumeration > check
Definition YAMLTraits.h:311
static constexpr bool value
Definition YAMLTraits.h:314
Definition YAMLTraits.h:328
void(*)(const T &, void *, raw_ostream &) SignatureOutput
Definition YAMLTraits.h:330
QuotingType(*)(StringRef) SignatureMustQuote
Definition YAMLTraits.h:331
std::tuple< SameType< SignatureInput, &U::input >, SameType< SignatureOutput, &U::output >, SameType< SignatureMustQuote, &U::mustQuote > > check
Definition YAMLTraits.h:334
StringRef(*)(StringRef, void *, T &) SignatureInput
Definition YAMLTraits.h:329
static constexpr bool value
Definition YAMLTraits.h:338
Definition YAMLTraits.h:427
static constexpr bool value
Definition YAMLTraits.h:432
size_t(*)(class IO &, T &) SignatureSize
Definition YAMLTraits.h:428
SameType< SignatureSize, &U::size > check
Definition YAMLTraits.h:430
Definition YAMLTraits.h:455
Definition YAMLTraits.h:354
StringRef(*)(StringRef, StringRef, void *, T &) SignatureInput
Definition YAMLTraits.h:355
QuotingType(*)(const T &, StringRef) SignatureMustQuote
Definition YAMLTraits.h:358
std::tuple< SameType< SignatureInput, &U::input >, SameType< SignatureOutput, &U::output >, SameType< SignatureMustQuote, &U::mustQuote > > check
Definition YAMLTraits.h:361
void(*)(const T &, void *, raw_ostream &, raw_ostream &) SignatureOutput
Definition YAMLTraits.h:356
static constexpr bool value
Definition YAMLTraits.h:365
Definition YAMLTraits.h:672
Definition YAMLTraits.h:683
Definition YAMLTraits.h:677