OnixS C++ CME iLink 3 Binary Order Entry Handler 1.18.9
API Documentation
Loading...
Searching...
No Matches
Serialization.h
Go to the documentation of this file.
1// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
2//
3// This software owned by Onix Solutions Limited [OnixS] and is
4// protected by copyright law and international copyright treaties.
5//
6// Access to and use of the software is governed by the terms of the applicable
7// OnixS Software Services Agreement (the Agreement) and Customer end user license
8// agreements granting a non-assignable, non-transferable and non-exclusive license
9// to use the software for it's own data processing purposes under the terms defined
10// in the Agreement.
11//
12// Except as otherwise granted within the terms of the Agreement, copying or
13// reproduction of any part of this source code or associated reference material
14// to any other location for further reproduction or redistribution, and any
15// amendments to this copyright notice, are expressly prohibited.
16//
17// Any reproduction or redistribution for sale or hiring of the Software not in
18// accordance with the terms of the Agreement is a violation of copyright law.
19//
20
21#pragma once
22
23#include <string>
24
27
29
30// Market Data Serialization.
31
34void
36 std::string& str,
37 AvgPxInd::Enum value);
38
39
41inline std::string toStr(AvgPxInd::Enum value)
42{
43 std::string str;
44
45 toStr(str, value);
46
47 return str;
48}
49
51inline
52std::ostream&
54 std::ostream& stream,
55 AvgPxInd::Enum value)
56{
57 std::string str;
58
59 toStr(str, value);
60
61 return stream << str;
62}
63
65inline
66void
68 std::string& str,
69 AvgPxInd::Enum value)
70{
71 toStr(
72 str,
73 static_cast<AvgPxInd::Base>(value));
74}
75
76
79void
81 std::string& str,
82 BooleanFlag::Enum value);
83
84
86inline std::string toStr(BooleanFlag::Enum value)
87{
88 std::string str;
89
90 toStr(str, value);
91
92 return str;
93}
94
96inline
97std::ostream&
99 std::ostream& stream,
100 BooleanFlag::Enum value)
101{
102 std::string str;
103
104 toStr(str, value);
105
106 return stream << str;
107}
108
110inline
111void
113 std::string& str,
114 BooleanFlag::Enum value)
115{
116 toStr(
117 str,
118 static_cast<BooleanFlag::Base>(value));
119}
120
121
124void
126 std::string& str,
127 BooleanNULL::Enum value);
128
129
131inline std::string toStr(BooleanNULL::Enum value)
132{
133 std::string str;
134
135 toStr(str, value);
136
137 return str;
138}
139
141inline
142std::ostream&
144 std::ostream& stream,
145 BooleanNULL::Enum value)
146{
147 std::string str;
148
149 toStr(str, value);
150
151 return stream << str;
152}
153
155inline
156void
158 std::string& str,
159 BooleanNULL::Enum value)
160{
161 toStr(
162 str,
163 static_cast<BooleanNULL::Base>(value));
164}
165
166
169void
171 std::string& str,
173
174
176inline
177std::string
180{
181 std::string str;
182
183 toStr(str, value);
184
185 return str;
186}
187
189inline
190std::ostream&
192 std::ostream& stream,
194{
195 std::string str;
196
197 toStr(str, value);
198
199 return stream << str;
200}
201
203inline
204void
206 std::string& str,
208{
209 toStr(
210 str,
211 static_cast<ClearingAcctType::Base>(value));
212}
213
214
217void
219 std::string& str,
220 CmtaGiveUpCD::Enum value);
221
222
224inline std::string toStr(CmtaGiveUpCD::Enum value)
225{
226 std::string str;
227
228 toStr(str, value);
229
230 return str;
231}
232
234inline
235std::ostream&
237 std::ostream& stream,
238 CmtaGiveUpCD::Enum value)
239{
240 std::string str;
241
242 toStr(str, value);
243
244 return stream << str;
245}
246
248inline
249void
251 std::string& str,
252 CmtaGiveUpCD::Enum value)
253{
254 toStr(
255 str,
256 static_cast<CmtaGiveUpCD::Base>(value));
257}
258
259
262void
264 std::string& str,
266
267
269inline
270std::string
273{
274 std::string str;
275
276 toStr(str, value);
277
278 return str;
279}
280
282inline
283std::ostream&
285 std::ostream& stream,
287{
288 std::string str;
289
290 toStr(str, value);
291
292 return stream << str;
293}
294
296inline
297void
299 std::string& str,
301{
302 toStr(
303 str,
304 static_cast<CustOrdHandlInst::Base>(value));
305}
306
307
310void
312 std::string& str,
314
315
317inline
318std::string
321{
322 std::string str;
323
324 toStr(str, value);
325
326 return str;
327}
328
330inline
331std::ostream&
333 std::ostream& stream,
335{
336 std::string str;
337
338 toStr(str, value);
339
340 return stream << str;
341}
342
344inline
345void
347 std::string& str,
349{
350 toStr(
351 str,
352 static_cast<CustOrderCapacity::Base>(value));
353}
354
355
358void
360 std::string& str,
361 DKReason::Enum value);
362
363
365inline std::string toStr(DKReason::Enum value)
366{
367 std::string str;
368
369 toStr(str, value);
370
371 return str;
372}
373
375inline
376std::ostream&
378 std::ostream& stream,
379 DKReason::Enum value)
380{
381 std::string str;
382
383 toStr(str, value);
384
385 return stream << str;
386}
387
389inline
390void
392 std::string& str,
393 DKReason::Enum value)
394{
395 toStr(
396 str,
397 static_cast<DKReason::Base>(value));
398}
399
400
403void
405 std::string& str,
406 ExecAckStatus::Enum value);
407
408
410inline
411std::string
414{
415 std::string str;
416
417 toStr(str, value);
418
419 return str;
420}
421
423inline
424std::ostream&
426 std::ostream& stream,
428{
429 std::string str;
430
431 toStr(str, value);
432
433 return stream << str;
434}
435
437inline
438void
440 std::string& str,
442{
443 toStr(
444 str,
445 static_cast<ExecAckStatus::Base>(value));
446}
447
448
451void
453 std::string& str,
454 ExecMode::Enum value);
455
456
458inline std::string toStr(ExecMode::Enum value)
459{
460 std::string str;
461
462 toStr(str, value);
463
464 return str;
465}
466
468inline
469std::ostream&
471 std::ostream& stream,
472 ExecMode::Enum value)
473{
474 std::string str;
475
476 toStr(str, value);
477
478 return stream << str;
479}
480
482inline
483void
485 std::string& str,
486 ExecMode::Enum value)
487{
488 toStr(
489 str,
490 static_cast<ExecMode::Base>(value));
491}
492
493
496void
498 std::string& str,
499 ExecReason::Enum value);
500
501
503inline std::string toStr(ExecReason::Enum value)
504{
505 std::string str;
506
507 toStr(str, value);
508
509 return str;
510}
511
513inline
514std::ostream&
516 std::ostream& stream,
517 ExecReason::Enum value)
518{
519 std::string str;
520
521 toStr(str, value);
522
523 return stream << str;
524}
525
527inline
528void
530 std::string& str,
531 ExecReason::Enum value)
532{
533 toStr(
534 str,
535 static_cast<ExecReason::Base>(value));
536}
537
538
541void
543 std::string& str,
544 ExecTypTrdCxl::Enum value);
545
546
548inline
549std::string
552{
553 std::string str;
554
555 toStr(str, value);
556
557 return str;
558}
559
561inline
562std::ostream&
564 std::ostream& stream,
566{
567 std::string str;
568
569 toStr(str, value);
570
571 return stream << str;
572}
573
575inline
576void
578 std::string& str,
580{
581 toStr(
582 str,
583 static_cast<ExecTypTrdCxl::Base>(value));
584}
585
586
589void
591 std::string& str,
592 ExpCycle::Enum value);
593
594
596inline std::string toStr(ExpCycle::Enum value)
597{
598 std::string str;
599
600 toStr(str, value);
601
602 return str;
603}
604
606inline
607std::ostream&
609 std::ostream& stream,
610 ExpCycle::Enum value)
611{
612 std::string str;
613
614 toStr(str, value);
615
616 return stream << str;
617}
618
620inline
621void
623 std::string& str,
624 ExpCycle::Enum value)
625{
626 toStr(
627 str,
628 static_cast<ExpCycle::Base>(value));
629}
630
631
634void
636 std::string& str,
637 FTI::Enum value);
638
639
641inline std::string toStr(FTI::Enum value)
642{
643 std::string str;
644
645 toStr(str, value);
646
647 return str;
648}
649
651inline
652std::ostream&
654 std::ostream& stream,
655 FTI::Enum value)
656{
657 std::string str;
658
659 toStr(str, value);
660
661 return stream << str;
662}
663
665inline
666void
668 std::string& str,
669 FTI::Enum value)
670{
671 toStr(
672 str,
673 static_cast<FTI::Base>(value));
674}
675
676
679void
681 std::string& str,
683
684
686inline
687std::string
690{
691 std::string str;
692
693 toStr(str, value);
694
695 return str;
696}
697
699inline
700std::ostream&
702 std::ostream& stream,
704{
705 std::string str;
706
707 toStr(str, value);
708
709 return stream << str;
710}
711
713inline
714void
716 std::string& str,
718{
719 toStr(
720 str,
721 static_cast<KeepAliveLapsed::Base>(value));
722}
723
724
727void
729 std::string& str,
730 ListUpdAct::Enum value);
731
732
734inline std::string toStr(ListUpdAct::Enum value)
735{
736 std::string str;
737
738 toStr(str, value);
739
740 return str;
741}
742
744inline
745std::ostream&
747 std::ostream& stream,
748 ListUpdAct::Enum value)
749{
750 std::string str;
751
752 toStr(str, value);
753
754 return stream << str;
755}
756
758inline
759void
761 std::string& str,
762 ListUpdAct::Enum value)
763{
764 toStr(
765 str,
766 static_cast<ListUpdAct::Base>(value));
767}
768
769
772void
774 std::string& str,
775 ManualOrdInd::Enum value);
776
777
779inline std::string toStr(ManualOrdInd::Enum value)
780{
781 std::string str;
782
783 toStr(str, value);
784
785 return str;
786}
787
789inline
790std::ostream&
792 std::ostream& stream,
793 ManualOrdInd::Enum value)
794{
795 std::string str;
796
797 toStr(str, value);
798
799 return stream << str;
800}
801
803inline
804void
806 std::string& str,
807 ManualOrdInd::Enum value)
808{
809 toStr(
810 str,
811 static_cast<ManualOrdInd::Base>(value));
812}
813
814
817void
819 std::string& str,
821
822
824inline
825std::string
828{
829 std::string str;
830
831 toStr(str, value);
832
833 return str;
834}
835
837inline
838std::ostream&
840 std::ostream& stream,
842{
843 std::string str;
844
845 toStr(str, value);
846
847 return stream << str;
848}
849
851inline
852void
854 std::string& str,
856{
857 toStr(
858 str,
859 static_cast<ManualOrdIndReq::Base>(value));
860}
861
862
865void
867 std::string& str,
869
870
872inline
873std::string
876{
877 std::string str;
878
879 toStr(str, value);
880
881 return str;
882}
883
885inline
886std::ostream&
888 std::ostream& stream,
890{
891 std::string str;
892
893 toStr(str, value);
894
895 return stream << str;
896}
897
899inline
900void
902 std::string& str,
904{
905 toStr(
906 str,
907 static_cast<MassActionOrdTyp::Base>(value));
908}
909
910
913void
915 std::string& str,
917
918
920inline
921std::string
924{
925 std::string str;
926
927 toStr(str, value);
928
929 return str;
930}
931
933inline
934std::ostream&
936 std::ostream& stream,
938{
939 std::string str;
940
941 toStr(str, value);
942
943 return stream << str;
944}
945
947inline
948void
950 std::string& str,
952{
953 toStr(
954 str,
955 static_cast<MassActionResponse::Base>(value));
956}
957
958
961void
963 std::string& str,
965
966
968inline
969std::string
972{
973 std::string str;
974
975 toStr(str, value);
976
977 return str;
978}
979
981inline
982std::ostream&
984 std::ostream& stream,
986{
987 std::string str;
988
989 toStr(str, value);
990
991 return stream << str;
992}
993
995inline
996void
998 std::string& str,
1000{
1001 toStr(
1002 str,
1003 static_cast<MassActionScope::Base>(value));
1004}
1005
1006
1009void
1011 std::string& str,
1012 MassCancelTIF::Enum value);
1013
1014
1016inline
1017std::string
1019 MassCancelTIF::Enum value)
1020{
1021 std::string str;
1022
1023 toStr(str, value);
1024
1025 return str;
1026}
1027
1029inline
1030std::ostream&
1032 std::ostream& stream,
1033 MassCancelTIF::Enum value)
1034{
1035 std::string str;
1036
1037 toStr(str, value);
1038
1039 return stream << str;
1040}
1041
1043inline
1044void
1046 std::string& str,
1047 MassCancelTIF::Enum value)
1048{
1049 toStr(
1050 str,
1051 static_cast<MassCancelTIF::Base>(value));
1052}
1053
1054
1057void
1059 std::string& str,
1060 MassCxlReqTyp::Enum value);
1061
1062
1064inline
1065std::string
1067 MassCxlReqTyp::Enum value)
1068{
1069 std::string str;
1070
1071 toStr(str, value);
1072
1073 return str;
1074}
1075
1077inline
1078std::ostream&
1080 std::ostream& stream,
1081 MassCxlReqTyp::Enum value)
1082{
1083 std::string str;
1084
1085 toStr(str, value);
1086
1087 return stream << str;
1088}
1089
1091inline
1092void
1094 std::string& str,
1095 MassCxlReqTyp::Enum value)
1096{
1097 toStr(
1098 str,
1099 static_cast<MassCxlReqTyp::Base>(value));
1100}
1101
1102
1105void
1107 std::string& str,
1109
1110
1112inline
1113std::string
1116{
1117 std::string str;
1118
1119 toStr(str, value);
1120
1121 return str;
1122}
1123
1125inline
1126std::ostream&
1128 std::ostream& stream,
1130{
1131 std::string str;
1132
1133 toStr(str, value);
1134
1135 return stream << str;
1136}
1137
1139inline
1140void
1142 std::string& str,
1144{
1145 toStr(
1146 str,
1147 static_cast<MassStatusOrdTyp::Base>(value));
1148}
1149
1150
1153void
1155 std::string& str,
1157
1158
1160inline
1161std::string
1164{
1165 std::string str;
1166
1167 toStr(str, value);
1168
1169 return str;
1170}
1171
1173inline
1174std::ostream&
1176 std::ostream& stream,
1178{
1179 std::string str;
1180
1181 toStr(str, value);
1182
1183 return stream << str;
1184}
1185
1187inline
1188void
1190 std::string& str,
1192{
1193 toStr(
1194 str,
1195 static_cast<MassStatusReqTyp::Base>(value));
1196}
1197
1198
1201void
1203 std::string& str,
1204 MassStatusTIF::Enum value);
1205
1206
1208inline
1209std::string
1211 MassStatusTIF::Enum value)
1212{
1213 std::string str;
1214
1215 toStr(str, value);
1216
1217 return str;
1218}
1219
1221inline
1222std::ostream&
1224 std::ostream& stream,
1225 MassStatusTIF::Enum value)
1226{
1227 std::string str;
1228
1229 toStr(str, value);
1230
1231 return stream << str;
1232}
1233
1235inline
1236void
1238 std::string& str,
1239 MassStatusTIF::Enum value)
1240{
1241 toStr(
1242 str,
1243 static_cast<MassStatusTIF::Base>(value));
1244}
1245
1246
1249void
1251 std::string& str,
1252 OFMOverrideReq::Enum value);
1253
1254
1256inline
1257std::string
1260{
1261 std::string str;
1262
1263 toStr(str, value);
1264
1265 return str;
1266}
1267
1269inline
1270std::ostream&
1272 std::ostream& stream,
1274{
1275 std::string str;
1276
1277 toStr(str, value);
1278
1279 return stream << str;
1280}
1281
1283inline
1284void
1286 std::string& str,
1288{
1289 toStr(
1290 str,
1291 static_cast<OFMOverrideReq::Base>(value));
1292}
1293
1294
1297void
1299 std::string& str,
1300 OrdStatusTrd::Enum value);
1301
1302
1304inline std::string toStr(OrdStatusTrd::Enum value)
1305{
1306 std::string str;
1307
1308 toStr(str, value);
1309
1310 return str;
1311}
1312
1314inline
1315std::ostream&
1317 std::ostream& stream,
1318 OrdStatusTrd::Enum value)
1319{
1320 std::string str;
1321
1322 toStr(str, value);
1323
1324 return stream << str;
1325}
1326
1328inline
1329void
1331 std::string& str,
1332 OrdStatusTrd::Enum value)
1333{
1334 toStr(
1335 str,
1336 static_cast<OrdStatusTrd::Base>(value));
1337}
1338
1339
1342void
1344 std::string& str,
1345 OrdStatusTrdCxl::Enum value);
1346
1347
1349inline
1350std::string
1353{
1354 std::string str;
1355
1356 toStr(str, value);
1357
1358 return str;
1359}
1360
1362inline
1363std::ostream&
1365 std::ostream& stream,
1367{
1368 std::string str;
1369
1370 toStr(str, value);
1371
1372 return stream << str;
1373}
1374
1376inline
1377void
1379 std::string& str,
1381{
1382 toStr(
1383 str,
1384 static_cast<OrdStatusTrdCxl::Base>(value));
1385}
1386
1387
1390void
1392 std::string& str,
1393 OrderEventType::Enum value);
1394
1395
1397inline
1398std::string
1401{
1402 std::string str;
1403
1404 toStr(str, value);
1405
1406 return str;
1407}
1408
1410inline
1411std::ostream&
1413 std::ostream& stream,
1415{
1416 std::string str;
1417
1418 toStr(str, value);
1419
1420 return stream << str;
1421}
1422
1424inline
1425void
1427 std::string& str,
1429{
1430 toStr(
1431 str,
1432 static_cast<OrderEventType::Base>(value));
1433}
1434
1435
1438void
1440 std::string& str,
1441 OrderStatus::Enum value);
1442
1443
1445inline std::string toStr(OrderStatus::Enum value)
1446{
1447 std::string str;
1448
1449 toStr(str, value);
1450
1451 return str;
1452}
1453
1455inline
1456std::ostream&
1458 std::ostream& stream,
1459 OrderStatus::Enum value)
1460{
1461 std::string str;
1462
1463 toStr(str, value);
1464
1465 return stream << str;
1466}
1467
1469inline
1470void
1472 std::string& str,
1473 OrderStatus::Enum value)
1474{
1475 toStr(
1476 str,
1477 static_cast<OrderStatus::Base>(value));
1478}
1479
1480
1483void
1485 std::string& str,
1486 OrderType::Enum value);
1487
1488
1490inline std::string toStr(OrderType::Enum value)
1491{
1492 std::string str;
1493
1494 toStr(str, value);
1495
1496 return str;
1497}
1498
1500inline
1501std::ostream&
1503 std::ostream& stream,
1504 OrderType::Enum value)
1505{
1506 std::string str;
1507
1508 toStr(str, value);
1509
1510 return stream << str;
1511}
1512
1514inline
1515void
1517 std::string& str,
1518 OrderType::Enum value)
1519{
1520 toStr(
1521 str,
1522 static_cast<OrderType::Base>(value));
1523}
1524
1525
1528void
1530 std::string& str,
1531 OrderTypeReq::Enum value);
1532
1533
1535inline std::string toStr(OrderTypeReq::Enum value)
1536{
1537 std::string str;
1538
1539 toStr(str, value);
1540
1541 return str;
1542}
1543
1545inline
1546std::ostream&
1548 std::ostream& stream,
1549 OrderTypeReq::Enum value)
1550{
1551 std::string str;
1552
1553 toStr(str, value);
1554
1555 return stream << str;
1556}
1557
1559inline
1560void
1562 std::string& str,
1563 OrderTypeReq::Enum value)
1564{
1565 toStr(
1566 str,
1567 static_cast<OrderTypeReq::Base>(value));
1568}
1569
1570
1573void
1575 std::string& str,
1576 PartyDetailRole::Enum value);
1577
1578
1580inline
1581std::string
1584{
1585 std::string str;
1586
1587 toStr(str, value);
1588
1589 return str;
1590}
1591
1593inline
1594std::ostream&
1596 std::ostream& stream,
1598{
1599 std::string str;
1600
1601 toStr(str, value);
1602
1603 return stream << str;
1604}
1605
1607inline
1608void
1610 std::string& str,
1612{
1613 toStr(
1614 str,
1615 static_cast<PartyDetailRole::Base>(value));
1616}
1617
1618
1621void
1623 std::string& str,
1624 QuoteAckStatus::Enum value);
1625
1626
1628inline
1629std::string
1632{
1633 std::string str;
1634
1635 toStr(str, value);
1636
1637 return str;
1638}
1639
1641inline
1642std::ostream&
1644 std::ostream& stream,
1646{
1647 std::string str;
1648
1649 toStr(str, value);
1650
1651 return stream << str;
1652}
1653
1655inline
1656void
1658 std::string& str,
1660{
1661 toStr(
1662 str,
1663 static_cast<QuoteAckStatus::Base>(value));
1664}
1665
1666
1669void
1671 std::string& str,
1672 QuoteCxlStatus::Enum value);
1673
1674
1676inline
1677std::string
1680{
1681 std::string str;
1682
1683 toStr(str, value);
1684
1685 return str;
1686}
1687
1689inline
1690std::ostream&
1692 std::ostream& stream,
1694{
1695 std::string str;
1696
1697 toStr(str, value);
1698
1699 return stream << str;
1700}
1701
1703inline
1704void
1706 std::string& str,
1708{
1709 toStr(
1710 str,
1711 static_cast<QuoteCxlStatus::Base>(value));
1712}
1713
1714
1717void
1719 std::string& str,
1720 QuoteCxlTyp::Enum value);
1721
1722
1724inline std::string toStr(QuoteCxlTyp::Enum value)
1725{
1726 std::string str;
1727
1728 toStr(str, value);
1729
1730 return str;
1731}
1732
1734inline
1735std::ostream&
1737 std::ostream& stream,
1738 QuoteCxlTyp::Enum value)
1739{
1740 std::string str;
1741
1742 toStr(str, value);
1743
1744 return stream << str;
1745}
1746
1748inline
1749void
1751 std::string& str,
1752 QuoteCxlTyp::Enum value)
1753{
1754 toStr(
1755 str,
1756 static_cast<QuoteCxlTyp::Base>(value));
1757}
1758
1759
1762void
1764 std::string& str,
1765 QuoteTyp::Enum value);
1766
1767
1769inline std::string toStr(QuoteTyp::Enum value)
1770{
1771 std::string str;
1772
1773 toStr(str, value);
1774
1775 return str;
1776}
1777
1779inline
1780std::ostream&
1782 std::ostream& stream,
1783 QuoteTyp::Enum value)
1784{
1785 std::string str;
1786
1787 toStr(str, value);
1788
1789 return stream << str;
1790}
1791
1793inline
1794void
1796 std::string& str,
1797 QuoteTyp::Enum value)
1798{
1799 toStr(
1800 str,
1801 static_cast<QuoteTyp::Base>(value));
1802}
1803
1804
1807void
1809 std::string& str,
1810 RFQSide::Enum value);
1811
1812
1814inline std::string toStr(RFQSide::Enum value)
1815{
1816 std::string str;
1817
1818 toStr(str, value);
1819
1820 return str;
1821}
1822
1824inline
1825std::ostream&
1827 std::ostream& stream,
1828 RFQSide::Enum value)
1829{
1830 std::string str;
1831
1832 toStr(str, value);
1833
1834 return stream << str;
1835}
1836
1838inline
1839void
1841 std::string& str,
1842 RFQSide::Enum value)
1843{
1844 toStr(
1845 str,
1846 static_cast<RFQSide::Base>(value));
1847}
1848
1849
1852void
1854 std::string& str,
1855 ReqResult::Enum value);
1856
1857
1859inline std::string toStr(ReqResult::Enum value)
1860{
1861 std::string str;
1862
1863 toStr(str, value);
1864
1865 return str;
1866}
1867
1869inline
1870std::ostream&
1872 std::ostream& stream,
1873 ReqResult::Enum value)
1874{
1875 std::string str;
1876
1877 toStr(str, value);
1878
1879 return stream << str;
1880}
1881
1883inline
1884void
1886 std::string& str,
1887 ReqResult::Enum value)
1888{
1889 toStr(
1890 str,
1891 static_cast<ReqResult::Base>(value));
1892}
1893
1894
1897void
1899 std::string& str,
1900 SLEDS::Enum value);
1901
1902
1904inline std::string toStr(SLEDS::Enum value)
1905{
1906 std::string str;
1907
1908 toStr(str, value);
1909
1910 return str;
1911}
1912
1914inline
1915std::ostream&
1917 std::ostream& stream,
1918 SLEDS::Enum value)
1919{
1920 std::string str;
1921
1922 toStr(str, value);
1923
1924 return stream << str;
1925}
1926
1928inline
1929void
1931 std::string& str,
1932 SLEDS::Enum value)
1933{
1934 toStr(
1935 str,
1936 static_cast<SLEDS::Base>(value));
1937}
1938
1939
1942void
1944 std::string& str,
1945 SMPI::Enum value);
1946
1947
1949inline std::string toStr(SMPI::Enum value)
1950{
1951 std::string str;
1952
1953 toStr(str, value);
1954
1955 return str;
1956}
1957
1959inline
1960std::ostream&
1962 std::ostream& stream,
1963 SMPI::Enum value)
1964{
1965 std::string str;
1966
1967 toStr(str, value);
1968
1969 return stream << str;
1970}
1971
1973inline
1974void
1976 std::string& str,
1977 SMPI::Enum value)
1978{
1979 toStr(
1980 str,
1981 static_cast<SMPI::Base>(value));
1982}
1983
1984
1987void
1989 std::string& str,
1990 SecRspTyp::Enum value);
1991
1992
1994inline std::string toStr(SecRspTyp::Enum value)
1995{
1996 std::string str;
1997
1998 toStr(str, value);
1999
2000 return str;
2001}
2002
2004inline
2005std::ostream&
2007 std::ostream& stream,
2008 SecRspTyp::Enum value)
2009{
2010 std::string str;
2011
2012 toStr(str, value);
2013
2014 return stream << str;
2015}
2016
2018inline
2019void
2021 std::string& str,
2022 SecRspTyp::Enum value)
2023{
2024 toStr(
2025 str,
2026 static_cast<SecRspTyp::Base>(value));
2027}
2028
2029
2032void
2034 std::string& str,
2035 ShortSaleType::Enum value);
2036
2037
2039inline
2040std::string
2042 ShortSaleType::Enum value)
2043{
2044 std::string str;
2045
2046 toStr(str, value);
2047
2048 return str;
2049}
2050
2052inline
2053std::ostream&
2055 std::ostream& stream,
2056 ShortSaleType::Enum value)
2057{
2058 std::string str;
2059
2060 toStr(str, value);
2061
2062 return stream << str;
2063}
2064
2066inline
2067void
2069 std::string& str,
2070 ShortSaleType::Enum value)
2071{
2072 toStr(
2073 str,
2074 static_cast<ShortSaleType::Base>(value));
2075}
2076
2077
2080void
2082 std::string& str,
2083 SideNULL::Enum value);
2084
2085
2087inline std::string toStr(SideNULL::Enum value)
2088{
2089 std::string str;
2090
2091 toStr(str, value);
2092
2093 return str;
2094}
2095
2097inline
2098std::ostream&
2100 std::ostream& stream,
2101 SideNULL::Enum value)
2102{
2103 std::string str;
2104
2105 toStr(str, value);
2106
2107 return stream << str;
2108}
2109
2111inline
2112void
2114 std::string& str,
2115 SideNULL::Enum value)
2116{
2117 toStr(
2118 str,
2119 static_cast<SideNULL::Base>(value));
2120}
2121
2122
2125void
2127 std::string& str,
2128 SideReq::Enum value);
2129
2130
2132inline std::string toStr(SideReq::Enum value)
2133{
2134 std::string str;
2135
2136 toStr(str, value);
2137
2138 return str;
2139}
2140
2142inline
2143std::ostream&
2145 std::ostream& stream,
2146 SideReq::Enum value)
2147{
2148 std::string str;
2149
2150 toStr(str, value);
2151
2152 return stream << str;
2153}
2154
2156inline
2157void
2159 std::string& str,
2160 SideReq::Enum value)
2161{
2162 toStr(
2163 str,
2164 static_cast<SideReq::Base>(value));
2165}
2166
2167
2170void
2172 std::string& str,
2173 SideTimeInForce::Enum value);
2174
2175
2177inline
2178std::string
2181{
2182 std::string str;
2183
2184 toStr(str, value);
2185
2186 return str;
2187}
2188
2190inline
2191std::ostream&
2193 std::ostream& stream,
2195{
2196 std::string str;
2197
2198 toStr(str, value);
2199
2200 return stream << str;
2201}
2202
2204inline
2205void
2207 std::string& str,
2209{
2210 toStr(
2211 str,
2212 static_cast<SideTimeInForce::Base>(value));
2213}
2214
2215
2218void
2220 std::string& str,
2221 SplitMsg::Enum value);
2222
2223
2225inline std::string toStr(SplitMsg::Enum value)
2226{
2227 std::string str;
2228
2229 toStr(str, value);
2230
2231 return str;
2232}
2233
2235inline
2236std::ostream&
2238 std::ostream& stream,
2239 SplitMsg::Enum value)
2240{
2241 std::string str;
2242
2243 toStr(str, value);
2244
2245 return stream << str;
2246}
2247
2249inline
2250void
2252 std::string& str,
2253 SplitMsg::Enum value)
2254{
2255 toStr(
2256 str,
2257 static_cast<SplitMsg::Base>(value));
2258}
2259
2260
2263void
2265 std::string& str,
2266 TimeInForce::Enum value);
2267
2268
2270inline std::string toStr(TimeInForce::Enum value)
2271{
2272 std::string str;
2273
2274 toStr(str, value);
2275
2276 return str;
2277}
2278
2280inline
2281std::ostream&
2283 std::ostream& stream,
2284 TimeInForce::Enum value)
2285{
2286 std::string str;
2287
2288 toStr(str, value);
2289
2290 return stream << str;
2291}
2292
2294inline
2295void
2297 std::string& str,
2298 TimeInForce::Enum value)
2299{
2300 toStr(
2301 str,
2302 static_cast<TimeInForce::Base>(value));
2303}
2304
2305
2308void
2310 std::string& str,
2311 TradeAddendum::Enum value);
2312
2313
2315inline
2316std::string
2318 TradeAddendum::Enum value)
2319{
2320 std::string str;
2321
2322 toStr(str, value);
2323
2324 return str;
2325}
2326
2328inline
2329std::ostream&
2331 std::ostream& stream,
2332 TradeAddendum::Enum value)
2333{
2334 std::string str;
2335
2336 toStr(str, value);
2337
2338 return stream << str;
2339}
2340
2342inline
2343void
2345 std::string& str,
2346 TradeAddendum::Enum value)
2347{
2348 toStr(
2349 str,
2350 static_cast<TradeAddendum::Base>(value));
2351}
2352
2353
2356void
2358 std::string& str,
2359 ExecInst set);
2360
2361
2363inline std::string toStr(ExecInst set)
2364{
2365 std::string str;
2366
2367 toStr(str, set);
2368
2369 return str;
2370}
2371
2373inline
2374std::ostream&
2376 std::ostream& stream,
2377 ExecInst set)
2378{
2379 std::string str;
2380
2381 toStr(str, set);
2382
2383 return stream << str;
2384}
2385
2387inline
2388void
2390 std::string& str,
2391 ExecInst set)
2392{
2393 toStr(str, set.bits());
2394}
2395
2396
2399void
2401 std::string& str,
2402 const MaturityMonthYear& obj);
2403
2404
2406inline
2407std::string
2409 const MaturityMonthYear& obj)
2410{
2411 std::string str;
2412
2413 toStr(str, obj);
2414
2415 return str;
2416}
2417
2419inline
2420std::ostream&
2422 std::ostream& stream,
2423 const MaturityMonthYear& obj)
2424{
2425 std::string str;
2426
2427 toStr(str, obj);
2428
2429 return stream << str;
2430}
2431
2432
2433inline std::string ExecInst::toString() const
2434{
2435 return toStr(*this);
2436}
2437
2438inline std::string MaturityMonthYear::toString() const
2439{
2440 return toStr(*this);
2441}
2442
2443inline std::string AvgPxInd::toString(AvgPxInd::Enum value)
2444{
2445 return toStr(value);
2446}
2447
2449{
2450 return toStr(value);
2451}
2452
2454{
2455 return toStr(value);
2456}
2457
2458inline
2459std::string
2462{
2463 return toStr(value);
2464}
2465
2467{
2468 return toStr(value);
2469}
2470
2471inline
2472std::string
2475{
2476 return toStr(value);
2477}
2478
2479inline
2480std::string
2483{
2484 return toStr(value);
2485}
2486
2487inline std::string DKReason::toString(DKReason::Enum value)
2488{
2489 return toStr(value);
2490}
2491
2492inline
2493std::string
2495 ExecAckStatus::Enum value)
2496{
2497 return toStr(value);
2498}
2499
2500inline std::string ExecMode::toString(ExecMode::Enum value)
2501{
2502 return toStr(value);
2503}
2504
2506{
2507 return toStr(value);
2508}
2509
2510inline
2511std::string
2513 ExecTypTrdCxl::Enum value)
2514{
2515 return toStr(value);
2516}
2517
2518inline std::string ExpCycle::toString(ExpCycle::Enum value)
2519{
2520 return toStr(value);
2521}
2522
2523inline std::string FTI::toString(FTI::Enum value)
2524{
2525 return toStr(value);
2526}
2527
2528inline
2529std::string
2532{
2533 return toStr(value);
2534}
2535
2537{
2538 return toStr(value);
2539}
2540
2542{
2543 return toStr(value);
2544}
2545
2546inline
2547std::string
2550{
2551 return toStr(value);
2552}
2553
2554inline
2555std::string
2558{
2559 return toStr(value);
2560}
2561
2562inline
2563std::string
2566{
2567 return toStr(value);
2568}
2569
2570inline
2571std::string
2574{
2575 return toStr(value);
2576}
2577
2578inline
2579std::string
2581 MassCancelTIF::Enum value)
2582{
2583 return toStr(value);
2584}
2585
2586inline
2587std::string
2589 MassCxlReqTyp::Enum value)
2590{
2591 return toStr(value);
2592}
2593
2594inline
2595std::string
2598{
2599 return toStr(value);
2600}
2601
2602inline
2603std::string
2606{
2607 return toStr(value);
2608}
2609
2610inline
2611std::string
2613 MassStatusTIF::Enum value)
2614{
2615 return toStr(value);
2616}
2617
2618inline
2619std::string
2622{
2623 return toStr(value);
2624}
2625
2627{
2628 return toStr(value);
2629}
2630
2631inline
2632std::string
2635{
2636 return toStr(value);
2637}
2638
2639inline
2640std::string
2643{
2644 return toStr(value);
2645}
2646
2648{
2649 return toStr(value);
2650}
2651
2652inline std::string OrderType::toString(OrderType::Enum value)
2653{
2654 return toStr(value);
2655}
2656
2658{
2659 return toStr(value);
2660}
2661
2662inline
2663std::string
2666{
2667 return toStr(value);
2668}
2669
2670inline
2671std::string
2674{
2675 return toStr(value);
2676}
2677
2678inline
2679std::string
2682{
2683 return toStr(value);
2684}
2685
2687{
2688 return toStr(value);
2689}
2690
2691inline std::string QuoteTyp::toString(QuoteTyp::Enum value)
2692{
2693 return toStr(value);
2694}
2695
2696inline std::string RFQSide::toString(RFQSide::Enum value)
2697{
2698 return toStr(value);
2699}
2700
2701inline std::string ReqResult::toString(ReqResult::Enum value)
2702{
2703 return toStr(value);
2704}
2705
2706inline std::string SLEDS::toString(SLEDS::Enum value)
2707{
2708 return toStr(value);
2709}
2710
2711inline std::string SMPI::toString(SMPI::Enum value)
2712{
2713 return toStr(value);
2714}
2715
2716inline std::string SecRspTyp::toString(SecRspTyp::Enum value)
2717{
2718 return toStr(value);
2719}
2720
2721inline
2722std::string
2724 ShortSaleType::Enum value)
2725{
2726 return toStr(value);
2727}
2728
2729inline std::string SideNULL::toString(SideNULL::Enum value)
2730{
2731 return toStr(value);
2732}
2733
2734inline std::string SideReq::toString(SideReq::Enum value)
2735{
2736 return toStr(value);
2737}
2738
2739inline
2740std::string
2743{
2744 return toStr(value);
2745}
2746
2747inline std::string SplitMsg::toString(SplitMsg::Enum value)
2748{
2749 return toStr(value);
2750}
2751
2753{
2754 return toStr(value);
2755}
2756
2757inline
2758std::string
2760 TradeAddendum::Enum value)
2761{
2762 return toStr(value);
2763}
2764
#define ONIXS_ILINK3_MESSAGING_NAMESPACE_END
Definition ABI.h:144
#define ONIXS_ILINK3_MESSAGING_NAMESPACE_BEGIN
Definition ABI.h:140
#define ONIXS_ILINK3_EXPORTED
Definition Compiler.h:175
std::ostream & operator<<(std::ostream &stream, const FloatingPointDecimal< Mantissa, Exponent > &value)
Serializes into a stream.
std::string toStr(const FixedPointDecimal< Mantissa, Exponent > &)
Serializes a fixed-point decimal into a string.
void toFix(std::string &str, const Negotiate500 &obj)
Serializes the object into FIX presentation.
static std::string toString(Enum)
static std::string toString(Enum)
static std::string toString(Enum)