OnixS C++ B3 Binary UMDF Market Data Handler  1.4.2
API documentation
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 
32 /// Serializes into a string.
34 void
35 toStr(
36  std::string& str,
37  MessageType::Enum value);
38 
39 
40 /// Serializes into a string.
41 inline std::string toStr(MessageType::Enum value)
42 {
43  std::string str;
44 
45  toStr(str, value);
46 
47  return str;
48 }
49 
50 /// Serializes into a stream.
51 inline
52 std::ostream&
54  std::ostream& stream,
55  MessageType::Enum value)
56 {
57  std::string str;
58 
59  toStr(str, value);
60 
61  return stream << str;
62 }
63 
64 /// Serializes the object into FIX presentation.
65 inline
66 void
68  std::string& str,
69  MessageType::Enum value)
70 {
71  toStr(
72  str,
73  static_cast<MessageType::Base>(value));
74 }
75 
76 
77 /// Serializes into a string.
79 void
80 toStr(
81  std::string& str,
82  Boolean::Enum value);
83 
84 
85 /// Serializes into a string.
86 inline std::string toStr(Boolean::Enum value)
87 {
88  std::string str;
89 
90  toStr(str, value);
91 
92  return str;
93 }
94 
95 /// Serializes into a stream.
96 inline
97 std::ostream&
99  std::ostream& stream,
100  Boolean::Enum value)
101 {
102  std::string str;
103 
104  toStr(str, value);
105 
106  return stream << str;
107 }
108 
109 /// Serializes the object into FIX presentation.
110 inline
111 void
113  std::string& str,
114  Boolean::Enum value)
115 {
116  toStr(
117  str,
118  static_cast<Boolean::Base>(value));
119 }
120 
121 
122 /// Serializes into a string.
124 void
125 toStr(
126  std::string& str,
127  TimeUnit::Enum value);
128 
129 
130 /// Serializes into a string.
131 inline std::string toStr(TimeUnit::Enum value)
132 {
133  std::string str;
134 
135  toStr(str, value);
136 
137  return str;
138 }
139 
140 /// Serializes into a stream.
141 inline
142 std::ostream&
144  std::ostream& stream,
145  TimeUnit::Enum value)
146 {
147  std::string str;
148 
149  toStr(str, value);
150 
151  return stream << str;
152 }
153 
154 /// Serializes the object into FIX presentation.
155 inline
156 void
158  std::string& str,
159  TimeUnit::Enum value)
160 {
161  toStr(
162  str,
163  static_cast<TimeUnit::Base>(value));
164 }
165 
166 
167 /// Serializes into a string.
169 void
170 toStr(
171  std::string& str,
172  Side::Enum value);
173 
174 
175 /// Serializes into a string.
176 inline std::string toStr(Side::Enum value)
177 {
178  std::string str;
179 
180  toStr(str, value);
181 
182  return str;
183 }
184 
185 /// Serializes into a stream.
186 inline
187 std::ostream&
189  std::ostream& stream,
190  Side::Enum value)
191 {
192  std::string str;
193 
194  toStr(str, value);
195 
196  return stream << str;
197 }
198 
199 /// Serializes the object into FIX presentation.
200 inline
201 void
203  std::string& str,
204  Side::Enum value)
205 {
206  toStr(
207  str,
208  static_cast<Side::Base>(value));
209 }
210 
211 
212 /// Serializes into a string.
214 void
215 toStr(
216  std::string& str,
218 
219 
220 /// Serializes into a string.
221 inline
222 std::string
225 {
226  std::string str;
227 
228  toStr(str, value);
229 
230  return str;
231 }
232 
233 /// Serializes into a stream.
234 inline
235 std::ostream&
237  std::ostream& stream,
239 {
240  std::string str;
241 
242  toStr(str, value);
243 
244  return stream << str;
245 }
246 
247 /// Serializes the object into FIX presentation.
248 inline
249 void
251  std::string& str,
253 {
254  toStr(
255  str,
256  static_cast<SecurityUpdateAction::Base>(value));
257 }
258 
259 
260 /// Serializes into a string.
262 void
263 toStr(
264  std::string& str,
265  LotType::Enum value);
266 
267 
268 /// Serializes into a string.
269 inline std::string toStr(LotType::Enum value)
270 {
271  std::string str;
272 
273  toStr(str, value);
274 
275  return str;
276 }
277 
278 /// Serializes into a stream.
279 inline
280 std::ostream&
282  std::ostream& stream,
283  LotType::Enum value)
284 {
285  std::string str;
286 
287  toStr(str, value);
288 
289  return stream << str;
290 }
291 
292 /// Serializes the object into FIX presentation.
293 inline
294 void
296  std::string& str,
297  LotType::Enum value)
298 {
299  toStr(
300  str,
301  static_cast<LotType::Base>(value));
302 }
303 
304 
305 /// Serializes into a string.
307 void
308 toStr(
309  std::string& str,
310  Product::Enum value);
311 
312 
313 /// Serializes into a string.
314 inline std::string toStr(Product::Enum value)
315 {
316  std::string str;
317 
318  toStr(str, value);
319 
320  return str;
321 }
322 
323 /// Serializes into a stream.
324 inline
325 std::ostream&
327  std::ostream& stream,
328  Product::Enum value)
329 {
330  std::string str;
331 
332  toStr(str, value);
333 
334  return stream << str;
335 }
336 
337 /// Serializes the object into FIX presentation.
338 inline
339 void
341  std::string& str,
342  Product::Enum value)
343 {
344  toStr(
345  str,
346  static_cast<Product::Base>(value));
347 }
348 
349 
350 /// Serializes into a string.
352 void
353 toStr(
354  std::string& str,
355  SecurityType::Enum value);
356 
357 
358 /// Serializes into a string.
359 inline std::string toStr(SecurityType::Enum value)
360 {
361  std::string str;
362 
363  toStr(str, value);
364 
365  return str;
366 }
367 
368 /// Serializes into a stream.
369 inline
370 std::ostream&
372  std::ostream& stream,
373  SecurityType::Enum value)
374 {
375  std::string str;
376 
377  toStr(str, value);
378 
379  return stream << str;
380 }
381 
382 /// Serializes the object into FIX presentation.
383 inline
384 void
386  std::string& str,
387  SecurityType::Enum value)
388 {
389  toStr(
390  str,
391  static_cast<SecurityType::Base>(value));
392 }
393 
394 
395 /// Serializes into a string.
397 void
398 toStr(
399  std::string& str,
400  ExerciseStyle::Enum value);
401 
402 
403 /// Serializes into a string.
404 inline
405 std::string
407  ExerciseStyle::Enum value)
408 {
409  std::string str;
410 
411  toStr(str, value);
412 
413  return str;
414 }
415 
416 /// Serializes into a stream.
417 inline
418 std::ostream&
420  std::ostream& stream,
421  ExerciseStyle::Enum value)
422 {
423  std::string str;
424 
425  toStr(str, value);
426 
427  return stream << str;
428 }
429 
430 /// Serializes the object into FIX presentation.
431 inline
432 void
434  std::string& str,
435  ExerciseStyle::Enum value)
436 {
437  toStr(
438  str,
439  static_cast<ExerciseStyle::Base>(value));
440 }
441 
442 
443 /// Serializes into a string.
445 void
446 toStr(
447  std::string& str,
448  PutOrCall::Enum value);
449 
450 
451 /// Serializes into a string.
452 inline std::string toStr(PutOrCall::Enum value)
453 {
454  std::string str;
455 
456  toStr(str, value);
457 
458  return str;
459 }
460 
461 /// Serializes into a stream.
462 inline
463 std::ostream&
465  std::ostream& stream,
466  PutOrCall::Enum value)
467 {
468  std::string str;
469 
470  toStr(str, value);
471 
472  return stream << str;
473 }
474 
475 /// Serializes the object into FIX presentation.
476 inline
477 void
479  std::string& str,
480  PutOrCall::Enum value)
481 {
482  toStr(
483  str,
484  static_cast<PutOrCall::Base>(value));
485 }
486 
487 
488 /// Serializes into a string.
490 void
491 toStr(
492  std::string& str,
493  PriceType::Enum value);
494 
495 
496 /// Serializes into a string.
497 inline std::string toStr(PriceType::Enum value)
498 {
499  std::string str;
500 
501  toStr(str, value);
502 
503  return str;
504 }
505 
506 /// Serializes into a stream.
507 inline
508 std::ostream&
510  std::ostream& stream,
511  PriceType::Enum value)
512 {
513  std::string str;
514 
515  toStr(str, value);
516 
517  return stream << str;
518 }
519 
520 /// Serializes the object into FIX presentation.
521 inline
522 void
524  std::string& str,
525  PriceType::Enum value)
526 {
527  toStr(
528  str,
529  static_cast<PriceType::Base>(value));
530 }
531 
532 
533 /// Serializes into a string.
535 void
536 toStr(
537  std::string& str,
539 
540 
541 /// Serializes into a string.
542 inline
543 std::string
546 {
547  std::string str;
548 
549  toStr(str, value);
550 
551  return str;
552 }
553 
554 /// Serializes into a stream.
555 inline
556 std::ostream&
558  std::ostream& stream,
560 {
561  std::string str;
562 
563  toStr(str, value);
564 
565  return stream << str;
566 }
567 
568 /// Serializes the object into FIX presentation.
569 inline
570 void
572  std::string& str,
574 {
575  toStr(
576  str,
577  static_cast<SecurityTradingStatus::Base>(value));
578 }
579 
580 
581 /// Serializes into a string.
583 void
584 toStr(
585  std::string& str,
587 
588 
589 /// Serializes into a string.
590 inline
591 std::string
594 {
595  std::string str;
596 
597  toStr(str, value);
598 
599  return str;
600 }
601 
602 /// Serializes into a stream.
603 inline
604 std::ostream&
606  std::ostream& stream,
608 {
609  std::string str;
610 
611  toStr(str, value);
612 
613  return stream << str;
614 }
615 
616 /// Serializes the object into FIX presentation.
617 inline
618 void
620  std::string& str,
622 {
623  toStr(
624  str,
625  static_cast<TradingSessionSubID::Base>(value));
626 }
627 
628 
629 /// Serializes into a string.
631 void
632 toStr(
633  std::string& str,
635 
636 
637 /// Serializes into a string.
638 inline
639 std::string
642 {
643  std::string str;
644 
645  toStr(str, value);
646 
647  return str;
648 }
649 
650 /// Serializes into a stream.
651 inline
652 std::ostream&
654  std::ostream& stream,
656 {
657  std::string str;
658 
659  toStr(str, value);
660 
661  return stream << str;
662 }
663 
664 /// Serializes the object into FIX presentation.
665 inline
666 void
668  std::string& str,
670 {
671  toStr(
672  str,
673  static_cast<GovernanceIndicator::Base>(value));
674 }
675 
676 
677 /// Serializes into a string.
679 void
680 toStr(
681  std::string& str,
683 
684 
685 /// Serializes into a string.
686 inline
687 std::string
690 {
691  std::string str;
692 
693  toStr(str, value);
694 
695  return str;
696 }
697 
698 /// Serializes into a stream.
699 inline
700 std::ostream&
702  std::ostream& stream,
704 {
705  std::string str;
706 
707  toStr(str, value);
708 
709  return stream << str;
710 }
711 
712 /// Serializes the object into FIX presentation.
713 inline
714 void
716  std::string& str,
718 {
719  toStr(
720  str,
721  static_cast<SecurityMatchType::Base>(value));
722 }
723 
724 
725 /// Serializes into a string.
727 void
728 toStr(
729  std::string& str,
730  AggressorSide::Enum value);
731 
732 
733 /// Serializes into a string.
734 inline
735 std::string
737  AggressorSide::Enum value)
738 {
739  std::string str;
740 
741  toStr(str, value);
742 
743  return str;
744 }
745 
746 /// Serializes into a stream.
747 inline
748 std::ostream&
750  std::ostream& stream,
751  AggressorSide::Enum value)
752 {
753  std::string str;
754 
755  toStr(str, value);
756 
757  return stream << str;
758 }
759 
760 /// Serializes the object into FIX presentation.
761 inline
762 void
764  std::string& str,
765  AggressorSide::Enum value)
766 {
767  toStr(
768  str,
769  static_cast<AggressorSide::Base>(value));
770 }
771 
772 
773 /// Serializes into a string.
775 void
776 toStr(
777  std::string& str,
778  TradingSessionID::Enum value);
779 
780 
781 /// Serializes into a string.
782 inline
783 std::string
786 {
787  std::string str;
788 
789  toStr(str, value);
790 
791  return str;
792 }
793 
794 /// Serializes into a stream.
795 inline
796 std::ostream&
798  std::ostream& stream,
800 {
801  std::string str;
802 
803  toStr(str, value);
804 
805  return stream << str;
806 }
807 
808 /// Serializes the object into FIX presentation.
809 inline
810 void
812  std::string& str,
814 {
815  toStr(
816  str,
817  static_cast<TradingSessionID::Base>(value));
818 }
819 
820 
821 /// Serializes into a string.
823 void
824 toStr(
825  std::string& str,
827 
828 
829 /// Serializes into a string.
830 inline
831 std::string
834 {
835  std::string str;
836 
837  toStr(str, value);
838 
839  return str;
840 }
841 
842 /// Serializes into a stream.
843 inline
844 std::ostream&
846  std::ostream& stream,
848 {
849  std::string str;
850 
851  toStr(str, value);
852 
853  return stream << str;
854 }
855 
856 /// Serializes the object into FIX presentation.
857 inline
858 void
860  std::string& str,
862 {
863  toStr(
864  str,
865  static_cast<SecurityTradingEvent::Base>(value));
866 }
867 
868 
869 /// Serializes into a string.
871 void
872 toStr(
873  std::string& str,
874  PriceBandType::Enum value);
875 
876 
877 /// Serializes into a string.
878 inline
879 std::string
881  PriceBandType::Enum value)
882 {
883  std::string str;
884 
885  toStr(str, value);
886 
887  return str;
888 }
889 
890 /// Serializes into a stream.
891 inline
892 std::ostream&
894  std::ostream& stream,
895  PriceBandType::Enum value)
896 {
897  std::string str;
898 
899  toStr(str, value);
900 
901  return stream << str;
902 }
903 
904 /// Serializes the object into FIX presentation.
905 inline
906 void
908  std::string& str,
909  PriceBandType::Enum value)
910 {
911  toStr(
912  str,
913  static_cast<PriceBandType::Base>(value));
914 }
915 
916 
917 /// Serializes into a string.
919 void
920 toStr(
921  std::string& str,
923 
924 
925 /// Serializes into a string.
926 inline
927 std::string
930 {
931  std::string str;
932 
933  toStr(str, value);
934 
935  return str;
936 }
937 
938 /// Serializes into a stream.
939 inline
940 std::ostream&
942  std::ostream& stream,
944 {
945  std::string str;
946 
947  toStr(str, value);
948 
949  return stream << str;
950 }
951 
952 /// Serializes the object into FIX presentation.
953 inline
954 void
956  std::string& str,
958 {
959  toStr(
960  str,
961  static_cast<OpenCloseSettlFlag::Base>(value));
962 }
963 
964 
965 /// Serializes into a string.
967 void
968 toStr(
969  std::string& str,
970  PriceLimitType::Enum value);
971 
972 
973 /// Serializes into a string.
974 inline
975 std::string
977  PriceLimitType::Enum value)
978 {
979  std::string str;
980 
981  toStr(str, value);
982 
983  return str;
984 }
985 
986 /// Serializes into a stream.
987 inline
988 std::ostream&
990  std::ostream& stream,
991  PriceLimitType::Enum value)
992 {
993  std::string str;
994 
995  toStr(str, value);
996 
997  return stream << str;
998 }
999 
1000 /// Serializes the object into FIX presentation.
1001 inline
1002 void
1004  std::string& str,
1005  PriceLimitType::Enum value)
1006 {
1007  toStr(
1008  str,
1009  static_cast<PriceLimitType::Base>(value));
1010 }
1011 
1012 
1013 /// Serializes into a string.
1015 void
1016 toStr(
1017  std::string& str,
1019 
1020 
1021 /// Serializes into a string.
1022 inline
1023 std::string
1026 {
1027  std::string str;
1028 
1029  toStr(str, value);
1030 
1031  return str;
1032 }
1033 
1034 /// Serializes into a stream.
1035 inline
1036 std::ostream&
1038  std::ostream& stream,
1040 {
1041  std::string str;
1042 
1043  toStr(str, value);
1044 
1045  return stream << str;
1046 }
1047 
1048 /// Serializes the object into FIX presentation.
1049 inline
1050 void
1052  std::string& str,
1054 {
1055  toStr(
1056  str,
1057  static_cast<PriceBandMidpointPriceType::Base>(value));
1058 }
1059 
1060 
1061 /// Serializes into a string.
1063 void
1064 toStr(
1065  std::string& str,
1066  SettlPriceType::Enum value);
1067 
1068 
1069 /// Serializes into a string.
1070 inline
1071 std::string
1073  SettlPriceType::Enum value)
1074 {
1075  std::string str;
1076 
1077  toStr(str, value);
1078 
1079  return str;
1080 }
1081 
1082 /// Serializes into a stream.
1083 inline
1084 std::ostream&
1086  std::ostream& stream,
1087  SettlPriceType::Enum value)
1088 {
1089  std::string str;
1090 
1091  toStr(str, value);
1092 
1093  return stream << str;
1094 }
1095 
1096 /// Serializes the object into FIX presentation.
1097 inline
1098 void
1100  std::string& str,
1101  SettlPriceType::Enum value)
1102 {
1103  toStr(
1104  str,
1105  static_cast<SettlPriceType::Base>(value));
1106 }
1107 
1108 
1109 /// Serializes into a string.
1111 void
1112 toStr(
1113  std::string& str,
1114  UnderlyingPxType::Enum value);
1115 
1116 
1117 /// Serializes into a string.
1118 inline
1119 std::string
1121  UnderlyingPxType::Enum value)
1122 {
1123  std::string str;
1124 
1125  toStr(str, value);
1126 
1127  return str;
1128 }
1129 
1130 /// Serializes into a stream.
1131 inline
1132 std::ostream&
1134  std::ostream& stream,
1135  UnderlyingPxType::Enum value)
1136 {
1137  std::string str;
1138 
1139  toStr(str, value);
1140 
1141  return stream << str;
1142 }
1143 
1144 /// Serializes the object into FIX presentation.
1145 inline
1146 void
1148  std::string& str,
1149  UnderlyingPxType::Enum value)
1150 {
1151  toStr(
1152  str,
1153  static_cast<UnderlyingPxType::Base>(value));
1154 }
1155 
1156 
1157 /// Serializes into a string.
1159 void
1160 toStr(
1161  std::string& str,
1162  UpdateAction::Enum value);
1163 
1164 
1165 /// Serializes into a string.
1166 inline std::string toStr(UpdateAction::Enum value)
1167 {
1168  std::string str;
1169 
1170  toStr(str, value);
1171 
1172  return str;
1173 }
1174 
1175 /// Serializes into a stream.
1176 inline
1177 std::ostream&
1179  std::ostream& stream,
1180  UpdateAction::Enum value)
1181 {
1182  std::string str;
1183 
1184  toStr(str, value);
1185 
1186  return stream << str;
1187 }
1188 
1189 /// Serializes the object into FIX presentation.
1190 inline
1191 void
1193  std::string& str,
1194  UpdateAction::Enum value)
1195 {
1196  toStr(
1197  str,
1198  static_cast<UpdateAction::Base>(value));
1199 }
1200 
1201 
1202 /// Serializes into a string.
1204 void
1205 toStr(
1206  std::string& str,
1207  EntryType::Enum value);
1208 
1209 
1210 /// Serializes into a string.
1211 inline std::string toStr(EntryType::Enum value)
1212 {
1213  std::string str;
1214 
1215  toStr(str, value);
1216 
1217  return str;
1218 }
1219 
1220 /// Serializes into a stream.
1221 inline
1222 std::ostream&
1224  std::ostream& stream,
1225  EntryType::Enum value)
1226 {
1227  std::string str;
1228 
1229  toStr(str, value);
1230 
1231  return stream << str;
1232 }
1233 
1234 /// Serializes the object into FIX presentation.
1235 inline
1236 void
1238  std::string& str,
1239  EntryType::Enum value)
1240 {
1241  toStr(
1242  str,
1243  static_cast<EntryType::Base>(value));
1244 }
1245 
1246 
1247 /// Serializes into a string.
1249 void
1250 toStr(
1251  std::string& str,
1252  NewsSource::Enum value);
1253 
1254 
1255 /// Serializes into a string.
1256 inline std::string toStr(NewsSource::Enum value)
1257 {
1258  std::string str;
1259 
1260  toStr(str, value);
1261 
1262  return str;
1263 }
1264 
1265 /// Serializes into a stream.
1266 inline
1267 std::ostream&
1269  std::ostream& stream,
1270  NewsSource::Enum value)
1271 {
1272  std::string str;
1273 
1274  toStr(str, value);
1275 
1276  return stream << str;
1277 }
1278 
1279 /// Serializes the object into FIX presentation.
1280 inline
1281 void
1283  std::string& str,
1284  NewsSource::Enum value)
1285 {
1286  toStr(
1287  str,
1288  static_cast<NewsSource::Base>(value));
1289 }
1290 
1291 
1292 /// Serializes into a string.
1294 void
1295 toStr(
1296  std::string& str,
1297  ApplVerID::Enum value);
1298 
1299 
1300 /// Serializes into a string.
1301 inline std::string toStr(ApplVerID::Enum value)
1302 {
1303  std::string str;
1304 
1305  toStr(str, value);
1306 
1307  return str;
1308 }
1309 
1310 /// Serializes into a stream.
1311 inline
1312 std::ostream&
1314  std::ostream& stream,
1315  ApplVerID::Enum value)
1316 {
1317  std::string str;
1318 
1319  toStr(str, value);
1320 
1321  return stream << str;
1322 }
1323 
1324 /// Serializes the object into FIX presentation.
1325 inline
1326 void
1328  std::string& str,
1329  ApplVerID::Enum value)
1330 {
1331  toStr(
1332  str,
1333  static_cast<ApplVerID::Base>(value));
1334 }
1335 
1336 
1337 /// Serializes into a string.
1339 void
1340 toStr(
1341  std::string& str,
1342  MultiLegModel::Enum value);
1343 
1344 
1345 /// Serializes into a string.
1346 inline
1347 std::string
1349  MultiLegModel::Enum value)
1350 {
1351  std::string str;
1352 
1353  toStr(str, value);
1354 
1355  return str;
1356 }
1357 
1358 /// Serializes into a stream.
1359 inline
1360 std::ostream&
1362  std::ostream& stream,
1363  MultiLegModel::Enum value)
1364 {
1365  std::string str;
1366 
1367  toStr(str, value);
1368 
1369  return stream << str;
1370 }
1371 
1372 /// Serializes the object into FIX presentation.
1373 inline
1374 void
1376  std::string& str,
1377  MultiLegModel::Enum value)
1378 {
1379  toStr(
1380  str,
1381  static_cast<MultiLegModel::Base>(value));
1382 }
1383 
1384 
1385 /// Serializes into a string.
1387 void
1388 toStr(
1389  std::string& str,
1391 
1392 
1393 /// Serializes into a string.
1394 inline
1395 std::string
1398 {
1399  std::string str;
1400 
1401  toStr(str, value);
1402 
1403  return str;
1404 }
1405 
1406 /// Serializes into a stream.
1407 inline
1408 std::ostream&
1410  std::ostream& stream,
1412 {
1413  std::string str;
1414 
1415  toStr(str, value);
1416 
1417  return stream << str;
1418 }
1419 
1420 /// Serializes the object into FIX presentation.
1421 inline
1422 void
1424  std::string& str,
1426 {
1427  toStr(
1428  str,
1429  static_cast<MultiLegPriceMethod::Base>(value));
1430 }
1431 
1432 
1433 /// Serializes into a string.
1435 void
1436 toStr(
1437  std::string& str,
1438  InstrAttribType::Enum value);
1439 
1440 
1441 /// Serializes into a string.
1442 inline
1443 std::string
1445  InstrAttribType::Enum value)
1446 {
1447  std::string str;
1448 
1449  toStr(str, value);
1450 
1451  return str;
1452 }
1453 
1454 /// Serializes into a stream.
1455 inline
1456 std::ostream&
1458  std::ostream& stream,
1459  InstrAttribType::Enum value)
1460 {
1461  std::string str;
1462 
1463  toStr(str, value);
1464 
1465  return stream << str;
1466 }
1467 
1468 /// Serializes the object into FIX presentation.
1469 inline
1470 void
1472  std::string& str,
1473  InstrAttribType::Enum value)
1474 {
1475  toStr(
1476  str,
1477  static_cast<InstrAttribType::Base>(value));
1478 }
1479 
1480 
1481 /// Serializes into a string.
1483 void
1484 toStr(
1485  std::string& str,
1486  InstrAttribValue::Enum value);
1487 
1488 
1489 /// Serializes into a string.
1490 inline
1491 std::string
1493  InstrAttribValue::Enum value)
1494 {
1495  std::string str;
1496 
1497  toStr(str, value);
1498 
1499  return str;
1500 }
1501 
1502 /// Serializes into a stream.
1503 inline
1504 std::ostream&
1506  std::ostream& stream,
1507  InstrAttribValue::Enum value)
1508 {
1509  std::string str;
1510 
1511  toStr(str, value);
1512 
1513  return stream << str;
1514 }
1515 
1516 /// Serializes the object into FIX presentation.
1517 inline
1518 void
1520  std::string& str,
1521  InstrAttribValue::Enum value)
1522 {
1523  toStr(
1524  str,
1525  static_cast<InstrAttribValue::Base>(value));
1526 }
1527 
1528 
1529 /// Serializes into a string.
1531 void
1532 toStr(
1533  std::string& str,
1534  SecurityIDSource::Enum value);
1535 
1536 
1537 /// Serializes into a string.
1538 inline
1539 std::string
1541  SecurityIDSource::Enum value)
1542 {
1543  std::string str;
1544 
1545  toStr(str, value);
1546 
1547  return str;
1548 }
1549 
1550 /// Serializes into a stream.
1551 inline
1552 std::ostream&
1554  std::ostream& stream,
1555  SecurityIDSource::Enum value)
1556 {
1557  std::string str;
1558 
1559  toStr(str, value);
1560 
1561  return stream << str;
1562 }
1563 
1564 /// Serializes the object into FIX presentation.
1565 inline
1566 void
1568  std::string& str,
1569  SecurityIDSource::Enum value)
1570 {
1571  toStr(
1572  str,
1573  static_cast<SecurityIDSource::Base>(value));
1574 }
1575 
1576 
1577 /// Serializes into a string.
1579 void
1580 toStr(
1581  std::string& str,
1582  TrdSubType::Enum value);
1583 
1584 
1585 /// Serializes into a string.
1586 inline std::string toStr(TrdSubType::Enum value)
1587 {
1588  std::string str;
1589 
1590  toStr(str, value);
1591 
1592  return str;
1593 }
1594 
1595 /// Serializes into a stream.
1596 inline
1597 std::ostream&
1599  std::ostream& stream,
1600  TrdSubType::Enum value)
1601 {
1602  std::string str;
1603 
1604  toStr(str, value);
1605 
1606  return stream << str;
1607 }
1608 
1609 /// Serializes the object into FIX presentation.
1610 inline
1611 void
1613  std::string& str,
1614  TrdSubType::Enum value)
1615 {
1616  toStr(
1617  str,
1618  static_cast<TrdSubType::Base>(value));
1619 }
1620 
1621 
1622 /// Serializes into a string.
1624 void
1625 toStr(
1626  std::string& str,
1628 
1629 
1630 /// Serializes into a string.
1631 inline
1632 std::string
1635 {
1636  std::string str;
1637 
1638  toStr(str, value);
1639 
1640  return str;
1641 }
1642 
1643 /// Serializes into a stream.
1644 inline
1645 std::ostream&
1647  std::ostream& stream,
1649 {
1650  std::string str;
1651 
1652  toStr(str, value);
1653 
1654  return stream << str;
1655 }
1656 
1657 /// Serializes the object into FIX presentation.
1658 inline
1659 void
1661  std::string& str,
1663 {
1664  toStr(
1665  str,
1666  static_cast<ImpliedMarketIndicator::Base>(value));
1667 }
1668 
1669 
1670 /// Serializes into a string.
1672 void
1673 toStr(
1674  std::string& str,
1675  ImbalanceCondition set);
1676 
1677 
1678 /// Serializes into a string.
1679 inline std::string toStr(ImbalanceCondition set)
1680 {
1681  std::string str;
1682 
1683  toStr(str, set);
1684 
1685  return str;
1686 }
1687 
1688 /// Serializes into a stream.
1689 inline
1690 std::ostream&
1692  std::ostream& stream,
1693  ImbalanceCondition set)
1694 {
1695  std::string str;
1696 
1697  toStr(str, set);
1698 
1699  return stream << str;
1700 }
1701 
1702 /// Serializes the object into FIX presentation.
1703 inline
1704 void
1706  std::string& str,
1707  ImbalanceCondition set)
1708 {
1709  toStr(str, set.bits());
1710 }
1711 
1712 
1713 /// Serializes into a string.
1715 void
1716 toStr(
1717  std::string& str,
1718  TradeCondition set);
1719 
1720 
1721 /// Serializes into a string.
1722 inline std::string toStr(TradeCondition set)
1723 {
1724  std::string str;
1725 
1726  toStr(str, set);
1727 
1728  return str;
1729 }
1730 
1731 /// Serializes into a stream.
1732 inline
1733 std::ostream&
1735  std::ostream& stream,
1736  TradeCondition set)
1737 {
1738  std::string str;
1739 
1740  toStr(str, set);
1741 
1742  return stream << str;
1743 }
1744 
1745 /// Serializes the object into FIX presentation.
1746 inline
1747 void
1749  std::string& str,
1750  TradeCondition set)
1751 {
1752  toStr(str, set.bits());
1753 }
1754 
1755 
1756 /// Serializes into a string.
1758 void
1759 toStr(
1760  std::string& str,
1761  MatchEventIndicator set);
1762 
1763 
1764 /// Serializes into a string.
1765 inline std::string toStr(MatchEventIndicator set)
1766 {
1767  std::string str;
1768 
1769  toStr(str, set);
1770 
1771  return str;
1772 }
1773 
1774 /// Serializes into a stream.
1775 inline
1776 std::ostream&
1778  std::ostream& stream,
1779  MatchEventIndicator set)
1780 {
1781  std::string str;
1782 
1783  toStr(str, set);
1784 
1785  return stream << str;
1786 }
1787 
1788 /// Serializes the object into FIX presentation.
1789 inline
1790 void
1792  std::string& str,
1793  MatchEventIndicator set)
1794 {
1795  toStr(str, set.bits());
1796 }
1797 
1798 
1799 /// Serializes into a string.
1801 void
1802 toStr(
1803  std::string& str,
1804  const GroupSizeEncoding& obj);
1805 
1806 
1807 /// Serializes into a string.
1808 inline
1809 std::string
1811  const GroupSizeEncoding& obj)
1812 {
1813  std::string str;
1814 
1815  toStr(str, obj);
1816 
1817  return str;
1818 }
1819 
1820 /// Serializes into a stream.
1821 inline
1822 std::ostream&
1824  std::ostream& stream,
1825  const GroupSizeEncoding& obj)
1826 {
1827  std::string str;
1828 
1829  toStr(str, obj);
1830 
1831  return stream << str;
1832 }
1833 
1834 
1835 /// Serializes into a string.
1837 void
1838 toStr(
1839  std::string& str,
1840  const Percentage& obj);
1841 
1842 
1843 /// Serializes into a string.
1844 inline std::string toStr(const Percentage& obj)
1845 {
1846  std::string str;
1847 
1848  toStr(str, obj);
1849 
1850  return str;
1851 }
1852 
1853 /// Serializes into a stream.
1854 inline
1855 std::ostream&
1857  std::ostream& stream,
1858  const Percentage& obj)
1859 {
1860  std::string str;
1861 
1862  toStr(str, obj);
1863 
1864  return stream << str;
1865 }
1866 
1867 
1868 /// Serializes into a string.
1870 void
1871 toStr(
1872  std::string& str,
1873  const RatioQty& obj);
1874 
1875 
1876 /// Serializes into a string.
1877 inline std::string toStr(const RatioQty& obj)
1878 {
1879  std::string str;
1880 
1881  toStr(str, obj);
1882 
1883  return str;
1884 }
1885 
1886 /// Serializes into a stream.
1887 inline
1888 std::ostream&
1890  std::ostream& stream,
1891  const RatioQty& obj)
1892 {
1893  std::string str;
1894 
1895  toStr(str, obj);
1896 
1897  return stream << str;
1898 }
1899 
1900 
1901 /// Serializes into a string.
1903 void
1904 toStr(
1905  std::string& str,
1906  const UTCTimestampNanos& obj);
1907 
1908 
1909 /// Serializes into a string.
1910 inline
1911 std::string
1913  const UTCTimestampNanos& obj)
1914 {
1915  std::string str;
1916 
1917  toStr(str, obj);
1918 
1919  return str;
1920 }
1921 
1922 /// Serializes into a stream.
1923 inline
1924 std::ostream&
1926  std::ostream& stream,
1927  const UTCTimestampNanos& obj)
1928 {
1929  std::string str;
1930 
1931  toStr(str, obj);
1932 
1933  return stream << str;
1934 }
1935 
1936 
1937 /// Serializes into a string.
1939 void
1940 toStr(
1941  std::string& str,
1942  const UTCTimestampSeconds& obj);
1943 
1944 
1945 /// Serializes into a string.
1946 inline
1947 std::string
1949  const UTCTimestampSeconds& obj)
1950 {
1951  std::string str;
1952 
1953  toStr(str, obj);
1954 
1955  return str;
1956 }
1957 
1958 /// Serializes into a stream.
1959 inline
1960 std::ostream&
1962  std::ostream& stream,
1963  const UTCTimestampSeconds& obj)
1964 {
1965  std::string str;
1966 
1967  toStr(str, obj);
1968 
1969  return stream << str;
1970 }
1971 
1972 
1973 /// Serializes into a string.
1975 void
1976 toStr(
1977  std::string& str,
1978  const MaturityMonthYear& obj);
1979 
1980 
1981 /// Serializes into a string.
1982 inline
1983 std::string
1985  const MaturityMonthYear& obj)
1986 {
1987  std::string str;
1988 
1989  toStr(str, obj);
1990 
1991  return str;
1992 }
1993 
1994 /// Serializes into a stream.
1995 inline
1996 std::ostream&
1998  std::ostream& stream,
1999  const MaturityMonthYear& obj)
2000 {
2001  std::string str;
2002 
2003  toStr(str, obj);
2004 
2005  return stream << str;
2006 }
2007 
2008 
2009 /// Serializes into a string.
2011 void
2012 toStr(
2013  std::string& str,
2014  const PriceOffset8Optional& obj);
2015 
2016 
2017 /// Serializes into a string.
2018 inline
2019 std::string
2021  const PriceOffset8Optional& obj)
2022 {
2023  std::string str;
2024 
2025  toStr(str, obj);
2026 
2027  return str;
2028 }
2029 
2030 /// Serializes into a stream.
2031 inline
2032 std::ostream&
2034  std::ostream& stream,
2035  const PriceOffset8Optional& obj)
2036 {
2037  std::string str;
2038 
2039  toStr(str, obj);
2040 
2041  return stream << str;
2042 }
2043 
2044 
2045 /// Serializes into a string.
2047 void
2048 toStr(
2049  std::string& str,
2050  const TextEncoding& obj);
2051 
2052 
2053 /// Serializes into a string.
2054 inline std::string toStr(const TextEncoding& obj)
2055 {
2056  std::string str;
2057 
2058  toStr(str, obj);
2059 
2060  return str;
2061 }
2062 
2063 /// Serializes into a stream.
2064 inline
2065 std::ostream&
2067  std::ostream& stream,
2068  const TextEncoding& obj)
2069 {
2070  std::string str;
2071 
2072  toStr(str, obj);
2073 
2074  return stream << str;
2075 }
2076 
2077 
2078 /// Serializes into a string.
2080 void
2081 toStr(
2082  std::string& str,
2083  const VarString& obj);
2084 
2085 
2086 /// Serializes into a string.
2087 inline std::string toStr(const VarString& obj)
2088 {
2089  std::string str;
2090 
2091  toStr(str, obj);
2092 
2093  return str;
2094 }
2095 
2096 /// Serializes into a stream.
2097 inline
2098 std::ostream&
2100  std::ostream& stream,
2101  const VarString& obj)
2102 {
2103  std::string str;
2104 
2105  toStr(str, obj);
2106 
2107  return stream << str;
2108 }
2109 
2110 
2111 inline std::string ImbalanceCondition::toString() const
2112 {
2113  return toStr(*this);
2114 }
2115 
2116 inline std::string TradeCondition::toString() const
2117 {
2118  return toStr(*this);
2119 }
2120 
2121 inline std::string MatchEventIndicator::toString() const
2122 {
2123  return toStr(*this);
2124 }
2125 
2126 inline std::string GroupSizeEncoding::toString() const
2127 {
2128  return toStr(*this);
2129 }
2130 
2131 inline std::string UTCTimestampNanos::toString() const
2132 {
2133  return toStr(*this);
2134 }
2135 
2136 inline std::string UTCTimestampSeconds::toString() const
2137 {
2138  return toStr(*this);
2139 }
2140 
2141 inline std::string MaturityMonthYear::toString() const
2142 {
2143  return toStr(*this);
2144 }
2145 
2146 inline std::string TextEncoding::toString() const
2147 {
2148  return toStr(*this);
2149 }
2150 
2151 inline std::string VarString::toString() const
2152 {
2153  return toStr(*this);
2154 }
2155 
2156 inline std::string MessageType::toString(MessageType::Enum value)
2157 {
2158  return toStr(value);
2159 }
2160 
2161 inline std::string Boolean::toString(Boolean::Enum value)
2162 {
2163  return toStr(value);
2164 }
2165 
2166 inline std::string TimeUnit::toString(TimeUnit::Enum value)
2167 {
2168  return toStr(value);
2169 }
2170 
2171 inline std::string Side::toString(Side::Enum value)
2172 {
2173  return toStr(value);
2174 }
2175 
2176 inline
2177 std::string
2178 SecurityUpdateAction::toString(
2180 {
2181  return toStr(value);
2182 }
2183 
2184 inline std::string LotType::toString(LotType::Enum value)
2185 {
2186  return toStr(value);
2187 }
2188 
2189 inline std::string Product::toString(Product::Enum value)
2190 {
2191  return toStr(value);
2192 }
2193 
2194 inline std::string SecurityType::toString(SecurityType::Enum value)
2195 {
2196  return toStr(value);
2197 }
2198 
2199 inline
2200 std::string
2201 ExerciseStyle::toString(
2202  ExerciseStyle::Enum value)
2203 {
2204  return toStr(value);
2205 }
2206 
2207 inline std::string PutOrCall::toString(PutOrCall::Enum value)
2208 {
2209  return toStr(value);
2210 }
2211 
2212 inline std::string PriceType::toString(PriceType::Enum value)
2213 {
2214  return toStr(value);
2215 }
2216 
2217 inline
2218 std::string
2219 SecurityTradingStatus::toString(
2221 {
2222  return toStr(value);
2223 }
2224 
2225 inline
2226 std::string
2227 TradingSessionSubID::toString(
2229 {
2230  return toStr(value);
2231 }
2232 
2233 inline
2234 std::string
2235 GovernanceIndicator::toString(
2237 {
2238  return toStr(value);
2239 }
2240 
2241 inline
2242 std::string
2243 SecurityMatchType::toString(
2245 {
2246  return toStr(value);
2247 }
2248 
2249 inline
2250 std::string
2251 AggressorSide::toString(
2252  AggressorSide::Enum value)
2253 {
2254  return toStr(value);
2255 }
2256 
2257 inline
2258 std::string
2259 TradingSessionID::toString(
2260  TradingSessionID::Enum value)
2261 {
2262  return toStr(value);
2263 }
2264 
2265 inline
2266 std::string
2267 SecurityTradingEvent::toString(
2269 {
2270  return toStr(value);
2271 }
2272 
2273 inline
2274 std::string
2275 PriceBandType::toString(
2276  PriceBandType::Enum value)
2277 {
2278  return toStr(value);
2279 }
2280 
2281 inline
2282 std::string
2283 OpenCloseSettlFlag::toString(
2285 {
2286  return toStr(value);
2287 }
2288 
2289 inline
2290 std::string
2291 PriceLimitType::toString(
2292  PriceLimitType::Enum value)
2293 {
2294  return toStr(value);
2295 }
2296 
2297 inline
2298 std::string
2299 PriceBandMidpointPriceType::toString(
2301 {
2302  return toStr(value);
2303 }
2304 
2305 inline
2306 std::string
2307 SettlPriceType::toString(
2308  SettlPriceType::Enum value)
2309 {
2310  return toStr(value);
2311 }
2312 
2313 inline
2314 std::string
2315 UnderlyingPxType::toString(
2316  UnderlyingPxType::Enum value)
2317 {
2318  return toStr(value);
2319 }
2320 
2321 inline std::string UpdateAction::toString(UpdateAction::Enum value)
2322 {
2323  return toStr(value);
2324 }
2325 
2326 inline std::string EntryType::toString(EntryType::Enum value)
2327 {
2328  return toStr(value);
2329 }
2330 
2331 inline std::string NewsSource::toString(NewsSource::Enum value)
2332 {
2333  return toStr(value);
2334 }
2335 
2336 inline std::string ApplVerID::toString(ApplVerID::Enum value)
2337 {
2338  return toStr(value);
2339 }
2340 
2341 inline
2342 std::string
2343 MultiLegModel::toString(
2344  MultiLegModel::Enum value)
2345 {
2346  return toStr(value);
2347 }
2348 
2349 inline
2350 std::string
2351 MultiLegPriceMethod::toString(
2353 {
2354  return toStr(value);
2355 }
2356 
2357 inline
2358 std::string
2359 InstrAttribType::toString(
2360  InstrAttribType::Enum value)
2361 {
2362  return toStr(value);
2363 }
2364 
2365 inline
2366 std::string
2367 InstrAttribValue::toString(
2368  InstrAttribValue::Enum value)
2369 {
2370  return toStr(value);
2371 }
2372 
2373 inline
2374 std::string
2375 SecurityIDSource::toString(
2376  SecurityIDSource::Enum value)
2377 {
2378  return toStr(value);
2379 }
2380 
2381 inline std::string TrdSubType::toString(TrdSubType::Enum value)
2382 {
2383  return toStr(value);
2384 }
2385 
2386 inline
2387 std::string
2388 ImpliedMarketIndicator::toString(
2390 {
2391  return toStr(value);
2392 }
2393 
Enum
Describes how the price limits are expressed.
Definition: Fields.h:909
#define ONIXS_B3_UMDF_MD_EXPORTED
Definition: ABI.h:37
std::string toStr(const VarString &obj)
Serializes into a string.
Enum
Action used when updating the security.
Definition: Fields.h:376
Set of indicators for the end of updates for a given event. It also indicates if this message is a re...
Definition: Fields.h:1654
Set of conditions describing an imbalance..
Definition: Fields.h:1448
Enum
Describes the lot type for the instruments. Used for the Equities segment.
Definition: Fields.h:404
Enum
Indicates the type of price banding (tunnel).
Definition: Fields.h:844
UTC timestamp with nanosecond precision (Unix Epoch).
Definition: Composites.h:646
Enum
Type of exercise of a derivatives security.
Definition: Fields.h:545
Enum
Type of the Market Data Entry.
Definition: Fields.h:1055
UTC timestamp with second precision (Unix Epoch).
Definition: Composites.h:778
Enum
Indicates whether an option contract is a put or call.
Definition: Fields.h:568
Set of conditions describing a trade..
Definition: Fields.h:1531
Enum
Status related to a given Instrument or phase related to a SecurityGroup where the instrument belongs...
Definition: Fields.h:621
Enum
Indicates the Underlying Instrument price type reflected in Index value. Used for Composite Underlyin...
Definition: Fields.h:993
std::ostream & operator<<(std::ostream &stream, const VarString &obj)
Serializes into a stream.
Enum
Sub type of trade assigned to a trade.
Definition: Fields.h:1384
#define ONIXS_B3_UMDF_MD_MESSAGING_NAMESPACE_END
Definition: ABI.h:151
Enum
Code to represent the price type. If absent (zero), the default value is DECIMALS.
Definition: Fields.h:593
Enum
Phase related to a SecurityGroup where the instrument belongs to.
Definition: Fields.h:791
Enum
Identifies class or source of the SecurityID value.
Definition: Fields.h:1359
Enum
Band Midpoint Type, used with Auction Price Banding.
Definition: Fields.h:937
Enum
Indicates the type of product the security is associated with.
Definition: Fields.h:432
Enum
Types of Market Data update action.
Definition: Fields.h:1018
Enum
Corporative governance level indicator. Required for cash equities.
Definition: Fields.h:701
Enum
Indicates the type of the security.
Definition: Fields.h:475
Enum
Specifies the type of multileg order. Defines whether the security is pre-defined or user-defined...
Definition: Fields.h:1244
#define ONIXS_B3_UMDF_MD_MESSAGING_NAMESPACE_BEGIN
Definition: ABI.h:146
Enum
Type of matching that occurred. Required for Special Auctions.
Definition: Fields.h:741
Enum
Flag that identifies if the opening/closing/settlement price is related to theoretical, daily, previous business day or just an updated value.
Definition: Fields.h:875
Enum
Identifies an event related to a Trade. This tag is also used to mark when an instrument state is kep...
Definition: Fields.h:816
Enum
Status related to a given Instrument or phase related to a SecurityGroup where the instrument belongs...
Definition: Fields.h:661
Enum
Code to represent how the multileg price is to be interpreted when applied to the legs...
Definition: Fields.h:1267
Enum
Code to represent the type of instrument attributes.
Definition: Fields.h:1325
Enum
Which side is aggressor of this trade.
Definition: Fields.h:763
Enum
Specifies the service pack release being applied at message level.
Definition: Fields.h:1197
Enum
Code to represent the type of instrument attributes.
Definition: Fields.h:1302
Week, month and year of the maturity (used for standardized futures and options). ...
Definition: Composites.h:910
Enum
Indicates that an implied order can be created for the instrument.
Definition: Fields.h:1430
void toFix(std::string &str, MatchEventIndicator set)
Serializes the object into FIX presentation.