OnixS C++ B3 Binary UMDF Market Data Handler  1.3.0
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,
1627  ImbalanceCondition set);
1628 
1629 
1630 /// Serializes into a string.
1631 inline std::string toStr(ImbalanceCondition set)
1632 {
1633  std::string str;
1634 
1635  toStr(str, set);
1636 
1637  return str;
1638 }
1639 
1640 /// Serializes into a stream.
1641 inline
1642 std::ostream&
1644  std::ostream& stream,
1645  ImbalanceCondition set)
1646 {
1647  std::string str;
1648 
1649  toStr(str, set);
1650 
1651  return stream << str;
1652 }
1653 
1654 /// Serializes the object into FIX presentation.
1655 inline
1656 void
1658  std::string& str,
1659  ImbalanceCondition set)
1660 {
1661  toStr(str, set.bits());
1662 }
1663 
1664 
1665 /// Serializes into a string.
1667 void
1668 toStr(
1669  std::string& str,
1670  TradeCondition set);
1671 
1672 
1673 /// Serializes into a string.
1674 inline std::string toStr(TradeCondition set)
1675 {
1676  std::string str;
1677 
1678  toStr(str, set);
1679 
1680  return str;
1681 }
1682 
1683 /// Serializes into a stream.
1684 inline
1685 std::ostream&
1687  std::ostream& stream,
1688  TradeCondition set)
1689 {
1690  std::string str;
1691 
1692  toStr(str, set);
1693 
1694  return stream << str;
1695 }
1696 
1697 /// Serializes the object into FIX presentation.
1698 inline
1699 void
1701  std::string& str,
1702  TradeCondition set)
1703 {
1704  toStr(str, set.bits());
1705 }
1706 
1707 
1708 /// Serializes into a string.
1710 void
1711 toStr(
1712  std::string& str,
1713  MatchEventIndicator set);
1714 
1715 
1716 /// Serializes into a string.
1717 inline std::string toStr(MatchEventIndicator set)
1718 {
1719  std::string str;
1720 
1721  toStr(str, set);
1722 
1723  return str;
1724 }
1725 
1726 /// Serializes into a stream.
1727 inline
1728 std::ostream&
1730  std::ostream& stream,
1731  MatchEventIndicator set)
1732 {
1733  std::string str;
1734 
1735  toStr(str, set);
1736 
1737  return stream << str;
1738 }
1739 
1740 /// Serializes the object into FIX presentation.
1741 inline
1742 void
1744  std::string& str,
1745  MatchEventIndicator set)
1746 {
1747  toStr(str, set.bits());
1748 }
1749 
1750 
1751 /// Serializes into a string.
1753 void
1754 toStr(
1755  std::string& str,
1756  const GroupSizeEncoding& obj);
1757 
1758 
1759 /// Serializes into a string.
1760 inline
1761 std::string
1763  const GroupSizeEncoding& obj)
1764 {
1765  std::string str;
1766 
1767  toStr(str, obj);
1768 
1769  return str;
1770 }
1771 
1772 /// Serializes into a stream.
1773 inline
1774 std::ostream&
1776  std::ostream& stream,
1777  const GroupSizeEncoding& obj)
1778 {
1779  std::string str;
1780 
1781  toStr(str, obj);
1782 
1783  return stream << str;
1784 }
1785 
1786 
1787 /// Serializes into a string.
1789 void
1790 toStr(
1791  std::string& str,
1792  const Percentage& obj);
1793 
1794 
1795 /// Serializes into a string.
1796 inline std::string toStr(const Percentage& obj)
1797 {
1798  std::string str;
1799 
1800  toStr(str, obj);
1801 
1802  return str;
1803 }
1804 
1805 /// Serializes into a stream.
1806 inline
1807 std::ostream&
1809  std::ostream& stream,
1810  const Percentage& obj)
1811 {
1812  std::string str;
1813 
1814  toStr(str, obj);
1815 
1816  return stream << str;
1817 }
1818 
1819 
1820 /// Serializes into a string.
1822 void
1823 toStr(
1824  std::string& str,
1825  const RatioQty& obj);
1826 
1827 
1828 /// Serializes into a string.
1829 inline std::string toStr(const RatioQty& obj)
1830 {
1831  std::string str;
1832 
1833  toStr(str, obj);
1834 
1835  return str;
1836 }
1837 
1838 /// Serializes into a stream.
1839 inline
1840 std::ostream&
1842  std::ostream& stream,
1843  const RatioQty& obj)
1844 {
1845  std::string str;
1846 
1847  toStr(str, obj);
1848 
1849  return stream << str;
1850 }
1851 
1852 
1853 /// Serializes into a string.
1855 void
1856 toStr(
1857  std::string& str,
1858  const UTCTimestampNanos& obj);
1859 
1860 
1861 /// Serializes into a string.
1862 inline
1863 std::string
1865  const UTCTimestampNanos& obj)
1866 {
1867  std::string str;
1868 
1869  toStr(str, obj);
1870 
1871  return str;
1872 }
1873 
1874 /// Serializes into a stream.
1875 inline
1876 std::ostream&
1878  std::ostream& stream,
1879  const UTCTimestampNanos& obj)
1880 {
1881  std::string str;
1882 
1883  toStr(str, obj);
1884 
1885  return stream << str;
1886 }
1887 
1888 
1889 /// Serializes into a string.
1891 void
1892 toStr(
1893  std::string& str,
1894  const UTCTimestampSeconds& obj);
1895 
1896 
1897 /// Serializes into a string.
1898 inline
1899 std::string
1901  const UTCTimestampSeconds& obj)
1902 {
1903  std::string str;
1904 
1905  toStr(str, obj);
1906 
1907  return str;
1908 }
1909 
1910 /// Serializes into a stream.
1911 inline
1912 std::ostream&
1914  std::ostream& stream,
1915  const UTCTimestampSeconds& obj)
1916 {
1917  std::string str;
1918 
1919  toStr(str, obj);
1920 
1921  return stream << str;
1922 }
1923 
1924 
1925 /// Serializes into a string.
1927 void
1928 toStr(
1929  std::string& str,
1930  const MaturityMonthYear& obj);
1931 
1932 
1933 /// Serializes into a string.
1934 inline
1935 std::string
1937  const MaturityMonthYear& obj)
1938 {
1939  std::string str;
1940 
1941  toStr(str, obj);
1942 
1943  return str;
1944 }
1945 
1946 /// Serializes into a stream.
1947 inline
1948 std::ostream&
1950  std::ostream& stream,
1951  const MaturityMonthYear& obj)
1952 {
1953  std::string str;
1954 
1955  toStr(str, obj);
1956 
1957  return stream << str;
1958 }
1959 
1960 
1961 /// Serializes into a string.
1963 void
1964 toStr(
1965  std::string& str,
1966  const Percentage9& obj);
1967 
1968 
1969 /// Serializes into a string.
1970 inline std::string toStr(const Percentage9& obj)
1971 {
1972  std::string str;
1973 
1974  toStr(str, obj);
1975 
1976  return str;
1977 }
1978 
1979 /// Serializes into a stream.
1980 inline
1981 std::ostream&
1983  std::ostream& stream,
1984  const Percentage9& obj)
1985 {
1986  std::string str;
1987 
1988  toStr(str, obj);
1989 
1990  return stream << str;
1991 }
1992 
1993 
1994 /// Serializes into a string.
1996 void
1997 toStr(
1998  std::string& str,
1999  const PriceOffset8Optional& obj);
2000 
2001 
2002 /// Serializes into a string.
2003 inline
2004 std::string
2006  const PriceOffset8Optional& obj)
2007 {
2008  std::string str;
2009 
2010  toStr(str, obj);
2011 
2012  return str;
2013 }
2014 
2015 /// Serializes into a stream.
2016 inline
2017 std::ostream&
2019  std::ostream& stream,
2020  const PriceOffset8Optional& obj)
2021 {
2022  std::string str;
2023 
2024  toStr(str, obj);
2025 
2026  return stream << str;
2027 }
2028 
2029 
2030 /// Serializes into a string.
2032 void
2033 toStr(
2034  std::string& str,
2035  const TextEncoding& obj);
2036 
2037 
2038 /// Serializes into a string.
2039 inline std::string toStr(const TextEncoding& obj)
2040 {
2041  std::string str;
2042 
2043  toStr(str, obj);
2044 
2045  return str;
2046 }
2047 
2048 /// Serializes into a stream.
2049 inline
2050 std::ostream&
2052  std::ostream& stream,
2053  const TextEncoding& obj)
2054 {
2055  std::string str;
2056 
2057  toStr(str, obj);
2058 
2059  return stream << str;
2060 }
2061 
2062 
2063 /// Serializes into a string.
2065 void
2066 toStr(
2067  std::string& str,
2068  const VarString& obj);
2069 
2070 
2071 /// Serializes into a string.
2072 inline std::string toStr(const VarString& obj)
2073 {
2074  std::string str;
2075 
2076  toStr(str, obj);
2077 
2078  return str;
2079 }
2080 
2081 /// Serializes into a stream.
2082 inline
2083 std::ostream&
2085  std::ostream& stream,
2086  const VarString& obj)
2087 {
2088  std::string str;
2089 
2090  toStr(str, obj);
2091 
2092  return stream << str;
2093 }
2094 
2095 
2096 inline std::string ImbalanceCondition::toString() const
2097 {
2098  return toStr(*this);
2099 }
2100 
2101 inline std::string TradeCondition::toString() const
2102 {
2103  return toStr(*this);
2104 }
2105 
2106 inline std::string MatchEventIndicator::toString() const
2107 {
2108  return toStr(*this);
2109 }
2110 
2111 inline std::string GroupSizeEncoding::toString() const
2112 {
2113  return toStr(*this);
2114 }
2115 
2116 inline std::string UTCTimestampNanos::toString() const
2117 {
2118  return toStr(*this);
2119 }
2120 
2121 inline std::string UTCTimestampSeconds::toString() const
2122 {
2123  return toStr(*this);
2124 }
2125 
2126 inline std::string MaturityMonthYear::toString() const
2127 {
2128  return toStr(*this);
2129 }
2130 
2131 inline std::string TextEncoding::toString() const
2132 {
2133  return toStr(*this);
2134 }
2135 
2136 inline std::string VarString::toString() const
2137 {
2138  return toStr(*this);
2139 }
2140 
2141 inline std::string MessageType::toString(MessageType::Enum value)
2142 {
2143  return toStr(value);
2144 }
2145 
2146 inline std::string Boolean::toString(Boolean::Enum value)
2147 {
2148  return toStr(value);
2149 }
2150 
2151 inline std::string TimeUnit::toString(TimeUnit::Enum value)
2152 {
2153  return toStr(value);
2154 }
2155 
2156 inline std::string Side::toString(Side::Enum value)
2157 {
2158  return toStr(value);
2159 }
2160 
2161 inline
2162 std::string
2163 SecurityUpdateAction::toString(
2165 {
2166  return toStr(value);
2167 }
2168 
2169 inline std::string LotType::toString(LotType::Enum value)
2170 {
2171  return toStr(value);
2172 }
2173 
2174 inline std::string Product::toString(Product::Enum value)
2175 {
2176  return toStr(value);
2177 }
2178 
2179 inline std::string SecurityType::toString(SecurityType::Enum value)
2180 {
2181  return toStr(value);
2182 }
2183 
2184 inline
2185 std::string
2186 ExerciseStyle::toString(
2187  ExerciseStyle::Enum value)
2188 {
2189  return toStr(value);
2190 }
2191 
2192 inline std::string PutOrCall::toString(PutOrCall::Enum value)
2193 {
2194  return toStr(value);
2195 }
2196 
2197 inline std::string PriceType::toString(PriceType::Enum value)
2198 {
2199  return toStr(value);
2200 }
2201 
2202 inline
2203 std::string
2204 SecurityTradingStatus::toString(
2206 {
2207  return toStr(value);
2208 }
2209 
2210 inline
2211 std::string
2212 TradingSessionSubID::toString(
2214 {
2215  return toStr(value);
2216 }
2217 
2218 inline
2219 std::string
2220 GovernanceIndicator::toString(
2222 {
2223  return toStr(value);
2224 }
2225 
2226 inline
2227 std::string
2228 SecurityMatchType::toString(
2230 {
2231  return toStr(value);
2232 }
2233 
2234 inline
2235 std::string
2236 AggressorSide::toString(
2237  AggressorSide::Enum value)
2238 {
2239  return toStr(value);
2240 }
2241 
2242 inline
2243 std::string
2244 TradingSessionID::toString(
2245  TradingSessionID::Enum value)
2246 {
2247  return toStr(value);
2248 }
2249 
2250 inline
2251 std::string
2252 SecurityTradingEvent::toString(
2254 {
2255  return toStr(value);
2256 }
2257 
2258 inline
2259 std::string
2260 PriceBandType::toString(
2261  PriceBandType::Enum value)
2262 {
2263  return toStr(value);
2264 }
2265 
2266 inline
2267 std::string
2268 OpenCloseSettlFlag::toString(
2270 {
2271  return toStr(value);
2272 }
2273 
2274 inline
2275 std::string
2276 PriceLimitType::toString(
2277  PriceLimitType::Enum value)
2278 {
2279  return toStr(value);
2280 }
2281 
2282 inline
2283 std::string
2284 PriceBandMidpointPriceType::toString(
2286 {
2287  return toStr(value);
2288 }
2289 
2290 inline
2291 std::string
2292 SettlPriceType::toString(
2293  SettlPriceType::Enum value)
2294 {
2295  return toStr(value);
2296 }
2297 
2298 inline
2299 std::string
2300 UnderlyingPxType::toString(
2301  UnderlyingPxType::Enum value)
2302 {
2303  return toStr(value);
2304 }
2305 
2306 inline std::string UpdateAction::toString(UpdateAction::Enum value)
2307 {
2308  return toStr(value);
2309 }
2310 
2311 inline std::string EntryType::toString(EntryType::Enum value)
2312 {
2313  return toStr(value);
2314 }
2315 
2316 inline std::string NewsSource::toString(NewsSource::Enum value)
2317 {
2318  return toStr(value);
2319 }
2320 
2321 inline std::string ApplVerID::toString(ApplVerID::Enum value)
2322 {
2323  return toStr(value);
2324 }
2325 
2326 inline
2327 std::string
2328 MultiLegModel::toString(
2329  MultiLegModel::Enum value)
2330 {
2331  return toStr(value);
2332 }
2333 
2334 inline
2335 std::string
2336 MultiLegPriceMethod::toString(
2338 {
2339  return toStr(value);
2340 }
2341 
2342 inline
2343 std::string
2344 InstrAttribType::toString(
2345  InstrAttribType::Enum value)
2346 {
2347  return toStr(value);
2348 }
2349 
2350 inline
2351 std::string
2352 InstrAttribValue::toString(
2353  InstrAttribValue::Enum value)
2354 {
2355  return toStr(value);
2356 }
2357 
2358 inline
2359 std::string
2360 SecurityIDSource::toString(
2361  SecurityIDSource::Enum value)
2362 {
2363  return toStr(value);
2364 }
2365 
2366 inline std::string TrdSubType::toString(TrdSubType::Enum value)
2367 {
2368  return toStr(value);
2369 }
2370 
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:1629
Set of conditions describing an imbalance..
Definition: Fields.h:1423
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:714
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:846
Enum
Indicates whether an option contract is a put or call.
Definition: Fields.h:568
Set of conditions describing a trade..
Definition: Fields.h:1506
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
void toFix(std::string &str, MatchEventIndicator set)
Serializes the object into FIX presentation.